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 0x00f5 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00f5, 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 0x52b0f196 0026 11 GT 0027 61 PUSH2 0x0097 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0097, if 0x52b0f196 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x52b0f196 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa9059cbb 0031 11 GT 0032 61 PUSH2 0x0066 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0xa9059cbb > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa9059cbb > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xa9059cbb 003C 14 EQ 003D 61 PUSH2 0x0626 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0626, if 0xa9059cbb == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xb2bdfa7b 0047 14 EQ 0048 61 PUSH2 0x068c 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068c, if 0xb2bdfa7b == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xb2bdfa7b == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xdd62ed3e 0052 14 EQ 0053 61 PUSH2 0x06d6 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d6, if 0xdd62ed3e == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe1268115 005D 14 EQ 005E 61 PUSH2 0x074e 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x074e, if 0xe1268115 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe1268115 == stack[-1] 0062 61 PUSH2 0x00f5 0065 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_0066: // Incoming jump from 0x0035, if 0xa9059cbb > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0x52b0f196 006D 14 EQ 006E 61 PUSH2 0x03b1 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b1, if 0x52b0f196 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0x52b0f196 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0x70a08231 0078 14 EQ 0079 61 PUSH2 0x0507 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0507, if 0x70a08231 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x70a08231 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x80b2122e 0083 14 EQ 0084 61 PUSH2 0x055f 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055f, if 0x80b2122e == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x80b2122e == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x95d89b41 008E 14 EQ 008F 61 PUSH2 0x05a3 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a3, if 0x95d89b41 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x95d89b41 == stack[-1] 0093 61 PUSH2 0x00f5 0096 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_0097: // Incoming jump from 0x002A, if 0x52b0f196 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x18160ddd 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x18160ddd > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x18160ddd > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x18160ddd 00A9 14 EQ 00AA 61 PUSH2 0x029b 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029b, if 0x18160ddd == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x18160ddd == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x23b872dd 00B4 14 EQ 00B5 61 PUSH2 0x02b9 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b9, if 0x23b872dd == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x23b872dd == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x313ce567 00BF 14 EQ 00C0 61 PUSH2 0x033f 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033f, if 0x313ce567 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x313ce567 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x4e6ec247 00CA 14 EQ 00CB 61 PUSH2 0x0363 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0363, if 0x4e6ec247 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x4e6ec247 == stack[-1] 00CF 61 PUSH2 0x00f5 00D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00f5 label_00D3: // Incoming jump from 0x00A2, if 0x18160ddd > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x043fa39e 00DA 14 EQ 00DB 61 PUSH2 0x00fa 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fa, if 0x043fa39e == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x043fa39e == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x06fdde03 00E5 14 EQ 00E6 61 PUSH2 0x01b2 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b2, if 0x06fdde03 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x06fdde03 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x095ea7b3 00F0 14 EQ 00F1 61 PUSH2 0x0235 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0235, if 0x095ea7b3 == stack[-1] label_00F5: // Incoming jump from 0x00D2 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0096 // Incoming jump from 0x0065 // Incoming jump from 0x00F4, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @00F9 memory[0x00:0x00] } 00F5 5B JUMPDEST 00F6 60 PUSH1 0x00 00F8 80 DUP1 00F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F9 revert(memory[0x00:0x00]); } // Block terminates label_00FA: // Incoming jump from 0x00DE, if 0x043fa39e == stack[-1] // Inputs[1] { @0101 msg.data.length } 00FA 5B JUMPDEST 00FB 61 PUSH2 0x01b0 00FE 60 PUSH1 0x04 0100 80 DUP1 0101 36 CALLDATASIZE 0102 03 SUB 0103 60 PUSH1 0x20 0105 81 DUP2 0106 10 LT 0107 15 ISZERO 0108 61 PUSH2 0x0110 010B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @00FB stack[0] = 0x01b0 // @00FE stack[1] = 0x04 // @0102 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0110, returns to 0x01B0, if !(msg.data.length - 0x04 < 0x20) label_010C: // Incoming jump from 0x010B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @010F memory[0x00:0x00] } 010C 60 PUSH1 0x00 010E 80 DUP1 010F FD *REVERT // Stack delta = +0 // Outputs[1] { @010F revert(memory[0x00:0x00]); } // Block terminates label_0110: // Incoming call from 0x010B, returns to 0x01B0, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0111 stack[-2] // @0112 stack[-1] // @0116 msg.data[stack[-2]:stack[-2] + 0x20] // } 0110 5B JUMPDEST 0111 81 DUP2 0112 01 ADD 0113 90 SWAP1 0114 80 DUP1 0115 80 DUP1 0116 35 CALLDATALOAD 0117 90 SWAP1 0118 60 PUSH1 0x20 011A 01 ADD 011B 90 SWAP1 011C 64 PUSH5 0x0100000000 0122 81 DUP2 0123 11 GT 0124 15 ISZERO 0125 61 PUSH2 0x012d 0128 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0113 stack[-1] = stack[-2] // @0113 stack[-2] = stack[-2] + stack[-1] // @011B stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @011B stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x012d, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0129: // Incoming jump from 0x0128, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @012C memory[0x00:0x00] } 0129 60 PUSH1 0x00 012B 80 DUP1 012C FD *REVERT // Stack delta = +0 // Outputs[1] { @012C revert(memory[0x00:0x00]); } // Block terminates label_012D: // Incoming jump from 0x0128, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @012E stack[-3] // @012F stack[-1] // @0130 stack[-4] // } 012D 5B JUMPDEST 012E 82 DUP3 012F 01 ADD 0130 83 DUP4 0131 60 PUSH1 0x20 0133 82 DUP3 0134 01 ADD 0135 11 GT 0136 15 ISZERO 0137 61 PUSH2 0x013f 013A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @012F stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x013f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_013B: // Incoming jump from 0x013A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @013E memory[0x00:0x00] } 013B 60 PUSH1 0x00 013D 80 DUP1 013E FD *REVERT // Stack delta = +0 // Outputs[1] { @013E revert(memory[0x00:0x00]); } // Block terminates label_013F: // Incoming jump from 0x013A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0140 stack[-1] // @0141 msg.data[stack[-1]:stack[-1] + 0x20] // @0146 stack[-2] // @0147 stack[-4] // } 013F 5B JUMPDEST 0140 80 DUP1 0141 35 CALLDATALOAD 0142 90 SWAP1 0143 60 PUSH1 0x20 0145 01 ADD 0146 91 SWAP2 0147 84 DUP5 0148 60 PUSH1 0x20 014A 83 DUP4 014B 02 MUL 014C 84 DUP5 014D 01 ADD 014E 11 GT 014F 64 PUSH5 0x0100000000 0155 83 DUP4 0156 11 GT 0157 17 OR 0158 15 ISZERO 0159 61 PUSH2 0x0161 015C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0142 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0146 stack[0] = stack[-2] // @0146 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0161, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_015D: // Incoming jump from 0x015C, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0160 memory[0x00:0x00] } 015D 60 PUSH1 0x00 015F 80 DUP1 0160 FD *REVERT // Stack delta = +0 // Outputs[1] { @0160 revert(memory[0x00:0x00]); } // Block terminates label_0161: // Incoming jump from 0x015C, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @0162 stack[-3] // @0162 stack[-1] // @0163 stack[-2] // @016E memory[0x40:0x60] // @0188 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @01A4 stack[-4] // @01A5 stack[-5] // } 0161 5B JUMPDEST 0162 91 SWAP2 0163 90 SWAP1 0164 80 DUP1 0165 80 DUP1 0166 60 PUSH1 0x20 0168 02 MUL 0169 60 PUSH1 0x20 016B 01 ADD 016C 60 PUSH1 0x40 016E 51 MLOAD 016F 90 SWAP1 0170 81 DUP2 0171 01 ADD 0172 60 PUSH1 0x40 0174 52 MSTORE 0175 80 DUP1 0176 93 SWAP4 0177 92 SWAP3 0178 91 SWAP2 0179 90 SWAP1 017A 81 DUP2 017B 81 DUP2 017C 52 MSTORE 017D 60 PUSH1 0x20 017F 01 ADD 0180 83 DUP4 0181 83 DUP4 0182 60 PUSH1 0x20 0184 02 MUL 0185 80 DUP1 0186 82 DUP3 0187 84 DUP5 0188 37 CALLDATACOPY 0189 60 PUSH1 0x00 018B 81 DUP2 018C 84 DUP5 018D 01 ADD 018E 52 MSTORE 018F 60 PUSH1 0x1f 0191 19 NOT 0192 60 PUSH1 0x1f 0194 82 DUP3 0195 01 ADD 0196 16 AND 0197 90 SWAP1 0198 50 POP 0199 80 DUP1 019A 83 DUP4 019B 01 ADD 019C 92 SWAP3 019D 50 POP 019E 50 POP 019F 50 POP 01A0 50 POP 01A1 50 POP 01A2 50 POP 01A3 50 POP 01A4 91 SWAP2 01A5 92 SWAP3 01A6 91 SWAP2 01A7 92 SWAP3 01A8 90 SWAP1 01A9 50 POP 01AA 50 POP 01AB 50 POP 01AC 61 PUSH2 0x0806 01AF 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0174 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @017C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0188 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @018E memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @01A7 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0806 label_01B0: // Incoming return from call to 0x0110 at 0x010B 01B0 5B JUMPDEST 01B1 00 *STOP // Stack delta = +0 // Outputs[1] { @01B1 stop(); } // Block terminates label_01B2: // Incoming jump from 0x00E9, if 0x06fdde03 == stack[-1] 01B2 5B JUMPDEST 01B3 61 PUSH2 0x01ba 01B6 61 PUSH2 0x09bf 01B9 56 *JUMP // Stack delta = +1 // Outputs[1] { @01B3 stack[0] = 0x01ba } // Block ends with call to 0x09bf, returns to 0x01BA label_01BA: // Incoming return from call to 0x09BF at 0x01B9 // Inputs[4] // { // @01BD memory[0x40:0x60] // @01C8 stack[-1] // @01CB memory[stack[-1]:stack[-1] + 0x20] // @01D4 memory[stack[-1]:stack[-1] + 0x20] // } 01BA 5B JUMPDEST 01BB 60 PUSH1 0x40 01BD 51 MLOAD 01BE 80 DUP1 01BF 80 DUP1 01C0 60 PUSH1 0x20 01C2 01 ADD 01C3 82 DUP3 01C4 81 DUP2 01C5 03 SUB 01C6 82 DUP3 01C7 52 MSTORE 01C8 83 DUP4 01C9 81 DUP2 01CA 81 DUP2 01CB 51 MLOAD 01CC 81 DUP2 01CD 52 MSTORE 01CE 60 PUSH1 0x20 01D0 01 ADD 01D1 91 SWAP2 01D2 50 POP 01D3 80 DUP1 01D4 51 MLOAD 01D5 90 SWAP1 01D6 60 PUSH1 0x20 01D8 01 ADD 01D9 90 SWAP1 01DA 80 DUP1 01DB 83 DUP4 01DC 83 DUP4 01DD 60 PUSH1 0x00 01DF 5B JUMPDEST 01E0 83 DUP4 01E1 81 DUP2 01E2 10 LT 01E3 15 ISZERO 01E4 61 PUSH2 0x01fa 01E7 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01BD stack[0] = memory[0x40:0x60] // @01BE stack[1] = memory[0x40:0x60] // @01C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @01CD memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @01D1 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @01D9 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @01D9 stack[3] = 0x20 + stack[-1] // @01DA stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @01DB stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @01DC stack[7] = 0x20 + stack[-1] // @01DD stack[8] = 0x00 // } // Block ends with conditional jump to 0x01fa, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_01E8: // Incoming jump from 0x01E7, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x01E7, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @01E8 stack[-1] // @01E9 stack[-2] // @01EB memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01ED stack[-3] // } 01E8 80 DUP1 01E9 82 DUP3 01EA 01 ADD 01EB 51 MLOAD 01EC 81 DUP2 01ED 84 DUP5 01EE 01 ADD 01EF 52 MSTORE 01F0 60 PUSH1 0x20 01F2 81 DUP2 01F3 01 ADD 01F4 90 SWAP1 01F5 50 POP 01F6 61 PUSH2 0x01df 01F9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01EF memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @01F4 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x01df label_01FA: // Incoming jump from 0x01E7, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x01E7, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @01FF stack[-5] // @01FF stack[-6] // @0201 stack[-7] // } 01FA 5B JUMPDEST 01FB 50 POP 01FC 50 POP 01FD 50 POP 01FE 50 POP 01FF 90 SWAP1 0200 50 POP 0201 90 SWAP1 0202 81 DUP2 0203 01 ADD 0204 90 SWAP1 0205 60 PUSH1 0x1f 0207 16 AND 0208 80 DUP1 0209 15 ISZERO 020A 61 PUSH2 0x0227 020D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0204 stack[-7] = stack[-5] + stack[-7] // @0207 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0227, if !(0x1f & stack[-5]) label_020E: // Incoming jump from 0x020D, if not !(0x1f & stack[-5]) // Inputs[6] // { // @020E stack[-1] // @020F stack[-2] // @0212 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0229 stack[-5] // @022F memory[0x40:0x60] // @0234 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 020E 80 DUP1 020F 82 DUP3 0210 03 SUB 0211 80 DUP1 0212 51 MLOAD 0213 60 PUSH1 0x01 0215 83 DUP4 0216 60 PUSH1 0x20 0218 03 SUB 0219 61 PUSH2 0x0100 021C 0A EXP 021D 03 SUB 021E 19 NOT 021F 16 AND 0220 81 DUP2 0221 52 MSTORE 0222 60 PUSH1 0x20 0224 01 ADD 0225 91 SWAP2 0226 50 POP 0227 5B JUMPDEST 0228 50 POP 0229 92 SWAP3 022A 50 POP 022B 50 POP 022C 50 POP 022D 60 PUSH1 0x40 022F 51 MLOAD 0230 80 DUP1 0231 91 SWAP2 0232 03 SUB 0233 90 SWAP1 0234 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0221 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] // @0234 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0235: // Incoming jump from 0x00F4, if 0x095ea7b3 == stack[-1] // Inputs[1] { @023C msg.data.length } 0235 5B JUMPDEST 0236 61 PUSH2 0x0281 0239 60 PUSH1 0x04 023B 80 DUP1 023C 36 CALLDATASIZE 023D 03 SUB 023E 60 PUSH1 0x40 0240 81 DUP2 0241 10 LT 0242 15 ISZERO 0243 61 PUSH2 0x024b 0246 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0236 stack[0] = 0x0281 // @0239 stack[1] = 0x04 // @023D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x024b, returns to 0x0281, if !(msg.data.length - 0x04 < 0x40) label_0247: // Incoming jump from 0x0246, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @024A memory[0x00:0x00] } 0247 60 PUSH1 0x00 0249 80 DUP1 024A FD *REVERT // Stack delta = +0 // Outputs[1] { @024A revert(memory[0x00:0x00]); } // Block terminates label_024B: // Incoming call from 0x0246, returns to 0x0281, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @024C stack[-2] // @024D stack[-1] // @0251 msg.data[stack[-2]:stack[-2] + 0x20] // @0271 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 024B 5B JUMPDEST 024C 81 DUP2 024D 01 ADD 024E 90 SWAP1 024F 80 DUP1 0250 80 DUP1 0251 35 CALLDATALOAD 0252 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0267 16 AND 0268 90 SWAP1 0269 60 PUSH1 0x20 026B 01 ADD 026C 90 SWAP1 026D 92 SWAP3 026E 91 SWAP2 026F 90 SWAP1 0270 80 DUP1 0271 35 CALLDATALOAD 0272 90 SWAP1 0273 60 PUSH1 0x20 0275 01 ADD 0276 90 SWAP1 0277 92 SWAP3 0278 91 SWAP2 0279 90 SWAP1 027A 50 POP 027B 50 POP 027C 50 POP 027D 61 PUSH2 0x0a61 0280 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @026D stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0277 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0a61 label_0281: // Incoming return from call to 0x024B at 0x0246 // Inputs[4] // { // @0284 memory[0x40:0x60] // @0286 stack[-1] // @0295 memory[0x40:0x60] // @029A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0281 5B JUMPDEST 0282 60 PUSH1 0x40 0284 51 MLOAD 0285 80 DUP1 0286 82 DUP3 0287 15 ISZERO 0288 15 ISZERO 0289 15 ISZERO 028A 15 ISZERO 028B 81 DUP2 028C 52 MSTORE 028D 60 PUSH1 0x20 028F 01 ADD 0290 91 SWAP2 0291 50 POP 0292 50 POP 0293 60 PUSH1 0x40 0295 51 MLOAD 0296 80 DUP1 0297 91 SWAP2 0298 03 SUB 0299 90 SWAP1 029A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @028C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @029A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_029B: // Incoming jump from 0x00AD, if 0x18160ddd == stack[-1] 029B 5B JUMPDEST 029C 61 PUSH2 0x02a3 029F 61 PUSH2 0x0a7f 02A2 56 *JUMP // Stack delta = +1 // Outputs[1] { @029C stack[0] = 0x02a3 } // Block ends with call to 0x0a7f, returns to 0x02A3 label_02A3: // Incoming return from call to 0x0A7F at 0x02A2 // Inputs[4] // { // @02A6 memory[0x40:0x60] // @02A8 stack[-1] // @02B3 memory[0x40:0x60] // @02B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02A3 5B JUMPDEST 02A4 60 PUSH1 0x40 02A6 51 MLOAD 02A7 80 DUP1 02A8 82 DUP3 02A9 81 DUP2 02AA 52 MSTORE 02AB 60 PUSH1 0x20 02AD 01 ADD 02AE 91 SWAP2 02AF 50 POP 02B0 50 POP 02B1 60 PUSH1 0x40 02B3 51 MLOAD 02B4 80 DUP1 02B5 91 SWAP2 02B6 03 SUB 02B7 90 SWAP1 02B8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02B8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02B9: // Incoming jump from 0x00B8, if 0x23b872dd == stack[-1] // Inputs[1] { @02C0 msg.data.length } 02B9 5B JUMPDEST 02BA 61 PUSH2 0x0325 02BD 60 PUSH1 0x04 02BF 80 DUP1 02C0 36 CALLDATASIZE 02C1 03 SUB 02C2 60 PUSH1 0x60 02C4 81 DUP2 02C5 10 LT 02C6 15 ISZERO 02C7 61 PUSH2 0x02cf 02CA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02BA stack[0] = 0x0325 // @02BD stack[1] = 0x04 // @02C1 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02cf, returns to 0x0325, if !(msg.data.length - 0x04 < 0x60) label_02CB: // Incoming jump from 0x02CA, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @02CE memory[0x00:0x00] } 02CB 60 PUSH1 0x00 02CD 80 DUP1 02CE FD *REVERT // Stack delta = +0 // Outputs[1] { @02CE revert(memory[0x00:0x00]); } // Block terminates label_02CF: // Incoming call from 0x02CA, returns to 0x0325, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @02D0 stack[-2] // @02D1 stack[-1] // @02D5 msg.data[stack[-2]:stack[-2] + 0x20] // @02F5 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0315 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 02CF 5B JUMPDEST 02D0 81 DUP2 02D1 01 ADD 02D2 90 SWAP1 02D3 80 DUP1 02D4 80 DUP1 02D5 35 CALLDATALOAD 02D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02EB 16 AND 02EC 90 SWAP1 02ED 60 PUSH1 0x20 02EF 01 ADD 02F0 90 SWAP1 02F1 92 SWAP3 02F2 91 SWAP2 02F3 90 SWAP1 02F4 80 DUP1 02F5 35 CALLDATALOAD 02F6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 030B 16 AND 030C 90 SWAP1 030D 60 PUSH1 0x20 030F 01 ADD 0310 90 SWAP1 0311 92 SWAP3 0312 91 SWAP2 0313 90 SWAP1 0314 80 DUP1 0315 35 CALLDATALOAD 0316 90 SWAP1 0317 60 PUSH1 0x20 0319 01 ADD 031A 90 SWAP1 031B 92 SWAP3 031C 91 SWAP2 031D 90 SWAP1 031E 50 POP 031F 50 POP 0320 50 POP 0321 61 PUSH2 0x0a89 0324 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @02F1 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0311 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @031B stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0a89 label_0325: // Incoming return from call to 0x02CF at 0x02CA // Inputs[4] // { // @0328 memory[0x40:0x60] // @032A stack[-1] // @0339 memory[0x40:0x60] // @033E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0325 5B JUMPDEST 0326 60 PUSH1 0x40 0328 51 MLOAD 0329 80 DUP1 032A 82 DUP3 032B 15 ISZERO 032C 15 ISZERO 032D 15 ISZERO 032E 15 ISZERO 032F 81 DUP2 0330 52 MSTORE 0331 60 PUSH1 0x20 0333 01 ADD 0334 91 SWAP2 0335 50 POP 0336 50 POP 0337 60 PUSH1 0x40 0339 51 MLOAD 033A 80 DUP1 033B 91 SWAP2 033C 03 SUB 033D 90 SWAP1 033E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0330 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @033E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_033F: // Incoming jump from 0x00C3, if 0x313ce567 == stack[-1] 033F 5B JUMPDEST 0340 61 PUSH2 0x0347 0343 61 PUSH2 0x0b62 0346 56 *JUMP // Stack delta = +1 // Outputs[1] { @0340 stack[0] = 0x0347 } // Block ends with call to 0x0b62, returns to 0x0347 label_0347: // Incoming return from call to 0x0B62 at 0x0346 // Inputs[4] // { // @034A memory[0x40:0x60] // @034C stack[-1] // @035D memory[0x40:0x60] // @0362 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0347 5B JUMPDEST 0348 60 PUSH1 0x40 034A 51 MLOAD 034B 80 DUP1 034C 82 DUP3 034D 60 PUSH1 0xff 034F 16 AND 0350 60 PUSH1 0xff 0352 16 AND 0353 81 DUP2 0354 52 MSTORE 0355 60 PUSH1 0x20 0357 01 ADD 0358 91 SWAP2 0359 50 POP 035A 50 POP 035B 60 PUSH1 0x40 035D 51 MLOAD 035E 80 DUP1 035F 91 SWAP2 0360 03 SUB 0361 90 SWAP1 0362 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0354 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @0362 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0363: // Incoming jump from 0x00CE, if 0x4e6ec247 == stack[-1] // Inputs[1] { @036A msg.data.length } 0363 5B JUMPDEST 0364 61 PUSH2 0x03af 0367 60 PUSH1 0x04 0369 80 DUP1 036A 36 CALLDATASIZE 036B 03 SUB 036C 60 PUSH1 0x40 036E 81 DUP2 036F 10 LT 0370 15 ISZERO 0371 61 PUSH2 0x0379 0374 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0364 stack[0] = 0x03af // @0367 stack[1] = 0x04 // @036B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0379, returns to 0x03AF, if !(msg.data.length - 0x04 < 0x40) label_0375: // Incoming jump from 0x0374, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0378 memory[0x00:0x00] } 0375 60 PUSH1 0x00 0377 80 DUP1 0378 FD *REVERT // Stack delta = +0 // Outputs[1] { @0378 revert(memory[0x00:0x00]); } // Block terminates label_0379: // Incoming call from 0x0374, returns to 0x03AF, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @037A stack[-2] // @037B stack[-1] // @037F msg.data[stack[-2]:stack[-2] + 0x20] // @039F msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0379 5B JUMPDEST 037A 81 DUP2 037B 01 ADD 037C 90 SWAP1 037D 80 DUP1 037E 80 DUP1 037F 35 CALLDATALOAD 0380 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0395 16 AND 0396 90 SWAP1 0397 60 PUSH1 0x20 0399 01 ADD 039A 90 SWAP1 039B 92 SWAP3 039C 91 SWAP2 039D 90 SWAP1 039E 80 DUP1 039F 35 CALLDATALOAD 03A0 90 SWAP1 03A1 60 PUSH1 0x20 03A3 01 ADD 03A4 90 SWAP1 03A5 92 SWAP3 03A6 91 SWAP2 03A7 90 SWAP1 03A8 50 POP 03A9 50 POP 03AA 50 POP 03AB 61 PUSH2 0x0b79 03AE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @039B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @03A5 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b79 label_03AF: // Incoming return from call to 0x0379 at 0x0374 03AF 5B JUMPDEST 03B0 00 *STOP // Stack delta = +0 // Outputs[1] { @03B0 stop(); } // Block terminates label_03B1: // Incoming jump from 0x0071, if 0x52b0f196 == stack[-1] // Inputs[1] { @03B8 msg.data.length } 03B1 5B JUMPDEST 03B2 61 PUSH2 0x0505 03B5 60 PUSH1 0x04 03B7 80 DUP1 03B8 36 CALLDATASIZE 03B9 03 SUB 03BA 60 PUSH1 0x60 03BC 81 DUP2 03BD 10 LT 03BE 15 ISZERO 03BF 61 PUSH2 0x03c7 03C2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03B2 stack[0] = 0x0505 // @03B5 stack[1] = 0x04 // @03B9 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03c7, returns to 0x0505, if !(msg.data.length - 0x04 < 0x60) label_03C3: // Incoming jump from 0x03C2, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @03C6 memory[0x00:0x00] } 03C3 60 PUSH1 0x00 03C5 80 DUP1 03C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C6 revert(memory[0x00:0x00]); } // Block terminates label_03C7: // Incoming call from 0x03C2, returns to 0x0505, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @03C8 stack[-2] // @03C9 stack[-1] // @03CD msg.data[stack[-2]:stack[-2] + 0x20] // @03D7 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 03C7 5B JUMPDEST 03C8 81 DUP2 03C9 01 ADD 03CA 90 SWAP1 03CB 80 DUP1 03CC 80 DUP1 03CD 35 CALLDATALOAD 03CE 90 SWAP1 03CF 60 PUSH1 0x20 03D1 01 ADD 03D2 90 SWAP1 03D3 92 SWAP3 03D4 91 SWAP2 03D5 90 SWAP1 03D6 80 DUP1 03D7 35 CALLDATALOAD 03D8 90 SWAP1 03D9 60 PUSH1 0x20 03DB 01 ADD 03DC 90 SWAP1 03DD 64 PUSH5 0x0100000000 03E3 81 DUP2 03E4 11 GT 03E5 15 ISZERO 03E6 61 PUSH2 0x03ee 03E9 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @03D3 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @03D4 stack[-1] = stack[-2] + stack[-1] // @03D5 stack[0] = stack[-2] // @03DC stack[1] = 0x20 + 0x20 + stack[-2] // @03DC stack[2] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with conditional jump to 0x03ee, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) label_03EA: // Incoming jump from 0x03E9, if not !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @03ED memory[0x00:0x00] } 03EA 60 PUSH1 0x00 03EC 80 DUP1 03ED FD *REVERT // Stack delta = +0 // Outputs[1] { @03ED revert(memory[0x00:0x00]); } // Block terminates label_03EE: // Incoming jump from 0x03E9, if !(msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @03EF stack[-3] // @03F0 stack[-1] // @03F1 stack[-4] // } 03EE 5B JUMPDEST 03EF 82 DUP3 03F0 01 ADD 03F1 83 DUP4 03F2 60 PUSH1 0x20 03F4 82 DUP3 03F5 01 ADD 03F6 11 GT 03F7 15 ISZERO 03F8 61 PUSH2 0x0400 03FB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03F0 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0400, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_03FC: // Incoming jump from 0x03FB, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @03FF memory[0x00:0x00] } 03FC 60 PUSH1 0x00 03FE 80 DUP1 03FF FD *REVERT // Stack delta = +0 // Outputs[1] { @03FF revert(memory[0x00:0x00]); } // Block terminates label_0400: // Incoming jump from 0x03FB, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0401 stack[-1] // @0402 msg.data[stack[-1]:stack[-1] + 0x20] // @0407 stack[-2] // @0408 stack[-4] // } 0400 5B JUMPDEST 0401 80 DUP1 0402 35 CALLDATALOAD 0403 90 SWAP1 0404 60 PUSH1 0x20 0406 01 ADD 0407 91 SWAP2 0408 84 DUP5 0409 60 PUSH1 0x20 040B 83 DUP4 040C 02 MUL 040D 84 DUP5 040E 01 ADD 040F 11 GT 0410 64 PUSH5 0x0100000000 0416 83 DUP4 0417 11 GT 0418 17 OR 0419 15 ISZERO 041A 61 PUSH2 0x0422 041D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0403 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0407 stack[0] = stack[-2] // @0407 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0422, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_041E: // Incoming jump from 0x041D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0421 memory[0x00:0x00] } 041E 60 PUSH1 0x00 0420 80 DUP1 0421 FD *REVERT // Stack delta = +0 // Outputs[1] { @0421 revert(memory[0x00:0x00]); } // Block terminates label_0422: // Incoming jump from 0x041D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0423 stack[-3] // @0423 stack[-1] // @0424 stack[-2] // @042F memory[0x40:0x60] // @0449 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0465 stack[-4] // @0466 stack[-5] // @046B msg.data[stack[-1]:stack[-1] + 0x20] // } 0422 5B JUMPDEST 0423 91 SWAP2 0424 90 SWAP1 0425 80 DUP1 0426 80 DUP1 0427 60 PUSH1 0x20 0429 02 MUL 042A 60 PUSH1 0x20 042C 01 ADD 042D 60 PUSH1 0x40 042F 51 MLOAD 0430 90 SWAP1 0431 81 DUP2 0432 01 ADD 0433 60 PUSH1 0x40 0435 52 MSTORE 0436 80 DUP1 0437 93 SWAP4 0438 92 SWAP3 0439 91 SWAP2 043A 90 SWAP1 043B 81 DUP2 043C 81 DUP2 043D 52 MSTORE 043E 60 PUSH1 0x20 0440 01 ADD 0441 83 DUP4 0442 83 DUP4 0443 60 PUSH1 0x20 0445 02 MUL 0446 80 DUP1 0447 82 DUP3 0448 84 DUP5 0449 37 CALLDATACOPY 044A 60 PUSH1 0x00 044C 81 DUP2 044D 84 DUP5 044E 01 ADD 044F 52 MSTORE 0450 60 PUSH1 0x1f 0452 19 NOT 0453 60 PUSH1 0x1f 0455 82 DUP3 0456 01 ADD 0457 16 AND 0458 90 SWAP1 0459 50 POP 045A 80 DUP1 045B 83 DUP4 045C 01 ADD 045D 92 SWAP3 045E 50 POP 045F 50 POP 0460 50 POP 0461 50 POP 0462 50 POP 0463 50 POP 0464 50 POP 0465 91 SWAP2 0466 92 SWAP3 0467 91 SWAP2 0468 92 SWAP3 0469 90 SWAP1 046A 80 DUP1 046B 35 CALLDATALOAD 046C 90 SWAP1 046D 60 PUSH1 0x20 046F 01 ADD 0470 90 SWAP1 0471 64 PUSH5 0x0100000000 0477 81 DUP2 0478 11 GT 0479 15 ISZERO 047A 61 PUSH2 0x0482 047D 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0435 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @043D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0449 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @044F memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0467 stack[-4] = stack[-5] // @0468 stack[-5] = memory[0x40:0x60] // @0469 stack[-3] = stack[-4] // @0470 stack[-2] = 0x20 + stack[-1] // @0470 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0482, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_047E: // Incoming jump from 0x047D, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @0481 memory[0x00:0x00] } 047E 60 PUSH1 0x00 0480 80 DUP1 0481 FD *REVERT // Stack delta = +0 // Outputs[1] { @0481 revert(memory[0x00:0x00]); } // Block terminates label_0482: // Incoming jump from 0x047D, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @0483 stack[-3] // @0484 stack[-1] // @0485 stack[-4] // } 0482 5B JUMPDEST 0483 82 DUP3 0484 01 ADD 0485 83 DUP4 0486 60 PUSH1 0x20 0488 82 DUP3 0489 01 ADD 048A 11 GT 048B 15 ISZERO 048C 61 PUSH2 0x0494 048F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0484 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0494, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0490: // Incoming jump from 0x048F, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0493 memory[0x00:0x00] } 0490 60 PUSH1 0x00 0492 80 DUP1 0493 FD *REVERT // Stack delta = +0 // Outputs[1] { @0493 revert(memory[0x00:0x00]); } // Block terminates label_0494: // Incoming jump from 0x048F, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0495 stack[-1] // @0496 msg.data[stack[-1]:stack[-1] + 0x20] // @049B stack[-2] // @049C stack[-4] // } 0494 5B JUMPDEST 0495 80 DUP1 0496 35 CALLDATALOAD 0497 90 SWAP1 0498 60 PUSH1 0x20 049A 01 ADD 049B 91 SWAP2 049C 84 DUP5 049D 60 PUSH1 0x20 049F 83 DUP4 04A0 02 MUL 04A1 84 DUP5 04A2 01 ADD 04A3 11 GT 04A4 64 PUSH5 0x0100000000 04AA 83 DUP4 04AB 11 GT 04AC 17 OR 04AD 15 ISZERO 04AE 61 PUSH2 0x04b6 04B1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0497 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @049B stack[0] = stack[-2] // @049B stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x04b6, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_04B2: // Incoming jump from 0x04B1, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @04B5 memory[0x00:0x00] } 04B2 60 PUSH1 0x00 04B4 80 DUP1 04B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B5 revert(memory[0x00:0x00]); } // Block terminates label_04B6: // Incoming jump from 0x04B1, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @04B7 stack[-3] // @04B7 stack[-1] // @04B8 stack[-2] // @04C3 memory[0x40:0x60] // @04DD msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @04F9 stack[-4] // @04FA stack[-5] // } 04B6 5B JUMPDEST 04B7 91 SWAP2 04B8 90 SWAP1 04B9 80 DUP1 04BA 80 DUP1 04BB 60 PUSH1 0x20 04BD 02 MUL 04BE 60 PUSH1 0x20 04C0 01 ADD 04C1 60 PUSH1 0x40 04C3 51 MLOAD 04C4 90 SWAP1 04C5 81 DUP2 04C6 01 ADD 04C7 60 PUSH1 0x40 04C9 52 MSTORE 04CA 80 DUP1 04CB 93 SWAP4 04CC 92 SWAP3 04CD 91 SWAP2 04CE 90 SWAP1 04CF 81 DUP2 04D0 81 DUP2 04D1 52 MSTORE 04D2 60 PUSH1 0x20 04D4 01 ADD 04D5 83 DUP4 04D6 83 DUP4 04D7 60 PUSH1 0x20 04D9 02 MUL 04DA 80 DUP1 04DB 82 DUP3 04DC 84 DUP5 04DD 37 CALLDATACOPY 04DE 60 PUSH1 0x00 04E0 81 DUP2 04E1 84 DUP5 04E2 01 ADD 04E3 52 MSTORE 04E4 60 PUSH1 0x1f 04E6 19 NOT 04E7 60 PUSH1 0x1f 04E9 82 DUP3 04EA 01 ADD 04EB 16 AND 04EC 90 SWAP1 04ED 50 POP 04EE 80 DUP1 04EF 83 DUP4 04F0 01 ADD 04F1 92 SWAP3 04F2 50 POP 04F3 50 POP 04F4 50 POP 04F5 50 POP 04F6 50 POP 04F7 50 POP 04F8 50 POP 04F9 91 SWAP2 04FA 92 SWAP3 04FB 91 SWAP2 04FC 92 SWAP3 04FD 90 SWAP1 04FE 50 POP 04FF 50 POP 0500 50 POP 0501 61 PUSH2 0x0d98 0504 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @04C9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @04D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @04DD memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @04E3 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @04FC stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0d98 label_0505: // Incoming return from call to 0x03C7 at 0x03C2 0505 5B JUMPDEST 0506 00 *STOP // Stack delta = +0 // Outputs[1] { @0506 stop(); } // Block terminates label_0507: // Incoming jump from 0x007C, if 0x70a08231 == stack[-1] // Inputs[1] { @050E msg.data.length } 0507 5B JUMPDEST 0508 61 PUSH2 0x0549 050B 60 PUSH1 0x04 050D 80 DUP1 050E 36 CALLDATASIZE 050F 03 SUB 0510 60 PUSH1 0x20 0512 81 DUP2 0513 10 LT 0514 15 ISZERO 0515 61 PUSH2 0x051d 0518 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0508 stack[0] = 0x0549 // @050B stack[1] = 0x04 // @050F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x051d, returns to 0x0549, if !(msg.data.length - 0x04 < 0x20) label_0519: // Incoming jump from 0x0518, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @051C memory[0x00:0x00] } 0519 60 PUSH1 0x00 051B 80 DUP1 051C FD *REVERT // Stack delta = +0 // Outputs[1] { @051C revert(memory[0x00:0x00]); } // Block terminates label_051D: // Incoming call from 0x0518, returns to 0x0549, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @051E stack[-2] // @051F stack[-1] // @0523 msg.data[stack[-2]:stack[-2] + 0x20] // } 051D 5B JUMPDEST 051E 81 DUP2 051F 01 ADD 0520 90 SWAP1 0521 80 DUP1 0522 80 DUP1 0523 35 CALLDATALOAD 0524 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0539 16 AND 053A 90 SWAP1 053B 60 PUSH1 0x20 053D 01 ADD 053E 90 SWAP1 053F 92 SWAP3 0540 91 SWAP2 0541 90 SWAP1 0542 50 POP 0543 50 POP 0544 50 POP 0545 61 PUSH2 0x0f81 0548 56 *JUMP // Stack delta = -1 // Outputs[1] { @053F stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0f81 label_0549: // Incoming return from call to 0x051D at 0x0518 // Inputs[4] // { // @054C memory[0x40:0x60] // @054E stack[-1] // @0559 memory[0x40:0x60] // @055E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0549 5B JUMPDEST 054A 60 PUSH1 0x40 054C 51 MLOAD 054D 80 DUP1 054E 82 DUP3 054F 81 DUP2 0550 52 MSTORE 0551 60 PUSH1 0x20 0553 01 ADD 0554 91 SWAP2 0555 50 POP 0556 50 POP 0557 60 PUSH1 0x40 0559 51 MLOAD 055A 80 DUP1 055B 91 SWAP2 055C 03 SUB 055D 90 SWAP1 055E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0550 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @055E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_055F: // Incoming jump from 0x0087, if 0x80b2122e == stack[-1] // Inputs[1] { @0566 msg.data.length } 055F 5B JUMPDEST 0560 61 PUSH2 0x05a1 0563 60 PUSH1 0x04 0565 80 DUP1 0566 36 CALLDATASIZE 0567 03 SUB 0568 60 PUSH1 0x20 056A 81 DUP2 056B 10 LT 056C 15 ISZERO 056D 61 PUSH2 0x0575 0570 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0560 stack[0] = 0x05a1 // @0563 stack[1] = 0x04 // @0567 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0575, returns to 0x05A1, if !(msg.data.length - 0x04 < 0x20) label_0571: // Incoming jump from 0x0570, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0574 memory[0x00:0x00] } 0571 60 PUSH1 0x00 0573 80 DUP1 0574 FD *REVERT // Stack delta = +0 // Outputs[1] { @0574 revert(memory[0x00:0x00]); } // Block terminates label_0575: // Incoming call from 0x0570, returns to 0x05A1, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0576 stack[-2] // @0577 stack[-1] // @057B msg.data[stack[-2]:stack[-2] + 0x20] // } 0575 5B JUMPDEST 0576 81 DUP2 0577 01 ADD 0578 90 SWAP1 0579 80 DUP1 057A 80 DUP1 057B 35 CALLDATALOAD 057C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0591 16 AND 0592 90 SWAP1 0593 60 PUSH1 0x20 0595 01 ADD 0596 90 SWAP1 0597 92 SWAP3 0598 91 SWAP2 0599 90 SWAP1 059A 50 POP 059B 50 POP 059C 50 POP 059D 61 PUSH2 0x0fc9 05A0 56 *JUMP // Stack delta = -1 // Outputs[1] { @0597 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0fc9 label_05A1: // Incoming return from call to 0x0575 at 0x0570 05A1 5B JUMPDEST 05A2 00 *STOP // Stack delta = +0 // Outputs[1] { @05A2 stop(); } // Block terminates label_05A3: // Incoming jump from 0x0092, if 0x95d89b41 == stack[-1] 05A3 5B JUMPDEST 05A4 61 PUSH2 0x05ab 05A7 61 PUSH2 0x10d0 05AA 56 *JUMP // Stack delta = +1 // Outputs[1] { @05A4 stack[0] = 0x05ab } // Block ends with call to 0x10d0, returns to 0x05AB label_05AB: // Incoming return from call to 0x10D0 at 0x05AA // Inputs[4] // { // @05AE memory[0x40:0x60] // @05B9 stack[-1] // @05BC memory[stack[-1]:stack[-1] + 0x20] // @05C5 memory[stack[-1]:stack[-1] + 0x20] // } 05AB 5B JUMPDEST 05AC 60 PUSH1 0x40 05AE 51 MLOAD 05AF 80 DUP1 05B0 80 DUP1 05B1 60 PUSH1 0x20 05B3 01 ADD 05B4 82 DUP3 05B5 81 DUP2 05B6 03 SUB 05B7 82 DUP3 05B8 52 MSTORE 05B9 83 DUP4 05BA 81 DUP2 05BB 81 DUP2 05BC 51 MLOAD 05BD 81 DUP2 05BE 52 MSTORE 05BF 60 PUSH1 0x20 05C1 01 ADD 05C2 91 SWAP2 05C3 50 POP 05C4 80 DUP1 05C5 51 MLOAD 05C6 90 SWAP1 05C7 60 PUSH1 0x20 05C9 01 ADD 05CA 90 SWAP1 05CB 80 DUP1 05CC 83 DUP4 05CD 83 DUP4 05CE 60 PUSH1 0x00 05D0 5B JUMPDEST 05D1 83 DUP4 05D2 81 DUP2 05D3 10 LT 05D4 15 ISZERO 05D5 61 PUSH2 0x05eb 05D8 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @05AE stack[0] = memory[0x40:0x60] // @05AF stack[1] = memory[0x40:0x60] // @05B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @05BE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @05C2 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @05CA stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @05CA stack[3] = 0x20 + stack[-1] // @05CB stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @05CC stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @05CD stack[7] = 0x20 + stack[-1] // @05CE stack[8] = 0x00 // } // Block ends with conditional jump to 0x05eb, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_05D9: // Incoming jump from 0x05D8, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x05D8, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @05D9 stack[-1] // @05DA stack[-2] // @05DC memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @05DE stack[-3] // } 05D9 80 DUP1 05DA 82 DUP3 05DB 01 ADD 05DC 51 MLOAD 05DD 81 DUP2 05DE 84 DUP5 05DF 01 ADD 05E0 52 MSTORE 05E1 60 PUSH1 0x20 05E3 81 DUP2 05E4 01 ADD 05E5 90 SWAP1 05E6 50 POP 05E7 61 PUSH2 0x05d0 05EA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @05E0 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @05E5 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x05d0 label_05EB: // Incoming jump from 0x05D8, if !(stack[-1] < stack[-4]) // Incoming jump from 0x05D8, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @05F0 stack[-6] // @05F0 stack[-5] // @05F2 stack[-7] // } 05EB 5B JUMPDEST 05EC 50 POP 05ED 50 POP 05EE 50 POP 05EF 50 POP 05F0 90 SWAP1 05F1 50 POP 05F2 90 SWAP1 05F3 81 DUP2 05F4 01 ADD 05F5 90 SWAP1 05F6 60 PUSH1 0x1f 05F8 16 AND 05F9 80 DUP1 05FA 15 ISZERO 05FB 61 PUSH2 0x0618 05FE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @05F5 stack[-7] = stack[-5] + stack[-7] // @05F8 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0618, if !(0x1f & stack[-5]) label_05FF: // Incoming jump from 0x05FE, if not !(0x1f & stack[-5]) // Inputs[6] // { // @05FF stack[-1] // @0600 stack[-2] // @0603 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @061A stack[-5] // @0620 memory[0x40:0x60] // @0625 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 05FF 80 DUP1 0600 82 DUP3 0601 03 SUB 0602 80 DUP1 0603 51 MLOAD 0604 60 PUSH1 0x01 0606 83 DUP4 0607 60 PUSH1 0x20 0609 03 SUB 060A 61 PUSH2 0x0100 060D 0A EXP 060E 03 SUB 060F 19 NOT 0610 16 AND 0611 81 DUP2 0612 52 MSTORE 0613 60 PUSH1 0x20 0615 01 ADD 0616 91 SWAP2 0617 50 POP 0618 5B JUMPDEST 0619 50 POP 061A 92 SWAP3 061B 50 POP 061C 50 POP 061D 50 POP 061E 60 PUSH1 0x40 0620 51 MLOAD 0621 80 DUP1 0622 91 SWAP2 0623 03 SUB 0624 90 SWAP1 0625 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0612 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] // @0625 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0626: // Incoming jump from 0x0040, if 0xa9059cbb == stack[-1] // Inputs[1] { @062D msg.data.length } 0626 5B JUMPDEST 0627 61 PUSH2 0x0672 062A 60 PUSH1 0x04 062C 80 DUP1 062D 36 CALLDATASIZE 062E 03 SUB 062F 60 PUSH1 0x40 0631 81 DUP2 0632 10 LT 0633 15 ISZERO 0634 61 PUSH2 0x063c 0637 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0627 stack[0] = 0x0672 // @062A stack[1] = 0x04 // @062E stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x063c, returns to 0x0672, if !(msg.data.length - 0x04 < 0x40) label_0638: // Incoming jump from 0x0637, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @063B memory[0x00:0x00] } 0638 60 PUSH1 0x00 063A 80 DUP1 063B FD *REVERT // Stack delta = +0 // Outputs[1] { @063B revert(memory[0x00:0x00]); } // Block terminates label_063C: // Incoming call from 0x0637, returns to 0x0672, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @063D stack[-2] // @063E stack[-1] // @0642 msg.data[stack[-2]:stack[-2] + 0x20] // @0662 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 063C 5B JUMPDEST 063D 81 DUP2 063E 01 ADD 063F 90 SWAP1 0640 80 DUP1 0641 80 DUP1 0642 35 CALLDATALOAD 0643 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0658 16 AND 0659 90 SWAP1 065A 60 PUSH1 0x20 065C 01 ADD 065D 90 SWAP1 065E 92 SWAP3 065F 91 SWAP2 0660 90 SWAP1 0661 80 DUP1 0662 35 CALLDATALOAD 0663 90 SWAP1 0664 60 PUSH1 0x20 0666 01 ADD 0667 90 SWAP1 0668 92 SWAP3 0669 91 SWAP2 066A 90 SWAP1 066B 50 POP 066C 50 POP 066D 50 POP 066E 61 PUSH2 0x1172 0671 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @065E stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0668 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1172 label_0672: // Incoming return from call to 0x063C at 0x0637 // Inputs[4] // { // @0675 memory[0x40:0x60] // @0677 stack[-1] // @0686 memory[0x40:0x60] // @068B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0672 5B JUMPDEST 0673 60 PUSH1 0x40 0675 51 MLOAD 0676 80 DUP1 0677 82 DUP3 0678 15 ISZERO 0679 15 ISZERO 067A 15 ISZERO 067B 15 ISZERO 067C 81 DUP2 067D 52 MSTORE 067E 60 PUSH1 0x20 0680 01 ADD 0681 91 SWAP2 0682 50 POP 0683 50 POP 0684 60 PUSH1 0x40 0686 51 MLOAD 0687 80 DUP1 0688 91 SWAP2 0689 03 SUB 068A 90 SWAP1 068B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @067D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @068B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_068C: // Incoming jump from 0x004B, if 0xb2bdfa7b == stack[-1] 068C 5B JUMPDEST 068D 61 PUSH2 0x0694 0690 61 PUSH2 0x1190 0693 56 *JUMP // Stack delta = +1 // Outputs[1] { @068D stack[0] = 0x0694 } // Block ends with call to 0x1190, returns to 0x0694 label_0694: // Incoming return from call to 0x1190 at 0x0693 // Inputs[4] // { // @0697 memory[0x40:0x60] // @0699 stack[-1] // @06D0 memory[0x40:0x60] // @06D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0694 5B JUMPDEST 0695 60 PUSH1 0x40 0697 51 MLOAD 0698 80 DUP1 0699 82 DUP3 069A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06AF 16 AND 06B0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06C5 16 AND 06C6 81 DUP2 06C7 52 MSTORE 06C8 60 PUSH1 0x20 06CA 01 ADD 06CB 91 SWAP2 06CC 50 POP 06CD 50 POP 06CE 60 PUSH1 0x40 06D0 51 MLOAD 06D1 80 DUP1 06D2 91 SWAP2 06D3 03 SUB 06D4 90 SWAP1 06D5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @06C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @06D5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_06D6: // Incoming jump from 0x0056, if 0xdd62ed3e == stack[-1] // Inputs[1] { @06DD msg.data.length } 06D6 5B JUMPDEST 06D7 61 PUSH2 0x0738 06DA 60 PUSH1 0x04 06DC 80 DUP1 06DD 36 CALLDATASIZE 06DE 03 SUB 06DF 60 PUSH1 0x40 06E1 81 DUP2 06E2 10 LT 06E3 15 ISZERO 06E4 61 PUSH2 0x06ec 06E7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06D7 stack[0] = 0x0738 // @06DA stack[1] = 0x04 // @06DE stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06ec, returns to 0x0738, if !(msg.data.length - 0x04 < 0x40) label_06E8: // Incoming jump from 0x06E7, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @06EB memory[0x00:0x00] } 06E8 60 PUSH1 0x00 06EA 80 DUP1 06EB FD *REVERT // Stack delta = +0 // Outputs[1] { @06EB revert(memory[0x00:0x00]); } // Block terminates label_06EC: // Incoming call from 0x06E7, returns to 0x0738, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @06ED stack[-2] // @06EE stack[-1] // @06F2 msg.data[stack[-2]:stack[-2] + 0x20] // @0712 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 06EC 5B JUMPDEST 06ED 81 DUP2 06EE 01 ADD 06EF 90 SWAP1 06F0 80 DUP1 06F1 80 DUP1 06F2 35 CALLDATALOAD 06F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0708 16 AND 0709 90 SWAP1 070A 60 PUSH1 0x20 070C 01 ADD 070D 90 SWAP1 070E 92 SWAP3 070F 91 SWAP2 0710 90 SWAP1 0711 80 DUP1 0712 35 CALLDATALOAD 0713 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0728 16 AND 0729 90 SWAP1 072A 60 PUSH1 0x20 072C 01 ADD 072D 90 SWAP1 072E 92 SWAP3 072F 91 SWAP2 0730 90 SWAP1 0731 50 POP 0732 50 POP 0733 50 POP 0734 61 PUSH2 0x11b6 0737 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @070E stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @072E stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x11b6 label_0738: // Incoming return from call to 0x06EC at 0x06E7 // Inputs[4] // { // @073B memory[0x40:0x60] // @073D stack[-1] // @0748 memory[0x40:0x60] // @074D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0738 5B JUMPDEST 0739 60 PUSH1 0x40 073B 51 MLOAD 073C 80 DUP1 073D 82 DUP3 073E 81 DUP2 073F 52 MSTORE 0740 60 PUSH1 0x20 0742 01 ADD 0743 91 SWAP2 0744 50 POP 0745 50 POP 0746 60 PUSH1 0x40 0748 51 MLOAD 0749 80 DUP1 074A 91 SWAP2 074B 03 SUB 074C 90 SWAP1 074D F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @073F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @074D return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_074E: // Incoming jump from 0x0061, if 0xe1268115 == stack[-1] // Inputs[1] { @0755 msg.data.length } 074E 5B JUMPDEST 074F 61 PUSH2 0x0804 0752 60 PUSH1 0x04 0754 80 DUP1 0755 36 CALLDATASIZE 0756 03 SUB 0757 60 PUSH1 0x20 0759 81 DUP2 075A 10 LT 075B 15 ISZERO 075C 61 PUSH2 0x0764 075F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @074F stack[0] = 0x0804 // @0752 stack[1] = 0x04 // @0756 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0764, returns to 0x0804, if !(msg.data.length - 0x04 < 0x20) label_0760: // Incoming jump from 0x075F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0763 memory[0x00:0x00] } 0760 60 PUSH1 0x00 0762 80 DUP1 0763 FD *REVERT // Stack delta = +0 // Outputs[1] { @0763 revert(memory[0x00:0x00]); } // Block terminates label_0764: // Incoming call from 0x075F, returns to 0x0804, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0765 stack[-2] // @0766 stack[-1] // @076A msg.data[stack[-2]:stack[-2] + 0x20] // } 0764 5B JUMPDEST 0765 81 DUP2 0766 01 ADD 0767 90 SWAP1 0768 80 DUP1 0769 80 DUP1 076A 35 CALLDATALOAD 076B 90 SWAP1 076C 60 PUSH1 0x20 076E 01 ADD 076F 90 SWAP1 0770 64 PUSH5 0x0100000000 0776 81 DUP2 0777 11 GT 0778 15 ISZERO 0779 61 PUSH2 0x0781 077C 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0767 stack[-1] = stack[-2] // @0767 stack[-2] = stack[-2] + stack[-1] // @076F stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @076F stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0781, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_077D: // Incoming jump from 0x077C, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0780 memory[0x00:0x00] } 077D 60 PUSH1 0x00 077F 80 DUP1 0780 FD *REVERT // Stack delta = +0 // Outputs[1] { @0780 revert(memory[0x00:0x00]); } // Block terminates label_0781: // Incoming jump from 0x077C, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0782 stack[-3] // @0783 stack[-1] // @0784 stack[-4] // } 0781 5B JUMPDEST 0782 82 DUP3 0783 01 ADD 0784 83 DUP4 0785 60 PUSH1 0x20 0787 82 DUP3 0788 01 ADD 0789 11 GT 078A 15 ISZERO 078B 61 PUSH2 0x0793 078E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0783 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0793, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_078F: // Incoming jump from 0x078E, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0792 memory[0x00:0x00] } 078F 60 PUSH1 0x00 0791 80 DUP1 0792 FD *REVERT // Stack delta = +0 // Outputs[1] { @0792 revert(memory[0x00:0x00]); } // Block terminates label_0793: // Incoming jump from 0x078E, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0794 stack[-1] // @0795 msg.data[stack[-1]:stack[-1] + 0x20] // @079A stack[-2] // @079B stack[-4] // } 0793 5B JUMPDEST 0794 80 DUP1 0795 35 CALLDATALOAD 0796 90 SWAP1 0797 60 PUSH1 0x20 0799 01 ADD 079A 91 SWAP2 079B 84 DUP5 079C 60 PUSH1 0x20 079E 83 DUP4 079F 02 MUL 07A0 84 DUP5 07A1 01 ADD 07A2 11 GT 07A3 64 PUSH5 0x0100000000 07A9 83 DUP4 07AA 11 GT 07AB 17 OR 07AC 15 ISZERO 07AD 61 PUSH2 0x07b5 07B0 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0796 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @079A stack[0] = stack[-2] // @079A stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x07b5, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_07B1: // Incoming jump from 0x07B0, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @07B4 memory[0x00:0x00] } 07B1 60 PUSH1 0x00 07B3 80 DUP1 07B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B4 revert(memory[0x00:0x00]); } // Block terminates label_07B5: // Incoming jump from 0x07B0, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @07B6 stack[-3] // @07B6 stack[-1] // @07B7 stack[-2] // @07C2 memory[0x40:0x60] // @07DC msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @07F8 stack[-4] // @07F9 stack[-5] // } 07B5 5B JUMPDEST 07B6 91 SWAP2 07B7 90 SWAP1 07B8 80 DUP1 07B9 80 DUP1 07BA 60 PUSH1 0x20 07BC 02 MUL 07BD 60 PUSH1 0x20 07BF 01 ADD 07C0 60 PUSH1 0x40 07C2 51 MLOAD 07C3 90 SWAP1 07C4 81 DUP2 07C5 01 ADD 07C6 60 PUSH1 0x40 07C8 52 MSTORE 07C9 80 DUP1 07CA 93 SWAP4 07CB 92 SWAP3 07CC 91 SWAP2 07CD 90 SWAP1 07CE 81 DUP2 07CF 81 DUP2 07D0 52 MSTORE 07D1 60 PUSH1 0x20 07D3 01 ADD 07D4 83 DUP4 07D5 83 DUP4 07D6 60 PUSH1 0x20 07D8 02 MUL 07D9 80 DUP1 07DA 82 DUP3 07DB 84 DUP5 07DC 37 CALLDATACOPY 07DD 60 PUSH1 0x00 07DF 81 DUP2 07E0 84 DUP5 07E1 01 ADD 07E2 52 MSTORE 07E3 60 PUSH1 0x1f 07E5 19 NOT 07E6 60 PUSH1 0x1f 07E8 82 DUP3 07E9 01 ADD 07EA 16 AND 07EB 90 SWAP1 07EC 50 POP 07ED 80 DUP1 07EE 83 DUP4 07EF 01 ADD 07F0 92 SWAP3 07F1 50 POP 07F2 50 POP 07F3 50 POP 07F4 50 POP 07F5 50 POP 07F6 50 POP 07F7 50 POP 07F8 91 SWAP2 07F9 92 SWAP3 07FA 91 SWAP2 07FB 92 SWAP3 07FC 90 SWAP1 07FD 50 POP 07FE 50 POP 07FF 50 POP 0800 61 PUSH2 0x123d 0803 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @07C8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @07D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @07DC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @07E2 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @07FB stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x123d label_0804: // Incoming return from call to 0x0764 at 0x075F 0804 5B JUMPDEST 0805 00 *STOP // Stack delta = +0 // Outputs[1] { @0805 stop(); } // Block terminates label_0806: // Incoming jump from 0x01AF // Inputs[2] // { // @080C storage[0x0a] // @0840 msg.sender // } 0806 5B JUMPDEST 0807 60 PUSH1 0x0a 0809 60 PUSH1 0x00 080B 90 SWAP1 080C 54 SLOAD 080D 90 SWAP1 080E 61 PUSH2 0x0100 0811 0A EXP 0812 90 SWAP1 0813 04 DIV 0814 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0829 16 AND 082A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 083F 16 AND 0840 33 CALLER 0841 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0856 16 AND 0857 14 EQ 0858 61 PUSH2 0x08c9 085B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08c9, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 label_085C: // Incoming jump from 0x085B, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[3] // { // @085E memory[0x40:0x60] // @08C3 memory[0x40:0x60] // @08C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 085C 60 PUSH1 0x40 085E 51 MLOAD 085F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0880 81 DUP2 0881 52 MSTORE 0882 60 PUSH1 0x04 0884 01 ADD 0885 80 DUP1 0886 80 DUP1 0887 60 PUSH1 0x20 0889 01 ADD 088A 82 DUP3 088B 81 DUP2 088C 03 SUB 088D 82 DUP3 088E 52 MSTORE 088F 60 PUSH1 0x06 0891 81 DUP2 0892 52 MSTORE 0893 60 PUSH1 0x20 0895 01 ADD 0896 80 DUP1 0897 7F PUSH32 0x216f776e65720000000000000000000000000000000000000000000000000000 08B8 81 DUP2 08B9 52 MSTORE 08BA 50 POP 08BB 60 PUSH1 0x20 08BD 01 ADD 08BE 91 SWAP2 08BF 50 POP 08C0 50 POP 08C1 60 PUSH1 0x40 08C3 51 MLOAD 08C4 80 DUP1 08C5 91 SWAP2 08C6 03 SUB 08C7 90 SWAP1 08C8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0881 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @088E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0892 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x06 // @08B9 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x216f776e65720000000000000000000000000000000000000000000000000000 // @08C8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08C9: // Incoming jump from 0x085B, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[2] // { // @08D0 stack[-1] // @08D1 memory[stack[-1]:stack[-1] + 0x20] // } 08C9 5B JUMPDEST 08CA 60 PUSH1 0x00 08CC 80 DUP1 08CD 90 SWAP1 08CE 50 POP 08CF 5B JUMPDEST 08D0 81 DUP2 08D1 51 MLOAD 08D2 81 DUP2 08D3 10 LT 08D4 15 ISZERO 08D5 61 PUSH2 0x09bb 08D8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @08CD stack[0] = 0x00 } // Block ends with conditional jump to 0x09bb, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_08D9: // Incoming jump from 0x08D8, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x08D8, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @08DF stack[-2] // @08E0 stack[-1] // @08E2 memory[stack[-2]:stack[-2] + 0x20] // } 08D9 60 PUSH1 0x01 08DB 60 PUSH1 0x02 08DD 60 PUSH1 0x00 08DF 84 DUP5 08E0 84 DUP5 08E1 81 DUP2 08E2 51 MLOAD 08E3 81 DUP2 08E4 10 LT 08E5 61 PUSH2 0x08ea 08E8 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @08D9 stack[0] = 0x01 // @08DB stack[1] = 0x02 // @08DD stack[2] = 0x00 // @08DF stack[3] = stack[-2] // @08E0 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x08ea, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_08E9: // Incoming jump from 0x08E8, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 08E9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @08E9 assert(); } // Block terminates label_08EA: // Incoming jump from 0x08E8, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[11] // { // @08ED stack[-1] // @08F1 stack[-2] // @08F2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @091F stack[-3] // @0924 stack[-4] // @092C memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @0934 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @093C stack[-5] // @094A stack[-7] // @094B stack[-6] // @094D memory[stack[-7]:stack[-7] + 0x20] // } 08EA 5B JUMPDEST 08EB 60 PUSH1 0x20 08ED 02 MUL 08EE 60 PUSH1 0x20 08F0 01 ADD 08F1 01 ADD 08F2 51 MLOAD 08F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0908 16 AND 0909 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 091E 16 AND 091F 81 DUP2 0920 52 MSTORE 0921 60 PUSH1 0x20 0923 01 ADD 0924 90 SWAP1 0925 81 DUP2 0926 52 MSTORE 0927 60 PUSH1 0x20 0929 01 ADD 092A 60 PUSH1 0x00 092C 20 SHA3 092D 60 PUSH1 0x00 092F 61 PUSH2 0x0100 0932 0A EXP 0933 81 DUP2 0934 54 SLOAD 0935 81 DUP2 0936 60 PUSH1 0xff 0938 02 MUL 0939 19 NOT 093A 16 AND 093B 90 SWAP1 093C 83 DUP4 093D 15 ISZERO 093E 15 ISZERO 093F 02 MUL 0940 17 OR 0941 90 SWAP1 0942 55 SSTORE 0943 50 POP 0944 60 PUSH1 0x00 0946 60 PUSH1 0x01 0948 60 PUSH1 0x00 094A 84 DUP5 094B 84 DUP5 094C 81 DUP2 094D 51 MLOAD 094E 81 DUP2 094F 10 LT 0950 61 PUSH2 0x0955 0953 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @0920 memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0926 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @0942 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // @0944 stack[-5] = 0x00 // @0946 stack[-4] = 0x01 // @0948 stack[-3] = 0x00 // @094A stack[-2] = stack[-7] // @094B stack[-1] = stack[-6] // } // Block ends with conditional jump to 0x0955, if stack[-6] < memory[stack[-7]:stack[-7] + 0x20] label_0954: // Incoming jump from 0x0953, if not stack[-6] < memory[stack[-7]:stack[-7] + 0x20] 0954 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0954 assert(); } // Block terminates label_0955: // Incoming jump from 0x0953, if stack[-6] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[9] // { // @0958 stack[-1] // @095C stack[-2] // @095D memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @098A stack[-3] // @098F stack[-4] // @0997 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @099F storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @09A7 stack[-5] // @09AF stack[-6] // } 0955 5B JUMPDEST 0956 60 PUSH1 0x20 0958 02 MUL 0959 60 PUSH1 0x20 095B 01 ADD 095C 01 ADD 095D 51 MLOAD 095E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0973 16 AND 0974 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0989 16 AND 098A 81 DUP2 098B 52 MSTORE 098C 60 PUSH1 0x20 098E 01 ADD 098F 90 SWAP1 0990 81 DUP2 0991 52 MSTORE 0992 60 PUSH1 0x20 0994 01 ADD 0995 60 PUSH1 0x00 0997 20 SHA3 0998 60 PUSH1 0x00 099A 61 PUSH2 0x0100 099D 0A EXP 099E 81 DUP2 099F 54 SLOAD 09A0 81 DUP2 09A1 60 PUSH1 0xff 09A3 02 MUL 09A4 19 NOT 09A5 16 AND 09A6 90 SWAP1 09A7 83 DUP4 09A8 15 ISZERO 09A9 15 ISZERO 09AA 02 MUL 09AB 17 OR 09AC 90 SWAP1 09AD 55 SSTORE 09AE 50 POP 09AF 80 DUP1 09B0 80 DUP1 09B1 60 PUSH1 0x01 09B3 01 ADD 09B4 91 SWAP2 09B5 50 POP 09B6 50 POP 09B7 61 PUSH2 0x08cf 09BA 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @098B memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0991 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @09AD storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // @09B4 stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x08cf label_09BB: // Incoming jump from 0x08D8, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x08D8, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[1] { @09BE stack[-3] } 09BB 5B JUMPDEST 09BC 50 POP 09BD 50 POP 09BE 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_09BF: // Incoming call from 0x01B9, returns to 0x01BA // Inputs[3] // { // @09C5 storage[0x06] // @09E6 memory[0x40:0x60] // @09F9 storage[0x06] // } 09BF 5B JUMPDEST 09C0 60 PUSH1 0x60 09C2 60 PUSH1 0x06 09C4 80 DUP1 09C5 54 SLOAD 09C6 60 PUSH1 0x01 09C8 81 DUP2 09C9 60 PUSH1 0x01 09CB 16 AND 09CC 15 ISZERO 09CD 61 PUSH2 0x0100 09D0 02 MUL 09D1 03 SUB 09D2 16 AND 09D3 60 PUSH1 0x02 09D5 90 SWAP1 09D6 04 DIV 09D7 80 DUP1 09D8 60 PUSH1 0x1f 09DA 01 ADD 09DB 60 PUSH1 0x20 09DD 80 DUP1 09DE 91 SWAP2 09DF 04 DIV 09E0 02 MUL 09E1 60 PUSH1 0x20 09E3 01 ADD 09E4 60 PUSH1 0x40 09E6 51 MLOAD 09E7 90 SWAP1 09E8 81 DUP2 09E9 01 ADD 09EA 60 PUSH1 0x40 09EC 52 MSTORE 09ED 80 DUP1 09EE 92 SWAP3 09EF 91 SWAP2 09F0 90 SWAP1 09F1 81 DUP2 09F2 81 DUP2 09F3 52 MSTORE 09F4 60 PUSH1 0x20 09F6 01 ADD 09F7 82 DUP3 09F8 80 DUP1 09F9 54 SLOAD 09FA 60 PUSH1 0x01 09FC 81 DUP2 09FD 60 PUSH1 0x01 09FF 16 AND 0A00 15 ISZERO 0A01 61 PUSH2 0x0100 0A04 02 MUL 0A05 03 SUB 0A06 16 AND 0A07 60 PUSH1 0x02 0A09 90 SWAP1 0A0A 04 DIV 0A0B 80 DUP1 0A0C 15 ISZERO 0A0D 61 PUSH2 0x0a57 0A10 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @09C0 stack[0] = 0x60 // @09EC memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) / 0x20 * 0x20 // @09EE stack[1] = memory[0x40:0x60] // @09EF stack[2] = 0x06 // @09F0 stack[3] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // @09F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // @09F6 stack[4] = 0x20 + memory[0x40:0x60] // @09F7 stack[5] = 0x06 // @0A0A stack[6] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // } // Block ends with conditional jump to 0x0a57, if !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) label_0A11: // Incoming jump from 0x0A10, if not !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) // Inputs[1] { @0A11 stack[-1] } 0A11 80 DUP1 0A12 60 PUSH1 0x1f 0A14 10 LT 0A15 61 PUSH2 0x0a2c 0A18 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a2c, if 0x1f < stack[-1] label_0A19: // Incoming jump from 0x0A18, if not 0x1f < stack[-1] // Inputs[4] // { // @0A1D stack[-2] // @0A1E storage[stack[-2]] // @0A21 stack[-3] // @0A23 stack[-1] // } 0A19 61 PUSH2 0x0100 0A1C 80 DUP1 0A1D 83 DUP4 0A1E 54 SLOAD 0A1F 04 DIV 0A20 02 MUL 0A21 83 DUP4 0A22 52 MSTORE 0A23 91 SWAP2 0A24 60 PUSH1 0x20 0A26 01 ADD 0A27 91 SWAP2 0A28 61 PUSH2 0x0a57 0A2B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0A22 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0A27 stack[-1] = stack[-1] // @0A27 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0a57 label_0A2C: // Incoming jump from 0x0A18, if 0x1f < stack[-1] // Inputs[5] // { // @0A2D stack[-3] // @0A2E stack[-1] // @0A30 stack[-2] // @0A38 memory[0x00:0x20] // @0A3C storage[keccak256(memory[0x00:0x20])] // } 0A2C 5B JUMPDEST 0A2D 82 DUP3 0A2E 01 ADD 0A2F 91 SWAP2 0A30 90 SWAP1 0A31 60 PUSH1 0x00 0A33 52 MSTORE 0A34 60 PUSH1 0x20 0A36 60 PUSH1 0x00 0A38 20 SHA3 0A39 90 SWAP1 0A3A 5B JUMPDEST 0A3B 81 DUP2 0A3C 54 SLOAD 0A3D 81 DUP2 0A3E 52 MSTORE 0A3F 90 SWAP1 0A40 60 PUSH1 0x01 0A42 01 ADD 0A43 90 SWAP1 0A44 60 PUSH1 0x20 0A46 01 ADD 0A47 80 DUP1 0A48 83 DUP4 0A49 11 GT 0A4A 61 PUSH2 0x0a3a 0A4D 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0A2F stack[-3] = stack[-3] + stack[-1] // @0A33 memory[0x00:0x20] = stack[-2] // @0A3E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0A43 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0A46 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0a3a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0A4E: // Incoming jump from 0x0A4D, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0A4D, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0A4E stack[-3] // @0A4F stack[-1] // } 0A4E 82 DUP3 0A4F 90 SWAP1 0A50 03 SUB 0A51 60 PUSH1 0x1f 0A53 16 AND 0A54 82 DUP3 0A55 01 ADD 0A56 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0A56 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0A56 stack[-1] = stack[-3] // } // Block continues label_0A57: // Incoming jump from 0x0A56 // Incoming jump from 0x0A2B // Incoming jump from 0x0A10, if !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) // Inputs[3] // { // @0A5D stack[-6] // @0A5D stack[-7] // @0A5F stack[-8] // } 0A57 5B JUMPDEST 0A58 50 POP 0A59 50 POP 0A5A 50 POP 0A5B 50 POP 0A5C 50 POP 0A5D 90 SWAP1 0A5E 50 POP 0A5F 90 SWAP1 0A60 56 *JUMP // Stack delta = -7 // Outputs[1] { @0A5F stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0A61: // Incoming jump from 0x0280 0A61 5B JUMPDEST 0A62 60 PUSH1 0x00 0A64 61 PUSH2 0x0a75 0A67 61 PUSH2 0x0a6e 0A6A 61 PUSH2 0x13f5 0A6D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A62 stack[0] = 0x00 // @0A64 stack[1] = 0x0a75 // @0A67 stack[2] = 0x0a6e // } // Block ends with call to 0x13f5, returns to 0x0A6E label_0A6E: // Incoming return from call to 0x13F5 at 0x0A6D // Inputs[2] // { // @0A6F stack[-5] // @0A70 stack[-4] // } 0A6E 5B JUMPDEST 0A6F 84 DUP5 0A70 84 DUP5 0A71 61 PUSH2 0x13fd 0A74 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A6F stack[0] = stack[-5] // @0A70 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x13fd label_0A75: // Incoming return from call to 0x0A6E at 0x0A6D // Inputs[3] // { // @0A78 stack[-1] // @0A7A stack[-4] // @0A7B stack[-3] // } 0A75 5B JUMPDEST 0A76 60 PUSH1 0x01 0A78 90 SWAP1 0A79 50 POP 0A7A 92 SWAP3 0A7B 91 SWAP2 0A7C 50 POP 0A7D 50 POP 0A7E 56 *JUMP // Stack delta = -3 // Outputs[1] { @0A7A stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0A7F: // Incoming call from 0x02A2, returns to 0x02A3 // Inputs[2] // { // @0A84 storage[0x05] // @0A87 stack[-1] // } 0A7F 5B JUMPDEST 0A80 60 PUSH1 0x00 0A82 60 PUSH1 0x05 0A84 54 SLOAD 0A85 90 SWAP1 0A86 50 POP 0A87 90 SWAP1 0A88 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A87 stack[-1] = storage[0x05] } // Block ends with unconditional jump to stack[-1] label_0A89: // Incoming jump from 0x0324 // Inputs[3] // { // @0A8F stack[-3] // @0A90 stack[-2] // @0A91 stack[-1] // } 0A89 5B JUMPDEST 0A8A 60 PUSH1 0x00 0A8C 61 PUSH2 0x0a96 0A8F 84 DUP5 0A90 84 DUP5 0A91 84 DUP5 0A92 61 PUSH2 0x15f4 0A95 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0A8A stack[0] = 0x00 // @0A8C stack[1] = 0x0a96 // @0A8F stack[2] = stack[-3] // @0A90 stack[3] = stack[-2] // @0A91 stack[4] = stack[-1] // } // Block ends with call to 0x15f4, returns to 0x0A96 label_0A96: // Incoming return from call to 0x15F4 at 0x0A95 // Inputs[1] { @0A9A stack[-4] } 0A96 5B JUMPDEST 0A97 61 PUSH2 0x0b57 0A9A 84 DUP5 0A9B 61 PUSH2 0x0aa2 0A9E 61 PUSH2 0x13f5 0AA1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A97 stack[0] = 0x0b57 // @0A9A stack[1] = stack[-4] // @0A9B stack[2] = 0x0aa2 // } // Block ends with call to 0x13f5, returns to 0x0AA2 label_0AA2: // Incoming return from call to 0x13F5 at 0x0AA1 // Inputs[4] // { // @0AA6 stack[-5] // @0AA9 memory[0x40:0x60] // @0AC4 stack[-7] // @0AFE memory[0x00:0x40] // } 0AA2 5B JUMPDEST 0AA3 61 PUSH2 0x0b52 0AA6 85 DUP6 0AA7 60 PUSH1 0x40 0AA9 51 MLOAD 0AAA 80 DUP1 0AAB 60 PUSH1 0x60 0AAD 01 ADD 0AAE 60 PUSH1 0x40 0AB0 52 MSTORE 0AB1 80 DUP1 0AB2 60 PUSH1 0x28 0AB4 81 DUP2 0AB5 52 MSTORE 0AB6 60 PUSH1 0x20 0AB8 01 ADD 0AB9 61 PUSH2 0x2eaa 0ABC 60 PUSH1 0x28 0ABE 91 SWAP2 0ABF 39 CODECOPY 0AC0 60 PUSH1 0x04 0AC2 60 PUSH1 0x00 0AC4 8B DUP12 0AC5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ADA 16 AND 0ADB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0AF0 16 AND 0AF1 81 DUP2 0AF2 52 MSTORE 0AF3 60 PUSH1 0x20 0AF5 01 ADD 0AF6 90 SWAP1 0AF7 81 DUP2 0AF8 52 MSTORE 0AF9 60 PUSH1 0x20 0AFB 01 ADD 0AFC 60 PUSH1 0x00 0AFE 20 SHA3 0AFF 60 PUSH1 0x00 0B01 61 PUSH2 0x0b08 0B04 61 PUSH2 0x13f5 0B07 56 *JUMP // Stack delta = +6 // Outputs[11] // { // @0AA3 stack[0] = 0x0b52 // @0AA6 stack[1] = stack[-5] // @0AA9 stack[2] = memory[0x40:0x60] // @0AB0 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0AB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x28 // @0ABF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x28] = code[0x2eaa:0x2ed2] // @0AF2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @0AF8 memory[0x20:0x40] = 0x04 // @0AFE stack[3] = keccak256(memory[0x00:0x40]) // @0AFF stack[4] = 0x00 // @0B01 stack[5] = 0x0b08 // } // Block ends with call to 0x13f5, returns to 0x0B08 label_0B08: // Incoming return from call to 0x13F5 at 0x0B07 // Inputs[7] // { // @0B1E stack[-1] // @0B35 stack[-2] // @0B3A stack[-3] // @0B42 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0B43 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @0B48 stack[-5] // @0B49 stack[-4] // } 0B08 5B JUMPDEST 0B09 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B1E 16 AND 0B1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B34 16 AND 0B35 81 DUP2 0B36 52 MSTORE 0B37 60 PUSH1 0x20 0B39 01 ADD 0B3A 90 SWAP1 0B3B 81 DUP2 0B3C 52 MSTORE 0B3D 60 PUSH1 0x20 0B3F 01 ADD 0B40 60 PUSH1 0x00 0B42 20 SHA3 0B43 54 SLOAD 0B44 61 PUSH2 0x2cf1 0B47 90 SWAP1 0B48 92 SWAP3 0B49 91 SWAP2 0B4A 90 SWAP1 0B4B 63 PUSH4 0xffffffff 0B50 16 AND 0B51 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0B36 memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0B3C memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @0B48 stack[-5] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @0B49 stack[-4] = stack[-5] // @0B4A stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0xffffffff & 0x2cf1 label_0B52: // Incoming return from call to 0x0B08 at 0x0B07 0B52 5B JUMPDEST 0B53 61 PUSH2 0x13fd 0B56 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x13fd label_0B57: // Incoming return from call to 0x0AA2 at 0x0AA1 // Inputs[3] // { // @0B5A stack[-1] // @0B5C stack[-5] // @0B5D stack[-4] // } 0B57 5B JUMPDEST 0B58 60 PUSH1 0x01 0B5A 90 SWAP1 0B5B 50 POP 0B5C 93 SWAP4 0B5D 92 SWAP3 0B5E 50 POP 0B5F 50 POP 0B60 50 POP 0B61 56 *JUMP // Stack delta = -4 // Outputs[1] { @0B5C stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0B62: // Incoming call from 0x0346, returns to 0x0347 // Inputs[2] // { // @0B6A storage[0x08] // @0B77 stack[-1] // } 0B62 5B JUMPDEST 0B63 60 PUSH1 0x00 0B65 60 PUSH1 0x08 0B67 60 PUSH1 0x00 0B69 90 SWAP1 0B6A 54 SLOAD 0B6B 90 SWAP1 0B6C 61 PUSH2 0x0100 0B6F 0A EXP 0B70 90 SWAP1 0B71 04 DIV 0B72 60 PUSH1 0xff 0B74 16 AND 0B75 90 SWAP1 0B76 50 POP 0B77 90 SWAP1 0B78 56 *JUMP // Stack delta = +0 // Outputs[1] { @0B77 stack[-1] = 0xff & storage[0x08] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_0B79: // Incoming jump from 0x03AE // Inputs[2] // { // @0B7F storage[0x0a] // @0BB3 msg.sender // } 0B79 5B JUMPDEST 0B7A 60 PUSH1 0x0a 0B7C 60 PUSH1 0x00 0B7E 90 SWAP1 0B7F 54 SLOAD 0B80 90 SWAP1 0B81 61 PUSH2 0x0100 0B84 0A EXP 0B85 90 SWAP1 0B86 04 DIV 0B87 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B9C 16 AND 0B9D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BB2 16 AND 0BB3 33 CALLER 0BB4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BC9 16 AND 0BCA 14 EQ 0BCB 61 PUSH2 0x0c3c 0BCE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c3c, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 label_0BCF: // Incoming jump from 0x0BCE, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[3] // { // @0BD1 memory[0x40:0x60] // @0C36 memory[0x40:0x60] // @0C3B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BCF 60 PUSH1 0x40 0BD1 51 MLOAD 0BD2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0BF3 81 DUP2 0BF4 52 MSTORE 0BF5 60 PUSH1 0x04 0BF7 01 ADD 0BF8 80 DUP1 0BF9 80 DUP1 0BFA 60 PUSH1 0x20 0BFC 01 ADD 0BFD 82 DUP3 0BFE 81 DUP2 0BFF 03 SUB 0C00 82 DUP3 0C01 52 MSTORE 0C02 60 PUSH1 0x1f 0C04 81 DUP2 0C05 52 MSTORE 0C06 60 PUSH1 0x20 0C08 01 ADD 0C09 80 DUP1 0C0A 7F PUSH32 0x45524332303a206d696e7420746f20746865207a65726f206164647265737300 0C2B 81 DUP2 0C2C 52 MSTORE 0C2D 50 POP 0C2E 60 PUSH1 0x20 0C30 01 ADD 0C31 91 SWAP2 0C32 50 POP 0C33 50 POP 0C34 60 PUSH1 0x40 0C36 51 MLOAD 0C37 80 DUP1 0C38 91 SWAP2 0C39 03 SUB 0C3A 90 SWAP1 0C3B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0BF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0C01 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0C05 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1f // @0C2C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x45524332303a206d696e7420746f20746865207a65726f206164647265737300 // @0C3B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C3C: // Incoming jump from 0x0BCE, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[2] // { // @0C40 stack[-1] // @0C43 storage[0x05] // } 0C3C 5B JUMPDEST 0C3D 61 PUSH2 0x0c51 0C40 81 DUP2 0C41 60 PUSH1 0x05 0C43 54 SLOAD 0C44 61 PUSH2 0x2db1 0C47 90 SWAP1 0C48 91 SWAP2 0C49 90 SWAP1 0C4A 63 PUSH4 0xffffffff 0C4F 16 AND 0C50 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C3D stack[0] = 0x0c51 // @0C48 stack[1] = storage[0x05] // @0C49 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2db1, returns to 0x0C51 label_0C51: // Incoming return from call to 0x2DB1 at 0x0C50 // Inputs[5] // { // @0C54 stack[-1] // @0C5B stack[-2] // @0C64 storage[0x0a] // @0CBB memory[0x00:0x40] // @0CBC storage[keccak256(memory[0x00:0x40])] // } 0C51 5B JUMPDEST 0C52 60 PUSH1 0x05 0C54 81 DUP2 0C55 90 SWAP1 0C56 55 SSTORE 0C57 50 POP 0C58 61 PUSH2 0x0cca 0C5B 81 DUP2 0C5C 60 PUSH1 0x00 0C5E 80 DUP1 0C5F 60 PUSH1 0x0a 0C61 60 PUSH1 0x00 0C63 90 SWAP1 0C64 54 SLOAD 0C65 90 SWAP1 0C66 61 PUSH2 0x0100 0C69 0A EXP 0C6A 90 SWAP1 0C6B 04 DIV 0C6C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C81 16 AND 0C82 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C97 16 AND 0C98 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CAD 16 AND 0CAE 81 DUP2 0CAF 52 MSTORE 0CB0 60 PUSH1 0x20 0CB2 01 ADD 0CB3 90 SWAP1 0CB4 81 DUP2 0CB5 52 MSTORE 0CB6 60 PUSH1 0x20 0CB8 01 ADD 0CB9 60 PUSH1 0x00 0CBB 20 SHA3 0CBC 54 SLOAD 0CBD 61 PUSH2 0x2db1 0CC0 90 SWAP1 0CC1 91 SWAP2 0CC2 90 SWAP1 0CC3 63 PUSH4 0xffffffff 0CC8 16 AND 0CC9 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0C56 storage[0x05] = stack[-1] // @0C58 stack[-1] = 0x0cca // @0CAF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // @0CB5 memory[0x20:0x40] = 0x00 // @0CC1 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0CC2 stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x2db1, returns to 0x0CCA label_0CCA: // Incoming return from call to 0x2DB1 at 0x0CC9 // Inputs[9] // { // @0CD3 storage[0x0a] // @0D2A memory[0x00:0x40] // @0D2B stack[-1] // @0D2F stack[-3] // @0D7F stack[-2] // @0D82 memory[0x40:0x60] // @0D8F memory[0x40:0x60] // @0D94 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0D97 stack[-4] // } 0CCA 5B JUMPDEST 0CCB 60 PUSH1 0x00 0CCD 80 DUP1 0CCE 60 PUSH1 0x0a 0CD0 60 PUSH1 0x00 0CD2 90 SWAP1 0CD3 54 SLOAD 0CD4 90 SWAP1 0CD5 61 PUSH2 0x0100 0CD8 0A EXP 0CD9 90 SWAP1 0CDA 04 DIV 0CDB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CF0 16 AND 0CF1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D06 16 AND 0D07 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D1C 16 AND 0D1D 81 DUP2 0D1E 52 MSTORE 0D1F 60 PUSH1 0x20 0D21 01 ADD 0D22 90 SWAP1 0D23 81 DUP2 0D24 52 MSTORE 0D25 60 PUSH1 0x20 0D27 01 ADD 0D28 60 PUSH1 0x00 0D2A 20 SHA3 0D2B 81 DUP2 0D2C 90 SWAP1 0D2D 55 SSTORE 0D2E 50 POP 0D2F 81 DUP2 0D30 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D45 16 AND 0D46 60 PUSH1 0x00 0D48 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D5D 16 AND 0D5E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0D7F 83 DUP4 0D80 60 PUSH1 0x40 0D82 51 MLOAD 0D83 80 DUP1 0D84 82 DUP3 0D85 81 DUP2 0D86 52 MSTORE 0D87 60 PUSH1 0x20 0D89 01 ADD 0D8A 91 SWAP2 0D8B 50 POP 0D8C 50 POP 0D8D 60 PUSH1 0x40 0D8F 51 MLOAD 0D90 80 DUP1 0D91 91 SWAP2 0D92 03 SUB 0D93 90 SWAP1 0D94 A3 LOG3 0D95 50 POP 0D96 50 POP 0D97 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0D1E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // @0D24 memory[0x20:0x40] = 0x00 // @0D2D storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0D86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0D94 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_0D98: // Incoming jump from 0x0504 // Inputs[2] // { // @0D9E storage[0x0a] // @0DD2 msg.sender // } 0D98 5B JUMPDEST 0D99 60 PUSH1 0x0a 0D9B 60 PUSH1 0x00 0D9D 90 SWAP1 0D9E 54 SLOAD 0D9F 90 SWAP1 0DA0 61 PUSH2 0x0100 0DA3 0A EXP 0DA4 90 SWAP1 0DA5 04 DIV 0DA6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DBB 16 AND 0DBC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DD1 16 AND 0DD2 33 CALLER 0DD3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DE8 16 AND 0DE9 14 EQ 0DEA 61 PUSH2 0x0e5b 0DED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e5b, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 label_0DEE: // Incoming jump from 0x0DED, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[3] // { // @0DF0 memory[0x40:0x60] // @0E55 memory[0x40:0x60] // @0E5A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DEE 60 PUSH1 0x40 0DF0 51 MLOAD 0DF1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0E12 81 DUP2 0E13 52 MSTORE 0E14 60 PUSH1 0x04 0E16 01 ADD 0E17 80 DUP1 0E18 80 DUP1 0E19 60 PUSH1 0x20 0E1B 01 ADD 0E1C 82 DUP3 0E1D 81 DUP2 0E1E 03 SUB 0E1F 82 DUP3 0E20 52 MSTORE 0E21 60 PUSH1 0x06 0E23 81 DUP2 0E24 52 MSTORE 0E25 60 PUSH1 0x20 0E27 01 ADD 0E28 80 DUP1 0E29 7F PUSH32 0x216f776e65720000000000000000000000000000000000000000000000000000 0E4A 81 DUP2 0E4B 52 MSTORE 0E4C 50 POP 0E4D 60 PUSH1 0x20 0E4F 01 ADD 0E50 91 SWAP2 0E51 50 POP 0E52 50 POP 0E53 60 PUSH1 0x40 0E55 51 MLOAD 0E56 80 DUP1 0E57 91 SWAP2 0E58 03 SUB 0E59 90 SWAP1 0E5A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E13 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E20 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0E24 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x06 // @0E4B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x216f776e65720000000000000000000000000000000000000000000000000000 // @0E5A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E5B: // Incoming jump from 0x0DED, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[2] // { // @0E62 stack[-2] // @0E63 memory[stack[-2]:stack[-2] + 0x20] // } 0E5B 5B JUMPDEST 0E5C 60 PUSH1 0x00 0E5E 80 DUP1 0E5F 90 SWAP1 0E60 50 POP 0E61 5B JUMPDEST 0E62 82 DUP3 0E63 51 MLOAD 0E64 81 DUP2 0E65 10 LT 0E66 15 ISZERO 0E67 61 PUSH2 0x0f7b 0E6A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E5F stack[0] = 0x00 } // Block ends with conditional jump to 0x0f7b, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_0E6B: // Incoming jump from 0x0E6A, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0E6A, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @0E6E stack[-3] // @0E6F stack[-1] // @0E71 memory[stack[-3]:stack[-3] + 0x20] // } 0E6B 61 PUSH2 0x0e9a 0E6E 83 DUP4 0E6F 82 DUP3 0E70 81 DUP2 0E71 51 MLOAD 0E72 81 DUP2 0E73 10 LT 0E74 61 PUSH2 0x0e79 0E77 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E6B stack[0] = 0x0e9a // @0E6E stack[1] = stack[-3] // @0E6F stack[2] = stack[-1] // } // Block ends with conditional call to 0x0e79, returns to 0x0E9A, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_0E78: // Incoming jump from 0x0E77, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 0E78 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E78 assert(); } // Block terminates label_0E79: // Incoming call from 0x0E77, returns to 0x0E9A, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @0E7C stack[-1] // @0E80 stack[-2] // @0E81 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E82 stack[-5] // @0E83 stack[-4] // @0E85 memory[stack[-5]:stack[-5] + 0x20] // } 0E79 5B JUMPDEST 0E7A 60 PUSH1 0x20 0E7C 02 MUL 0E7D 60 PUSH1 0x20 0E7F 01 ADD 0E80 01 ADD 0E81 51 MLOAD 0E82 83 DUP4 0E83 83 DUP4 0E84 81 DUP2 0E85 51 MLOAD 0E86 81 DUP2 0E87 10 LT 0E88 61 PUSH2 0x0e8d 0E8B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0E81 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E82 stack[-1] = stack[-5] // @0E83 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0e8d, if stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_0E8C: // Incoming jump from 0x0E8B, if not stack[-4] < memory[stack[-5]:stack[-5] + 0x20] 0E8C FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E8C assert(); } // Block terminates label_0E8D: // Incoming jump from 0x0E8B, if stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @0E90 stack[-1] // @0E94 stack[-2] // @0E95 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0E8D 5B JUMPDEST 0E8E 60 PUSH1 0x20 0E90 02 MUL 0E91 60 PUSH1 0x20 0E93 01 ADD 0E94 01 ADD 0E95 51 MLOAD 0E96 61 PUSH2 0x1172 0E99 56 *JUMP // Stack delta = -1 // Outputs[1] { @0E95 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1172 label_0E9A: // Incoming return from call to 0x0E79 at 0x0E77 // Inputs[2] // { // @0E9C stack[-5] // @0E9D stack[-2] // } 0E9A 5B JUMPDEST 0E9B 50 POP 0E9C 83 DUP4 0E9D 81 DUP2 0E9E 10 LT 0E9F 15 ISZERO 0EA0 61 PUSH2 0x0f6e 0EA3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f6e, if !(stack[-2] < stack[-5]) label_0EA4: // Incoming jump from 0x0EA3, if not !(stack[-2] < stack[-5]) // Inputs[3] // { // @0EA9 stack[-3] // @0EAA stack[-1] // @0EAC memory[stack[-3]:stack[-3] + 0x20] // } 0EA4 60 PUSH1 0x01 0EA6 80 DUP1 0EA7 60 PUSH1 0x00 0EA9 85 DUP6 0EAA 84 DUP5 0EAB 81 DUP2 0EAC 51 MLOAD 0EAD 81 DUP2 0EAE 10 LT 0EAF 61 PUSH2 0x0eb4 0EB2 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0EA4 stack[0] = 0x01 // @0EA6 stack[1] = 0x01 // @0EA7 stack[2] = 0x00 // @0EA9 stack[3] = stack[-3] // @0EAA stack[4] = stack[-1] // } // Block ends with conditional jump to 0x0eb4, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_0EB3: // Incoming jump from 0x0EB2, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 0EB3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0EB3 assert(); } // Block terminates label_0EB4: // Incoming jump from 0x0EB2, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[11] // { // @0EB7 stack[-1] // @0EBB stack[-2] // @0EBC memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0EE9 stack[-3] // @0EEE stack[-4] // @0EF6 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @0EFE storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @0F06 stack[-5] // @0F11 stack[-8] // @0F12 stack[-6] // @0F14 memory[stack[-8]:stack[-8] + 0x20] // } 0EB4 5B JUMPDEST 0EB5 60 PUSH1 0x20 0EB7 02 MUL 0EB8 60 PUSH1 0x20 0EBA 01 ADD 0EBB 01 ADD 0EBC 51 MLOAD 0EBD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ED2 16 AND 0ED3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EE8 16 AND 0EE9 81 DUP2 0EEA 52 MSTORE 0EEB 60 PUSH1 0x20 0EED 01 ADD 0EEE 90 SWAP1 0EEF 81 DUP2 0EF0 52 MSTORE 0EF1 60 PUSH1 0x20 0EF3 01 ADD 0EF4 60 PUSH1 0x00 0EF6 20 SHA3 0EF7 60 PUSH1 0x00 0EF9 61 PUSH2 0x0100 0EFC 0A EXP 0EFD 81 DUP2 0EFE 54 SLOAD 0EFF 81 DUP2 0F00 60 PUSH1 0xff 0F02 02 MUL 0F03 19 NOT 0F04 16 AND 0F05 90 SWAP1 0F06 83 DUP4 0F07 15 ISZERO 0F08 15 ISZERO 0F09 02 MUL 0F0A 17 OR 0F0B 90 SWAP1 0F0C 55 SSTORE 0F0D 50 POP 0F0E 61 PUSH2 0x0f6d 0F11 83 DUP4 0F12 82 DUP3 0F13 81 DUP2 0F14 51 MLOAD 0F15 81 DUP2 0F16 10 LT 0F17 61 PUSH2 0x0f1c 0F1A 57 *JUMPI // Stack delta = -2 // Outputs[6] // { // @0EEA memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0EF0 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @0F0C storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // @0F0E stack[-5] = 0x0f6d // @0F11 stack[-4] = stack[-8] // @0F12 stack[-3] = stack[-6] // } // Block ends with conditional call to 0x0f1c, returns to 0x0F6D, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20] label_0F1B: // Incoming jump from 0x0F1A, if not stack[-6] < memory[stack[-8]:stack[-8] + 0x20] 0F1B FE *ASSERT // Stack delta = +0 // Outputs[1] { @0F1B assert(); } // Block terminates label_0F1C: // Incoming call from 0x0F1A, returns to 0x0F6D, if stack[-6] < memory[stack[-8]:stack[-8] + 0x20] // Inputs[4] // { // @0F1F stack[-1] // @0F23 stack[-2] // @0F24 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0F2A storage[0x0c] // } 0F1C 5B JUMPDEST 0F1D 60 PUSH1 0x20 0F1F 02 MUL 0F20 60 PUSH1 0x20 0F22 01 ADD 0F23 01 ADD 0F24 51 MLOAD 0F25 60 PUSH1 0x0c 0F27 60 PUSH1 0x00 0F29 90 SWAP1 0F2A 54 SLOAD 0F2B 90 SWAP1 0F2C 61 PUSH2 0x0100 0F2F 0A EXP 0F30 90 SWAP1 0F31 04 DIV 0F32 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F47 16 AND 0F48 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0F69 61 PUSH2 0x13fd 0F6C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0F24 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0F47 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0c] / 0x0100 ** 0x00 // @0F48 stack[0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // } // Block ends with unconditional jump to 0x13fd label_0F6D: // Incoming return from call to 0x0F1C at 0x0F1A 0F6D 5B JUMPDEST // Stack delta = +0 // Block continues label_0F6E: // Incoming jump from 0x0F6D // Incoming jump from 0x0EA3, if !(stack[-2] < stack[-5]) // Inputs[1] { @0F6F stack[-1] } 0F6E 5B JUMPDEST 0F6F 80 DUP1 0F70 80 DUP1 0F71 60 PUSH1 0x01 0F73 01 ADD 0F74 91 SWAP2 0F75 50 POP 0F76 50 POP 0F77 61 PUSH2 0x0e61 0F7A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0F74 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x0e61 label_0F7B: // Incoming jump from 0x0E6A, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0E6A, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[1] { @0F80 stack[-5] } 0F7B 5B JUMPDEST 0F7C 50 POP 0F7D 50 POP 0F7E 50 POP 0F7F 50 POP 0F80 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0F81: // Incoming jump from 0x0548 // Inputs[4] // { // @0F87 stack[-1] // @0FC1 memory[0x00:0x40] // @0FC2 storage[keccak256(memory[0x00:0x40])] // @0FC5 stack[-2] // } 0F81 5B JUMPDEST 0F82 60 PUSH1 0x00 0F84 80 DUP1 0F85 60 PUSH1 0x00 0F87 83 DUP4 0F88 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F9D 16 AND 0F9E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FB3 16 AND 0FB4 81 DUP2 0FB5 52 MSTORE 0FB6 60 PUSH1 0x20 0FB8 01 ADD 0FB9 90 SWAP1 0FBA 81 DUP2 0FBB 52 MSTORE 0FBC 60 PUSH1 0x20 0FBE 01 ADD 0FBF 60 PUSH1 0x00 0FC1 20 SHA3 0FC2 54 SLOAD 0FC3 90 SWAP1 0FC4 50 POP 0FC5 91 SWAP2 0FC6 90 SWAP1 0FC7 50 POP 0FC8 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0FB5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0FBB memory[0x20:0x40] = 0x00 // @0FC5 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0FC9: // Incoming jump from 0x05A0 // Inputs[2] // { // @0FCF storage[0x0a] // @1003 msg.sender // } 0FC9 5B JUMPDEST 0FCA 60 PUSH1 0x0a 0FCC 60 PUSH1 0x00 0FCE 90 SWAP1 0FCF 54 SLOAD 0FD0 90 SWAP1 0FD1 61 PUSH2 0x0100 0FD4 0A EXP 0FD5 90 SWAP1 0FD6 04 DIV 0FD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FEC 16 AND 0FED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1002 16 AND 1003 33 CALLER 1004 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1019 16 AND 101A 14 EQ 101B 61 PUSH2 0x108c 101E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x108c, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 label_101F: // Incoming jump from 0x101E, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[3] // { // @1021 memory[0x40:0x60] // @1086 memory[0x40:0x60] // @108B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 101F 60 PUSH1 0x40 1021 51 MLOAD 1022 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1043 81 DUP2 1044 52 MSTORE 1045 60 PUSH1 0x04 1047 01 ADD 1048 80 DUP1 1049 80 DUP1 104A 60 PUSH1 0x20 104C 01 ADD 104D 82 DUP3 104E 81 DUP2 104F 03 SUB 1050 82 DUP3 1051 52 MSTORE 1052 60 PUSH1 0x06 1054 81 DUP2 1055 52 MSTORE 1056 60 PUSH1 0x20 1058 01 ADD 1059 80 DUP1 105A 7F PUSH32 0x216f776e65720000000000000000000000000000000000000000000000000000 107B 81 DUP2 107C 52 MSTORE 107D 50 POP 107E 60 PUSH1 0x20 1080 01 ADD 1081 91 SWAP2 1082 50 POP 1083 50 POP 1084 60 PUSH1 0x40 1086 51 MLOAD 1087 80 DUP1 1088 91 SWAP2 1089 03 SUB 108A 90 SWAP1 108B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1044 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1051 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1055 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x06 // @107C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x216f776e65720000000000000000000000000000000000000000000000000000 // @108B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_108C: // Incoming jump from 0x101E, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[3] // { // @108D stack[-1] // @1097 storage[0x0b] // @10CF stack[-2] // } 108C 5B JUMPDEST 108D 80 DUP1 108E 60 PUSH1 0x0b 1090 60 PUSH1 0x00 1092 61 PUSH2 0x0100 1095 0A EXP 1096 81 DUP2 1097 54 SLOAD 1098 81 DUP2 1099 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10AE 02 MUL 10AF 19 NOT 10B0 16 AND 10B1 90 SWAP1 10B2 83 DUP4 10B3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10C8 16 AND 10C9 02 MUL 10CA 17 OR 10CB 90 SWAP1 10CC 55 SSTORE 10CD 50 POP 10CE 50 POP 10CF 56 *JUMP // Stack delta = -2 // Outputs[1] { @10CC storage[0x0b] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0b]) } // Block ends with unconditional jump to stack[-2] label_10D0: // Incoming call from 0x05AA, returns to 0x05AB // Inputs[3] // { // @10D6 storage[0x07] // @10F7 memory[0x40:0x60] // @110A storage[0x07] // } 10D0 5B JUMPDEST 10D1 60 PUSH1 0x60 10D3 60 PUSH1 0x07 10D5 80 DUP1 10D6 54 SLOAD 10D7 60 PUSH1 0x01 10D9 81 DUP2 10DA 60 PUSH1 0x01 10DC 16 AND 10DD 15 ISZERO 10DE 61 PUSH2 0x0100 10E1 02 MUL 10E2 03 SUB 10E3 16 AND 10E4 60 PUSH1 0x02 10E6 90 SWAP1 10E7 04 DIV 10E8 80 DUP1 10E9 60 PUSH1 0x1f 10EB 01 ADD 10EC 60 PUSH1 0x20 10EE 80 DUP1 10EF 91 SWAP2 10F0 04 DIV 10F1 02 MUL 10F2 60 PUSH1 0x20 10F4 01 ADD 10F5 60 PUSH1 0x40 10F7 51 MLOAD 10F8 90 SWAP1 10F9 81 DUP2 10FA 01 ADD 10FB 60 PUSH1 0x40 10FD 52 MSTORE 10FE 80 DUP1 10FF 92 SWAP3 1100 91 SWAP2 1101 90 SWAP1 1102 81 DUP2 1103 81 DUP2 1104 52 MSTORE 1105 60 PUSH1 0x20 1107 01 ADD 1108 82 DUP3 1109 80 DUP1 110A 54 SLOAD 110B 60 PUSH1 0x01 110D 81 DUP2 110E 60 PUSH1 0x01 1110 16 AND 1111 15 ISZERO 1112 61 PUSH2 0x0100 1115 02 MUL 1116 03 SUB 1117 16 AND 1118 60 PUSH1 0x02 111A 90 SWAP1 111B 04 DIV 111C 80 DUP1 111D 15 ISZERO 111E 61 PUSH2 0x1168 1121 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @10D1 stack[0] = 0x60 // @10FD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) / 0x20 * 0x20 // @10FF stack[1] = memory[0x40:0x60] // @1100 stack[2] = 0x07 // @1101 stack[3] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // @1104 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // @1107 stack[4] = 0x20 + memory[0x40:0x60] // @1108 stack[5] = 0x07 // @111B stack[6] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // } // Block ends with conditional jump to 0x1168, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) label_1122: // Incoming jump from 0x1121, if not !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Inputs[1] { @1122 stack[-1] } 1122 80 DUP1 1123 60 PUSH1 0x1f 1125 10 LT 1126 61 PUSH2 0x113d 1129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x113d, if 0x1f < stack[-1] label_112A: // Incoming jump from 0x1129, if not 0x1f < stack[-1] // Inputs[4] // { // @112E stack[-2] // @112F storage[stack[-2]] // @1132 stack[-3] // @1134 stack[-1] // } 112A 61 PUSH2 0x0100 112D 80 DUP1 112E 83 DUP4 112F 54 SLOAD 1130 04 DIV 1131 02 MUL 1132 83 DUP4 1133 52 MSTORE 1134 91 SWAP2 1135 60 PUSH1 0x20 1137 01 ADD 1138 91 SWAP2 1139 61 PUSH2 0x1168 113C 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1133 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1138 stack[-1] = stack[-1] // @1138 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1168 label_113D: // Incoming jump from 0x1129, if 0x1f < stack[-1] // Inputs[5] // { // @113E stack[-3] // @113F stack[-1] // @1141 stack[-2] // @1149 memory[0x00:0x20] // @114D storage[keccak256(memory[0x00:0x20])] // } 113D 5B JUMPDEST 113E 82 DUP3 113F 01 ADD 1140 91 SWAP2 1141 90 SWAP1 1142 60 PUSH1 0x00 1144 52 MSTORE 1145 60 PUSH1 0x20 1147 60 PUSH1 0x00 1149 20 SHA3 114A 90 SWAP1 114B 5B JUMPDEST 114C 81 DUP2 114D 54 SLOAD 114E 81 DUP2 114F 52 MSTORE 1150 90 SWAP1 1151 60 PUSH1 0x01 1153 01 ADD 1154 90 SWAP1 1155 60 PUSH1 0x20 1157 01 ADD 1158 80 DUP1 1159 83 DUP4 115A 11 GT 115B 61 PUSH2 0x114b 115E 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1140 stack[-3] = stack[-3] + stack[-1] // @1144 memory[0x00:0x20] = stack[-2] // @114F memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1154 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1157 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x114b, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_115F: // Incoming jump from 0x115E, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x115E, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @115F stack[-3] // @1160 stack[-1] // } 115F 82 DUP3 1160 90 SWAP1 1161 03 SUB 1162 60 PUSH1 0x1f 1164 16 AND 1165 82 DUP3 1166 01 ADD 1167 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1167 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1167 stack[-1] = stack[-3] // } // Block continues label_1168: // Incoming jump from 0x1121, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Incoming jump from 0x113C // Incoming jump from 0x1167 // Inputs[3] // { // @116E stack[-6] // @116E stack[-7] // @1170 stack[-8] // } 1168 5B JUMPDEST 1169 50 POP 116A 50 POP 116B 50 POP 116C 50 POP 116D 50 POP 116E 90 SWAP1 116F 50 POP 1170 90 SWAP1 1171 56 *JUMP // Stack delta = -7 // Outputs[1] { @1170 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1172: // Incoming jump from 0x0E99 // Incoming jump from 0x0671 1172 5B JUMPDEST 1173 60 PUSH1 0x00 1175 61 PUSH2 0x1186 1178 61 PUSH2 0x117f 117B 61 PUSH2 0x13f5 117E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1173 stack[0] = 0x00 // @1175 stack[1] = 0x1186 // @1178 stack[2] = 0x117f // } // Block ends with call to 0x13f5, returns to 0x117F label_117F: // Incoming return from call to 0x13F5 at 0x117E // Inputs[2] // { // @1180 stack[-5] // @1181 stack[-4] // } 117F 5B JUMPDEST 1180 84 DUP5 1181 84 DUP5 1182 61 PUSH2 0x15f4 1185 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1180 stack[0] = stack[-5] // @1181 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x15f4 label_1186: // Incoming return from call to 0x117F at 0x117E // Inputs[3] // { // @1189 stack[-1] // @118B stack[-4] // @118C stack[-3] // } 1186 5B JUMPDEST 1187 60 PUSH1 0x01 1189 90 SWAP1 118A 50 POP 118B 92 SWAP3 118C 91 SWAP2 118D 50 POP 118E 50 POP 118F 56 *JUMP // Stack delta = -3 // Outputs[1] { @118B stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_1190: // Incoming call from 0x0693, returns to 0x0694 // Inputs[2] // { // @1196 storage[0x0a] // @11B4 stack[-1] // } 1190 5B JUMPDEST 1191 60 PUSH1 0x0a 1193 60 PUSH1 0x00 1195 90 SWAP1 1196 54 SLOAD 1197 90 SWAP1 1198 61 PUSH2 0x0100 119B 0A EXP 119C 90 SWAP1 119D 04 DIV 119E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11B3 16 AND 11B4 81 DUP2 11B5 56 *JUMP // Stack delta = +1 // Outputs[1] { @11B3 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_11B6: // Incoming jump from 0x0737 // Inputs[6] // { // @11BD stack[-2] // @11F7 memory[0x00:0x40] // @11FA stack[-1] // @1234 memory[0x00:0x40] // @1235 storage[keccak256(memory[0x00:0x40])] // @1238 stack[-3] // } 11B6 5B JUMPDEST 11B7 60 PUSH1 0x00 11B9 60 PUSH1 0x04 11BB 60 PUSH1 0x00 11BD 84 DUP5 11BE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11D3 16 AND 11D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11E9 16 AND 11EA 81 DUP2 11EB 52 MSTORE 11EC 60 PUSH1 0x20 11EE 01 ADD 11EF 90 SWAP1 11F0 81 DUP2 11F1 52 MSTORE 11F2 60 PUSH1 0x20 11F4 01 ADD 11F5 60 PUSH1 0x00 11F7 20 SHA3 11F8 60 PUSH1 0x00 11FA 83 DUP4 11FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1210 16 AND 1211 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1226 16 AND 1227 81 DUP2 1228 52 MSTORE 1229 60 PUSH1 0x20 122B 01 ADD 122C 90 SWAP1 122D 81 DUP2 122E 52 MSTORE 122F 60 PUSH1 0x20 1231 01 ADD 1232 60 PUSH1 0x00 1234 20 SHA3 1235 54 SLOAD 1236 90 SWAP1 1237 50 POP 1238 92 SWAP3 1239 91 SWAP2 123A 50 POP 123B 50 POP 123C 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @11EB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @11F1 memory[0x20:0x40] = 0x04 // @1228 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @122E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1238 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_123D: // Incoming jump from 0x0803 // Inputs[2] // { // @1243 storage[0x0a] // @1277 msg.sender // } 123D 5B JUMPDEST 123E 60 PUSH1 0x0a 1240 60 PUSH1 0x00 1242 90 SWAP1 1243 54 SLOAD 1244 90 SWAP1 1245 61 PUSH2 0x0100 1248 0A EXP 1249 90 SWAP1 124A 04 DIV 124B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1260 16 AND 1261 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1276 16 AND 1277 33 CALLER 1278 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 128D 16 AND 128E 14 EQ 128F 61 PUSH2 0x1300 1292 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1300, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 label_1293: // Incoming jump from 0x1292, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[3] // { // @1295 memory[0x40:0x60] // @12FA memory[0x40:0x60] // @12FF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1293 60 PUSH1 0x40 1295 51 MLOAD 1296 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 12B7 81 DUP2 12B8 52 MSTORE 12B9 60 PUSH1 0x04 12BB 01 ADD 12BC 80 DUP1 12BD 80 DUP1 12BE 60 PUSH1 0x20 12C0 01 ADD 12C1 82 DUP3 12C2 81 DUP2 12C3 03 SUB 12C4 82 DUP3 12C5 52 MSTORE 12C6 60 PUSH1 0x06 12C8 81 DUP2 12C9 52 MSTORE 12CA 60 PUSH1 0x20 12CC 01 ADD 12CD 80 DUP1 12CE 7F PUSH32 0x216f776e65720000000000000000000000000000000000000000000000000000 12EF 81 DUP2 12F0 52 MSTORE 12F1 50 POP 12F2 60 PUSH1 0x20 12F4 01 ADD 12F5 91 SWAP2 12F6 50 POP 12F7 50 POP 12F8 60 PUSH1 0x40 12FA 51 MLOAD 12FB 80 DUP1 12FC 91 SWAP2 12FD 03 SUB 12FE 90 SWAP1 12FF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @12B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @12C5 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @12C9 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x06 // @12F0 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x216f776e65720000000000000000000000000000000000000000000000000000 // @12FF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1300: // Incoming jump from 0x1292, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[2] // { // @1307 stack[-1] // @1308 memory[stack[-1]:stack[-1] + 0x20] // } 1300 5B JUMPDEST 1301 60 PUSH1 0x00 1303 80 DUP1 1304 90 SWAP1 1305 50 POP 1306 5B JUMPDEST 1307 81 DUP2 1308 51 MLOAD 1309 81 DUP2 130A 10 LT 130B 15 ISZERO 130C 61 PUSH2 0x13f1 130F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1304 stack[0] = 0x00 } // Block ends with conditional jump to 0x13f1, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1310: // Incoming jump from 0x130F, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x130F, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1315 stack[-2] // @1316 stack[-1] // @1318 memory[stack[-2]:stack[-2] + 0x20] // } 1310 60 PUSH1 0x01 1312 80 DUP1 1313 60 PUSH1 0x00 1315 84 DUP5 1316 84 DUP5 1317 81 DUP2 1318 51 MLOAD 1319 81 DUP2 131A 10 LT 131B 61 PUSH2 0x1320 131E 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1310 stack[0] = 0x01 // @1312 stack[1] = 0x01 // @1313 stack[2] = 0x00 // @1315 stack[3] = stack[-2] // @1316 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x1320, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_131F: // Incoming jump from 0x131E, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 131F FE *ASSERT // Stack delta = +0 // Outputs[1] { @131F assert(); } // Block terminates label_1320: // Incoming jump from 0x131E, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[11] // { // @1323 stack[-1] // @1327 stack[-2] // @1328 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1355 stack[-3] // @135A stack[-4] // @1362 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @136A storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @1372 stack[-5] // @1380 stack[-7] // @1381 stack[-6] // @1383 memory[stack[-7]:stack[-7] + 0x20] // } 1320 5B JUMPDEST 1321 60 PUSH1 0x20 1323 02 MUL 1324 60 PUSH1 0x20 1326 01 ADD 1327 01 ADD 1328 51 MLOAD 1329 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 133E 16 AND 133F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1354 16 AND 1355 81 DUP2 1356 52 MSTORE 1357 60 PUSH1 0x20 1359 01 ADD 135A 90 SWAP1 135B 81 DUP2 135C 52 MSTORE 135D 60 PUSH1 0x20 135F 01 ADD 1360 60 PUSH1 0x00 1362 20 SHA3 1363 60 PUSH1 0x00 1365 61 PUSH2 0x0100 1368 0A EXP 1369 81 DUP2 136A 54 SLOAD 136B 81 DUP2 136C 60 PUSH1 0xff 136E 02 MUL 136F 19 NOT 1370 16 AND 1371 90 SWAP1 1372 83 DUP4 1373 15 ISZERO 1374 15 ISZERO 1375 02 MUL 1376 17 OR 1377 90 SWAP1 1378 55 SSTORE 1379 50 POP 137A 60 PUSH1 0x00 137C 60 PUSH1 0x02 137E 60 PUSH1 0x00 1380 84 DUP5 1381 84 DUP5 1382 81 DUP2 1383 51 MLOAD 1384 81 DUP2 1385 10 LT 1386 61 PUSH2 0x138b 1389 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @1356 memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @135C memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @1378 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // @137A stack[-5] = 0x00 // @137C stack[-4] = 0x02 // @137E stack[-3] = 0x00 // @1380 stack[-2] = stack[-7] // @1381 stack[-1] = stack[-6] // } // Block ends with conditional jump to 0x138b, if stack[-6] < memory[stack[-7]:stack[-7] + 0x20] label_138A: // Incoming jump from 0x1389, if not stack[-6] < memory[stack[-7]:stack[-7] + 0x20] 138A FE *ASSERT // Stack delta = +0 // Outputs[1] { @138A assert(); } // Block terminates label_138B: // Incoming jump from 0x1389, if stack[-6] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[9] // { // @138E stack[-1] // @1392 stack[-2] // @1393 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @13C0 stack[-3] // @13C5 stack[-4] // @13CD memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @13D5 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @13DD stack[-5] // @13E5 stack[-6] // } 138B 5B JUMPDEST 138C 60 PUSH1 0x20 138E 02 MUL 138F 60 PUSH1 0x20 1391 01 ADD 1392 01 ADD 1393 51 MLOAD 1394 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13A9 16 AND 13AA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13BF 16 AND 13C0 81 DUP2 13C1 52 MSTORE 13C2 60 PUSH1 0x20 13C4 01 ADD 13C5 90 SWAP1 13C6 81 DUP2 13C7 52 MSTORE 13C8 60 PUSH1 0x20 13CA 01 ADD 13CB 60 PUSH1 0x00 13CD 20 SHA3 13CE 60 PUSH1 0x00 13D0 61 PUSH2 0x0100 13D3 0A EXP 13D4 81 DUP2 13D5 54 SLOAD 13D6 81 DUP2 13D7 60 PUSH1 0xff 13D9 02 MUL 13DA 19 NOT 13DB 16 AND 13DC 90 SWAP1 13DD 83 DUP4 13DE 15 ISZERO 13DF 15 ISZERO 13E0 02 MUL 13E1 17 OR 13E2 90 SWAP1 13E3 55 SSTORE 13E4 50 POP 13E5 80 DUP1 13E6 80 DUP1 13E7 60 PUSH1 0x01 13E9 01 ADD 13EA 91 SWAP2 13EB 50 POP 13EC 50 POP 13ED 61 PUSH2 0x1306 13F0 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @13C1 memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @13C7 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @13E3 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // @13EA stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x1306 label_13F1: // Incoming jump from 0x130F, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x130F, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @13F4 stack[-3] } 13F1 5B JUMPDEST 13F2 50 POP 13F3 50 POP 13F4 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_13F5: // Incoming call from 0x0B07, returns to 0x0B08 // Incoming call from 0x0AA1, returns to 0x0AA2 // Incoming call from 0x0A6D, returns to 0x0A6E // Incoming call from 0x117E, returns to 0x117F // Inputs[2] // { // @13F8 msg.sender // @13FB stack[-1] // } 13F5 5B JUMPDEST 13F6 60 PUSH1 0x00 13F8 33 CALLER 13F9 90 SWAP1 13FA 50 POP 13FB 90 SWAP1 13FC 56 *JUMP // Stack delta = +0 // Outputs[1] { @13FB stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_13FD: // Incoming jump from 0x0B56 // Incoming jump from 0x0F6C // Incoming jump from 0x0A74 // Inputs[1] { @1416 stack[-3] } 13FD 5B JUMPDEST 13FE 60 PUSH1 0x00 1400 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1415 16 AND 1416 83 DUP4 1417 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 142C 16 AND 142D 14 EQ 142E 15 ISZERO 142F 61 PUSH2 0x1483 1432 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1483, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1433: // Incoming jump from 0x1432, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1435 memory[0x40:0x60] // @147D memory[0x40:0x60] // @1482 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1433 60 PUSH1 0x40 1435 51 MLOAD 1436 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1457 81 DUP2 1458 52 MSTORE 1459 60 PUSH1 0x04 145B 01 ADD 145C 80 DUP1 145D 80 DUP1 145E 60 PUSH1 0x20 1460 01 ADD 1461 82 DUP3 1462 81 DUP2 1463 03 SUB 1464 82 DUP3 1465 52 MSTORE 1466 60 PUSH1 0x24 1468 81 DUP2 1469 52 MSTORE 146A 60 PUSH1 0x20 146C 01 ADD 146D 80 DUP1 146E 61 PUSH2 0x2ef7 1471 60 PUSH1 0x24 1473 91 SWAP2 1474 39 CODECOPY 1475 60 PUSH1 0x40 1477 01 ADD 1478 91 SWAP2 1479 50 POP 147A 50 POP 147B 60 PUSH1 0x40 147D 51 MLOAD 147E 80 DUP1 147F 91 SWAP2 1480 03 SUB 1481 90 SWAP1 1482 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1458 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1465 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1469 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @1474 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x2ef7:0x2f1b] // @1482 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1483: // Incoming jump from 0x1432, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @149C stack[-2] } 1483 5B JUMPDEST 1484 60 PUSH1 0x00 1486 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 149B 16 AND 149C 82 DUP3 149D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14B2 16 AND 14B3 14 EQ 14B4 15 ISZERO 14B5 61 PUSH2 0x1509 14B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1509, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_14B9: // Incoming jump from 0x14B8, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @14BB memory[0x40:0x60] // @1503 memory[0x40:0x60] // @1508 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 14B9 60 PUSH1 0x40 14BB 51 MLOAD 14BC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 14DD 81 DUP2 14DE 52 MSTORE 14DF 60 PUSH1 0x04 14E1 01 ADD 14E2 80 DUP1 14E3 80 DUP1 14E4 60 PUSH1 0x20 14E6 01 ADD 14E7 82 DUP3 14E8 81 DUP2 14E9 03 SUB 14EA 82 DUP3 14EB 52 MSTORE 14EC 60 PUSH1 0x22 14EE 81 DUP2 14EF 52 MSTORE 14F0 60 PUSH1 0x20 14F2 01 ADD 14F3 80 DUP1 14F4 61 PUSH2 0x2e62 14F7 60 PUSH1 0x22 14F9 91 SWAP2 14FA 39 CODECOPY 14FB 60 PUSH1 0x40 14FD 01 ADD 14FE 91 SWAP2 14FF 50 POP 1500 50 POP 1501 60 PUSH1 0x40 1503 51 MLOAD 1504 80 DUP1 1505 91 SWAP2 1506 03 SUB 1507 90 SWAP1 1508 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @14DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @14EB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @14EF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @14FA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x2e62:0x2e84] // @1508 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1509: // Incoming jump from 0x14B8, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[9] // { // @150A stack[-1] // @150F stack[-3] // @1549 memory[0x00:0x40] // @154C stack[-2] // @1586 memory[0x00:0x40] // @15DD memory[0x40:0x60] // @15EA memory[0x40:0x60] // @15EF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @15F3 stack[-4] // } 1509 5B JUMPDEST 150A 80 DUP1 150B 60 PUSH1 0x04 150D 60 PUSH1 0x00 150F 85 DUP6 1510 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1525 16 AND 1526 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 153B 16 AND 153C 81 DUP2 153D 52 MSTORE 153E 60 PUSH1 0x20 1540 01 ADD 1541 90 SWAP1 1542 81 DUP2 1543 52 MSTORE 1544 60 PUSH1 0x20 1546 01 ADD 1547 60 PUSH1 0x00 1549 20 SHA3 154A 60 PUSH1 0x00 154C 84 DUP5 154D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1562 16 AND 1563 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1578 16 AND 1579 81 DUP2 157A 52 MSTORE 157B 60 PUSH1 0x20 157D 01 ADD 157E 90 SWAP1 157F 81 DUP2 1580 52 MSTORE 1581 60 PUSH1 0x20 1583 01 ADD 1584 60 PUSH1 0x00 1586 20 SHA3 1587 81 DUP2 1588 90 SWAP1 1589 55 SSTORE 158A 50 POP 158B 81 DUP2 158C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15A1 16 AND 15A2 83 DUP4 15A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15B8 16 AND 15B9 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 15DA 83 DUP4 15DB 60 PUSH1 0x40 15DD 51 MLOAD 15DE 80 DUP1 15DF 82 DUP3 15E0 81 DUP2 15E1 52 MSTORE 15E2 60 PUSH1 0x20 15E4 01 ADD 15E5 91 SWAP2 15E6 50 POP 15E7 50 POP 15E8 60 PUSH1 0x40 15EA 51 MLOAD 15EB 80 DUP1 15EC 91 SWAP2 15ED 03 SUB 15EE 90 SWAP1 15EF A3 LOG3 15F0 50 POP 15F1 50 POP 15F2 50 POP 15F3 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @153D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1543 memory[0x20:0x40] = 0x04 // @157A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1580 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1589 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @15E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @15EF 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_15F4: // Incoming jump from 0x1185 // Incoming call from 0x0A95, returns to 0x0A96 // Inputs[5] // { // @15F5 stack[-3] // @15F6 stack[-2] // @15F7 stack[-1] // @15FD storage[0x0b] // @1636 storage[0x0a] // } 15F4 5B JUMPDEST 15F5 82 DUP3 15F6 82 DUP3 15F7 82 DUP3 15F8 60 PUSH1 0x0b 15FA 60 PUSH1 0x00 15FC 90 SWAP1 15FD 54 SLOAD 15FE 90 SWAP1 15FF 61 PUSH2 0x0100 1602 0A EXP 1603 90 SWAP1 1604 04 DIV 1605 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 161A 16 AND 161B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1630 16 AND 1631 60 PUSH1 0x0a 1633 60 PUSH1 0x00 1635 90 SWAP1 1636 54 SLOAD 1637 90 SWAP1 1638 61 PUSH2 0x0100 163B 0A EXP 163C 90 SWAP1 163D 04 DIV 163E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1653 16 AND 1654 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1669 16 AND 166A 14 EQ 166B 80 DUP1 166C 15 ISZERO 166D 61 PUSH2 0x16c3 1670 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @15F5 stack[0] = stack[-3] // @15F6 stack[1] = stack[-2] // @15F7 stack[2] = stack[-1] // @166A stack[3] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 // } // Block ends with conditional jump to 0x16c3, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00) label_1671: // Incoming jump from 0x1670, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00) // Inputs[2] // { // @1677 storage[0x0a] // @16AB stack[-4] // } 1671 50 POP 1672 60 PUSH1 0x0a 1674 60 PUSH1 0x00 1676 90 SWAP1 1677 54 SLOAD 1678 90 SWAP1 1679 61 PUSH2 0x0100 167C 0A EXP 167D 90 SWAP1 167E 04 DIV 167F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1694 16 AND 1695 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16AA 16 AND 16AB 83 DUP4 16AC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16C1 16 AND 16C2 14 EQ 16C3 5B JUMPDEST 16C4 15 ISZERO 16C5 61 PUSH2 0x19ca 16C8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x19ca, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00) label_16C9: // Incoming jump from 0x16C8, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00) // Incoming jump from 0x16C8, if not !stack[-1] // Inputs[3] // { // @16C9 stack[-2] // @16D3 storage[0x0b] // @1722 stack[-6] // } 16C9 81 DUP2 16CA 60 PUSH1 0x0b 16CC 60 PUSH1 0x00 16CE 61 PUSH2 0x0100 16D1 0A EXP 16D2 81 DUP2 16D3 54 SLOAD 16D4 81 DUP2 16D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16EA 02 MUL 16EB 19 NOT 16EC 16 AND 16ED 90 SWAP1 16EE 83 DUP4 16EF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1704 16 AND 1705 02 MUL 1706 17 OR 1707 90 SWAP1 1708 55 SSTORE 1709 50 POP 170A 60 PUSH1 0x00 170C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1721 16 AND 1722 86 DUP7 1723 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1738 16 AND 1739 14 EQ 173A 15 ISZERO 173B 61 PUSH2 0x178f 173E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1708 storage[0x0b] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0b]) } // Block ends with conditional jump to 0x178f, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_173F: // Incoming jump from 0x173E, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1741 memory[0x40:0x60] // @1789 memory[0x40:0x60] // @178E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 173F 60 PUSH1 0x40 1741 51 MLOAD 1742 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1763 81 DUP2 1764 52 MSTORE 1765 60 PUSH1 0x04 1767 01 ADD 1768 80 DUP1 1769 80 DUP1 176A 60 PUSH1 0x20 176C 01 ADD 176D 82 DUP3 176E 81 DUP2 176F 03 SUB 1770 82 DUP3 1771 52 MSTORE 1772 60 PUSH1 0x25 1774 81 DUP2 1775 52 MSTORE 1776 60 PUSH1 0x20 1778 01 ADD 1779 80 DUP1 177A 61 PUSH2 0x2ed2 177D 60 PUSH1 0x25 177F 91 SWAP2 1780 39 CODECOPY 1781 60 PUSH1 0x40 1783 01 ADD 1784 91 SWAP2 1785 50 POP 1786 50 POP 1787 60 PUSH1 0x40 1789 51 MLOAD 178A 80 DUP1 178B 91 SWAP2 178C 03 SUB 178D 90 SWAP1 178E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1764 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1771 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1775 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @1780 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2ed2:0x2ef7] // @178E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_178F: // Incoming jump from 0x173E, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @17A8 stack[-5] } 178F 5B JUMPDEST 1790 60 PUSH1 0x00 1792 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17A7 16 AND 17A8 85 DUP6 17A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17BE 16 AND 17BF 14 EQ 17C0 15 ISZERO 17C1 61 PUSH2 0x1815 17C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1815, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_17C5: // Incoming jump from 0x17C4, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @17C7 memory[0x40:0x60] // @180F memory[0x40:0x60] // @1814 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 17C5 60 PUSH1 0x40 17C7 51 MLOAD 17C8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 17E9 81 DUP2 17EA 52 MSTORE 17EB 60 PUSH1 0x04 17ED 01 ADD 17EE 80 DUP1 17EF 80 DUP1 17F0 60 PUSH1 0x20 17F2 01 ADD 17F3 82 DUP3 17F4 81 DUP2 17F5 03 SUB 17F6 82 DUP3 17F7 52 MSTORE 17F8 60 PUSH1 0x23 17FA 81 DUP2 17FB 52 MSTORE 17FC 60 PUSH1 0x20 17FE 01 ADD 17FF 80 DUP1 1800 61 PUSH2 0x2e3f 1803 60 PUSH1 0x23 1805 91 SWAP2 1806 39 CODECOPY 1807 60 PUSH1 0x40 1809 01 ADD 180A 91 SWAP2 180B 50 POP 180C 50 POP 180D 60 PUSH1 0x40 180F 51 MLOAD 1810 80 DUP1 1811 91 SWAP2 1812 03 SUB 1813 90 SWAP1 1814 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @17EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @17F7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @17FB memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @1806 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x2e3f:0x2e62] // @1814 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1815: // Incoming jump from 0x17C4, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1819 stack[-6] // @181A stack[-5] // @181B stack[-4] // } 1815 5B JUMPDEST 1816 61 PUSH2 0x1820 1819 86 DUP7 181A 86 DUP7 181B 86 DUP7 181C 61 PUSH2 0x2e39 181F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1816 stack[0] = 0x1820 // @1819 stack[1] = stack[-6] // @181A stack[2] = stack[-5] // @181B stack[3] = stack[-4] // } // Block ends with call to 0x2e39, returns to 0x1820 label_1820: // Incoming return from call to 0x2E39 at 0x181F // Inputs[5] // { // @1824 stack[-4] // @1827 memory[0x40:0x60] // @1841 stack[-6] // @187B memory[0x00:0x40] // @187C storage[keccak256(memory[0x00:0x40])] // } 1820 5B JUMPDEST 1821 61 PUSH2 0x188b 1824 84 DUP5 1825 60 PUSH1 0x40 1827 51 MLOAD 1828 80 DUP1 1829 60 PUSH1 0x60 182B 01 ADD 182C 60 PUSH1 0x40 182E 52 MSTORE 182F 80 DUP1 1830 60 PUSH1 0x26 1832 81 DUP2 1833 52 MSTORE 1834 60 PUSH1 0x20 1836 01 ADD 1837 61 PUSH2 0x2e84 183A 60 PUSH1 0x26 183C 91 SWAP2 183D 39 CODECOPY 183E 60 PUSH1 0x00 1840 80 DUP1 1841 8A DUP11 1842 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1857 16 AND 1858 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 186D 16 AND 186E 81 DUP2 186F 52 MSTORE 1870 60 PUSH1 0x20 1872 01 ADD 1873 90 SWAP1 1874 81 DUP2 1875 52 MSTORE 1876 60 PUSH1 0x20 1878 01 ADD 1879 60 PUSH1 0x00 187B 20 SHA3 187C 54 SLOAD 187D 61 PUSH2 0x2cf1 1880 90 SWAP1 1881 92 SWAP3 1882 91 SWAP2 1883 90 SWAP1 1884 63 PUSH4 0xffffffff 1889 16 AND 188A 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1821 stack[0] = 0x188b // @182E memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @1833 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 // @183D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x2e84:0x2eaa] // @186F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1875 memory[0x20:0x40] = 0x00 // @1881 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1882 stack[2] = stack[-4] // @1883 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x2cf1, returns to 0x188B label_188B: // Incoming return from call to 0x2CF1 at 0x188A // Inputs[7] // { // @188F stack[-7] // @18C9 memory[0x00:0x40] // @18CA stack[-1] // @18D1 stack[-5] // @18D5 stack[-6] // @190F memory[0x00:0x40] // @1910 storage[keccak256(memory[0x00:0x40])] // } 188B 5B JUMPDEST 188C 60 PUSH1 0x00 188E 80 DUP1 188F 88 DUP9 1890 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18A5 16 AND 18A6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18BB 16 AND 18BC 81 DUP2 18BD 52 MSTORE 18BE 60 PUSH1 0x20 18C0 01 ADD 18C1 90 SWAP1 18C2 81 DUP2 18C3 52 MSTORE 18C4 60 PUSH1 0x20 18C6 01 ADD 18C7 60 PUSH1 0x00 18C9 20 SHA3 18CA 81 DUP2 18CB 90 SWAP1 18CC 55 SSTORE 18CD 50 POP 18CE 61 PUSH2 0x191e 18D1 84 DUP5 18D2 60 PUSH1 0x00 18D4 80 DUP1 18D5 88 DUP9 18D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18EB 16 AND 18EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1901 16 AND 1902 81 DUP2 1903 52 MSTORE 1904 60 PUSH1 0x20 1906 01 ADD 1907 90 SWAP1 1908 81 DUP2 1909 52 MSTORE 190A 60 PUSH1 0x20 190C 01 ADD 190D 60 PUSH1 0x00 190F 20 SHA3 1910 54 SLOAD 1911 61 PUSH2 0x2db1 1914 90 SWAP1 1915 91 SWAP2 1916 90 SWAP1 1917 63 PUSH4 0xffffffff 191C 16 AND 191D 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @18BD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @18C3 memory[0x20:0x40] = 0x00 // @18CC storage[keccak256(memory[0x00:0x40])] = stack[-1] // @18CE stack[-1] = 0x191e // @1903 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1909 memory[0x20:0x40] = 0x00 // @1915 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1916 stack[1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x2db1, returns to 0x191E label_191E: // Incoming return from call to 0x2DB1 at 0x191D // Inputs[8] // { // @1922 stack[-6] // @195C memory[0x00:0x40] // @195D stack[-1] // @1978 stack[-7] // @19B0 stack[-5] // @19B3 memory[0x40:0x60] // @19C0 memory[0x40:0x60] // @19C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 191E 5B JUMPDEST 191F 60 PUSH1 0x00 1921 80 DUP1 1922 87 DUP8 1923 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1938 16 AND 1939 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 194E 16 AND 194F 81 DUP2 1950 52 MSTORE 1951 60 PUSH1 0x20 1953 01 ADD 1954 90 SWAP1 1955 81 DUP2 1956 52 MSTORE 1957 60 PUSH1 0x20 1959 01 ADD 195A 60 PUSH1 0x00 195C 20 SHA3 195D 81 DUP2 195E 90 SWAP1 195F 55 SSTORE 1960 50 POP 1961 84 DUP5 1962 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1977 16 AND 1978 86 DUP7 1979 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 198E 16 AND 198F 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 19B0 86 DUP7 19B1 60 PUSH1 0x40 19B3 51 MLOAD 19B4 80 DUP1 19B5 82 DUP3 19B6 81 DUP2 19B7 52 MSTORE 19B8 60 PUSH1 0x20 19BA 01 ADD 19BB 91 SWAP2 19BC 50 POP 19BD 50 POP 19BE 60 PUSH1 0x40 19C0 51 MLOAD 19C1 80 DUP1 19C2 91 SWAP2 19C3 03 SUB 19C4 90 SWAP1 19C5 A3 LOG3 19C6 61 PUSH2 0x2ce9 19C9 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1950 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1956 memory[0x20:0x40] = 0x00 // @195F storage[keccak256(memory[0x00:0x40])] = stack[-1] // @19B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @19C5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to 0x2ce9 label_19CA: // Incoming jump from 0x16C8, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00) // Incoming jump from 0x16C8, if !stack[-1] // Inputs[2] // { // @19D0 storage[0x0a] // @1A04 stack[-3] // } 19CA 5B JUMPDEST 19CB 60 PUSH1 0x0a 19CD 60 PUSH1 0x00 19CF 90 SWAP1 19D0 54 SLOAD 19D1 90 SWAP1 19D2 61 PUSH2 0x0100 19D5 0A EXP 19D6 90 SWAP1 19D7 04 DIV 19D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19ED 16 AND 19EE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A03 16 AND 1A04 83 DUP4 1A05 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A1A 16 AND 1A1B 14 EQ 1A1C 80 DUP1 1A1D 61 PUSH2 0x1a73 1A20 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A1B stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x1a73, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 label_1A21: // Incoming jump from 0x1A20, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 // Inputs[2] // { // @1A27 storage[0x0b] // @1A5B stack[-4] // } 1A21 50 POP 1A22 60 PUSH1 0x0b 1A24 60 PUSH1 0x00 1A26 90 SWAP1 1A27 54 SLOAD 1A28 90 SWAP1 1A29 61 PUSH2 0x0100 1A2C 0A EXP 1A2D 90 SWAP1 1A2E 04 DIV 1A2F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A44 16 AND 1A45 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A5A 16 AND 1A5B 83 DUP4 1A5C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A71 16 AND 1A72 14 EQ 1A73 5B JUMPDEST 1A74 80 DUP1 1A75 61 PUSH2 0x1acb 1A78 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A72 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x1acb, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 label_1A79: // Incoming jump from 0x1A78, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 // Incoming jump from 0x1A78, if not stack[-1] // Inputs[2] // { // @1A7F storage[0x0a] // @1AB3 stack[-3] // } 1A79 50 POP 1A7A 60 PUSH1 0x0a 1A7C 60 PUSH1 0x00 1A7E 90 SWAP1 1A7F 54 SLOAD 1A80 90 SWAP1 1A81 61 PUSH2 0x0100 1A84 0A EXP 1A85 90 SWAP1 1A86 04 DIV 1A87 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A9C 16 AND 1A9D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AB2 16 AND 1AB3 82 DUP3 1AB4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AC9 16 AND 1ACA 14 EQ 1ACB 5B JUMPDEST 1ACC 15 ISZERO 1ACD 61 PUSH2 0x1e26 1AD0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e26, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00) label_1AD1: // Incoming jump from 0x1AD0, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00) // Incoming jump from 0x1AD0, if not !stack[-1] // Inputs[2] // { // @1AD6 storage[0x0a] // @1B0A stack[-3] // } 1AD1 60 PUSH1 0x0a 1AD3 60 PUSH1 0x00 1AD5 90 SWAP1 1AD6 54 SLOAD 1AD7 90 SWAP1 1AD8 61 PUSH2 0x0100 1ADB 0A EXP 1ADC 90 SWAP1 1ADD 04 DIV 1ADE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AF3 16 AND 1AF4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B09 16 AND 1B0A 83 DUP4 1B0B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B20 16 AND 1B21 14 EQ 1B22 80 DUP1 1B23 15 ISZERO 1B24 61 PUSH2 0x1b58 1B27 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B21 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x1b58, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00) label_1B28: // Incoming jump from 0x1B27, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00) // Inputs[2] // { // @1B29 stack[-3] // @1B40 stack[-4] // } 1B28 50 POP 1B29 81 DUP2 1B2A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B3F 16 AND 1B40 83 DUP4 1B41 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B56 16 AND 1B57 14 EQ 1B58 5B JUMPDEST 1B59 15 ISZERO 1B5A 61 PUSH2 0x1b65 1B5D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b65, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) label_1B5E: // Incoming jump from 0x1B5D, if not !stack[-1] // Incoming jump from 0x1B5D, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) // Inputs[2] // { // @1B5E stack[-1] // @1B7E stack[-6] // } 1B5E 80 DUP1 1B5F 60 PUSH1 0x03 1B61 81 DUP2 1B62 90 SWAP1 1B63 55 SSTORE 1B64 50 POP 1B65 5B JUMPDEST 1B66 60 PUSH1 0x00 1B68 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B7D 16 AND 1B7E 86 DUP7 1B7F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B94 16 AND 1B95 14 EQ 1B96 15 ISZERO 1B97 61 PUSH2 0x1beb 1B9A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B63 storage[0x03] = stack[-1] } // Block ends with conditional jump to 0x1beb, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1B9B: // Incoming jump from 0x1B9A, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Incoming jump from 0x1B9A, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1B9D memory[0x40:0x60] // @1BE5 memory[0x40:0x60] // @1BEA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B9B 60 PUSH1 0x40 1B9D 51 MLOAD 1B9E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BBF 81 DUP2 1BC0 52 MSTORE 1BC1 60 PUSH1 0x04 1BC3 01 ADD 1BC4 80 DUP1 1BC5 80 DUP1 1BC6 60 PUSH1 0x20 1BC8 01 ADD 1BC9 82 DUP3 1BCA 81 DUP2 1BCB 03 SUB 1BCC 82 DUP3 1BCD 52 MSTORE 1BCE 60 PUSH1 0x25 1BD0 81 DUP2 1BD1 52 MSTORE 1BD2 60 PUSH1 0x20 1BD4 01 ADD 1BD5 80 DUP1 1BD6 61 PUSH2 0x2ed2 1BD9 60 PUSH1 0x25 1BDB 91 SWAP2 1BDC 39 CODECOPY 1BDD 60 PUSH1 0x40 1BDF 01 ADD 1BE0 91 SWAP2 1BE1 50 POP 1BE2 50 POP 1BE3 60 PUSH1 0x40 1BE5 51 MLOAD 1BE6 80 DUP1 1BE7 91 SWAP2 1BE8 03 SUB 1BE9 90 SWAP1 1BEA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1BC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1BCD memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1BD1 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @1BDC memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2ed2:0x2ef7] // @1BEA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1BEB: // Incoming jump from 0x1B9A, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Incoming jump from 0x1B9A, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1C04 stack[-5] } 1BEB 5B JUMPDEST 1BEC 60 PUSH1 0x00 1BEE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C03 16 AND 1C04 85 DUP6 1C05 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C1A 16 AND 1C1B 14 EQ 1C1C 15 ISZERO 1C1D 61 PUSH2 0x1c71 1C20 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c71, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1C21: // Incoming jump from 0x1C20, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1C23 memory[0x40:0x60] // @1C6B memory[0x40:0x60] // @1C70 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1C21 60 PUSH1 0x40 1C23 51 MLOAD 1C24 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1C45 81 DUP2 1C46 52 MSTORE 1C47 60 PUSH1 0x04 1C49 01 ADD 1C4A 80 DUP1 1C4B 80 DUP1 1C4C 60 PUSH1 0x20 1C4E 01 ADD 1C4F 82 DUP3 1C50 81 DUP2 1C51 03 SUB 1C52 82 DUP3 1C53 52 MSTORE 1C54 60 PUSH1 0x23 1C56 81 DUP2 1C57 52 MSTORE 1C58 60 PUSH1 0x20 1C5A 01 ADD 1C5B 80 DUP1 1C5C 61 PUSH2 0x2e3f 1C5F 60 PUSH1 0x23 1C61 91 SWAP2 1C62 39 CODECOPY 1C63 60 PUSH1 0x40 1C65 01 ADD 1C66 91 SWAP2 1C67 50 POP 1C68 50 POP 1C69 60 PUSH1 0x40 1C6B 51 MLOAD 1C6C 80 DUP1 1C6D 91 SWAP2 1C6E 03 SUB 1C6F 90 SWAP1 1C70 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1C46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C53 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1C57 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @1C62 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x2e3f:0x2e62] // @1C70 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1C71: // Incoming jump from 0x1C20, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1C75 stack[-6] // @1C76 stack[-5] // @1C77 stack[-4] // } 1C71 5B JUMPDEST 1C72 61 PUSH2 0x1c7c 1C75 86 DUP7 1C76 86 DUP7 1C77 86 DUP7 1C78 61 PUSH2 0x2e39 1C7B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C72 stack[0] = 0x1c7c // @1C75 stack[1] = stack[-6] // @1C76 stack[2] = stack[-5] // @1C77 stack[3] = stack[-4] // } // Block ends with call to 0x2e39, returns to 0x1C7C label_1C7C: // Incoming return from call to 0x2E39 at 0x1C7B // Inputs[5] // { // @1C80 stack[-4] // @1C83 memory[0x40:0x60] // @1C9D stack[-6] // @1CD7 memory[0x00:0x40] // @1CD8 storage[keccak256(memory[0x00:0x40])] // } 1C7C 5B JUMPDEST 1C7D 61 PUSH2 0x1ce7 1C80 84 DUP5 1C81 60 PUSH1 0x40 1C83 51 MLOAD 1C84 80 DUP1 1C85 60 PUSH1 0x60 1C87 01 ADD 1C88 60 PUSH1 0x40 1C8A 52 MSTORE 1C8B 80 DUP1 1C8C 60 PUSH1 0x26 1C8E 81 DUP2 1C8F 52 MSTORE 1C90 60 PUSH1 0x20 1C92 01 ADD 1C93 61 PUSH2 0x2e84 1C96 60 PUSH1 0x26 1C98 91 SWAP2 1C99 39 CODECOPY 1C9A 60 PUSH1 0x00 1C9C 80 DUP1 1C9D 8A DUP11 1C9E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CB3 16 AND 1CB4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CC9 16 AND 1CCA 81 DUP2 1CCB 52 MSTORE 1CCC 60 PUSH1 0x20 1CCE 01 ADD 1CCF 90 SWAP1 1CD0 81 DUP2 1CD1 52 MSTORE 1CD2 60 PUSH1 0x20 1CD4 01 ADD 1CD5 60 PUSH1 0x00 1CD7 20 SHA3 1CD8 54 SLOAD 1CD9 61 PUSH2 0x2cf1 1CDC 90 SWAP1 1CDD 92 SWAP3 1CDE 91 SWAP2 1CDF 90 SWAP1 1CE0 63 PUSH4 0xffffffff 1CE5 16 AND 1CE6 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1C7D stack[0] = 0x1ce7 // @1C8A memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @1C8F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 // @1C99 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x2e84:0x2eaa] // @1CCB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1CD1 memory[0x20:0x40] = 0x00 // @1CDD stack[1] = storage[keccak256(memory[0x00:0x40])] // @1CDE stack[2] = stack[-4] // @1CDF stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x2cf1, returns to 0x1CE7 label_1CE7: // Incoming return from call to 0x2CF1 at 0x1CE6 // Inputs[7] // { // @1CEB stack[-7] // @1D25 memory[0x00:0x40] // @1D26 stack[-1] // @1D2D stack[-5] // @1D31 stack[-6] // @1D6B memory[0x00:0x40] // @1D6C storage[keccak256(memory[0x00:0x40])] // } 1CE7 5B JUMPDEST 1CE8 60 PUSH1 0x00 1CEA 80 DUP1 1CEB 88 DUP9 1CEC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D01 16 AND 1D02 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D17 16 AND 1D18 81 DUP2 1D19 52 MSTORE 1D1A 60 PUSH1 0x20 1D1C 01 ADD 1D1D 90 SWAP1 1D1E 81 DUP2 1D1F 52 MSTORE 1D20 60 PUSH1 0x20 1D22 01 ADD 1D23 60 PUSH1 0x00 1D25 20 SHA3 1D26 81 DUP2 1D27 90 SWAP1 1D28 55 SSTORE 1D29 50 POP 1D2A 61 PUSH2 0x1d7a 1D2D 84 DUP5 1D2E 60 PUSH1 0x00 1D30 80 DUP1 1D31 88 DUP9 1D32 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D47 16 AND 1D48 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D5D 16 AND 1D5E 81 DUP2 1D5F 52 MSTORE 1D60 60 PUSH1 0x20 1D62 01 ADD 1D63 90 SWAP1 1D64 81 DUP2 1D65 52 MSTORE 1D66 60 PUSH1 0x20 1D68 01 ADD 1D69 60 PUSH1 0x00 1D6B 20 SHA3 1D6C 54 SLOAD 1D6D 61 PUSH2 0x2db1 1D70 90 SWAP1 1D71 91 SWAP2 1D72 90 SWAP1 1D73 63 PUSH4 0xffffffff 1D78 16 AND 1D79 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1D19 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @1D1F memory[0x20:0x40] = 0x00 // @1D28 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1D2A stack[-1] = 0x1d7a // @1D5F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1D65 memory[0x20:0x40] = 0x00 // @1D71 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1D72 stack[1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x2db1, returns to 0x1D7A label_1D7A: // Incoming return from call to 0x2DB1 at 0x1D79 // Inputs[8] // { // @1D7E stack[-6] // @1DB8 memory[0x00:0x40] // @1DB9 stack[-1] // @1DD4 stack[-7] // @1E0C stack[-5] // @1E0F memory[0x40:0x60] // @1E1C memory[0x40:0x60] // @1E21 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1D7A 5B JUMPDEST 1D7B 60 PUSH1 0x00 1D7D 80 DUP1 1D7E 87 DUP8 1D7F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D94 16 AND 1D95 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DAA 16 AND 1DAB 81 DUP2 1DAC 52 MSTORE 1DAD 60 PUSH1 0x20 1DAF 01 ADD 1DB0 90 SWAP1 1DB1 81 DUP2 1DB2 52 MSTORE 1DB3 60 PUSH1 0x20 1DB5 01 ADD 1DB6 60 PUSH1 0x00 1DB8 20 SHA3 1DB9 81 DUP2 1DBA 90 SWAP1 1DBB 55 SSTORE 1DBC 50 POP 1DBD 84 DUP5 1DBE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DD3 16 AND 1DD4 86 DUP7 1DD5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DEA 16 AND 1DEB 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1E0C 86 DUP7 1E0D 60 PUSH1 0x40 1E0F 51 MLOAD 1E10 80 DUP1 1E11 82 DUP3 1E12 81 DUP2 1E13 52 MSTORE 1E14 60 PUSH1 0x20 1E16 01 ADD 1E17 91 SWAP2 1E18 50 POP 1E19 50 POP 1E1A 60 PUSH1 0x40 1E1C 51 MLOAD 1E1D 80 DUP1 1E1E 91 SWAP2 1E1F 03 SUB 1E20 90 SWAP1 1E21 A3 LOG3 1E22 61 PUSH2 0x2ce8 1E25 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1DAC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1DB2 memory[0x20:0x40] = 0x00 // @1DBB storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1E13 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @1E21 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to 0x2ce8 label_1E26: // Incoming jump from 0x1AD0, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00) // Incoming jump from 0x1AD0, if !stack[-1] // Inputs[3] // { // @1E2F stack[-3] // @1E69 memory[0x00:0x40] // @1E6D storage[keccak256(memory[0x00:0x40])] // } 1E26 5B JUMPDEST 1E27 60 PUSH1 0x01 1E29 15 ISZERO 1E2A 15 ISZERO 1E2B 60 PUSH1 0x01 1E2D 60 PUSH1 0x00 1E2F 85 DUP6 1E30 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E45 16 AND 1E46 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E5B 16 AND 1E5C 81 DUP2 1E5D 52 MSTORE 1E5E 60 PUSH1 0x20 1E60 01 ADD 1E61 90 SWAP1 1E62 81 DUP2 1E63 52 MSTORE 1E64 60 PUSH1 0x20 1E66 01 ADD 1E67 60 PUSH1 0x00 1E69 20 SHA3 1E6A 60 PUSH1 0x00 1E6C 90 SWAP1 1E6D 54 SLOAD 1E6E 90 SWAP1 1E6F 61 PUSH2 0x0100 1E72 0A EXP 1E73 90 SWAP1 1E74 04 DIV 1E75 60 PUSH1 0xff 1E77 16 AND 1E78 15 ISZERO 1E79 15 ISZERO 1E7A 14 EQ 1E7B 15 ISZERO 1E7C 61 PUSH2 0x2140 1E7F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1E5D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1E63 memory[0x20:0x40] = 0x01 // } // Block ends with conditional jump to 0x2140, if !(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) label_1E80: // Incoming jump from 0x1E7F, if not !(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) // Inputs[1] { @1E98 stack[-6] } 1E80 60 PUSH1 0x00 1E82 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E97 16 AND 1E98 86 DUP7 1E99 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EAE 16 AND 1EAF 14 EQ 1EB0 15 ISZERO 1EB1 61 PUSH2 0x1f05 1EB4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f05, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1EB5: // Incoming jump from 0x1EB4, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1EB7 memory[0x40:0x60] // @1EFF memory[0x40:0x60] // @1F04 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1EB5 60 PUSH1 0x40 1EB7 51 MLOAD 1EB8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1ED9 81 DUP2 1EDA 52 MSTORE 1EDB 60 PUSH1 0x04 1EDD 01 ADD 1EDE 80 DUP1 1EDF 80 DUP1 1EE0 60 PUSH1 0x20 1EE2 01 ADD 1EE3 82 DUP3 1EE4 81 DUP2 1EE5 03 SUB 1EE6 82 DUP3 1EE7 52 MSTORE 1EE8 60 PUSH1 0x25 1EEA 81 DUP2 1EEB 52 MSTORE 1EEC 60 PUSH1 0x20 1EEE 01 ADD 1EEF 80 DUP1 1EF0 61 PUSH2 0x2ed2 1EF3 60 PUSH1 0x25 1EF5 91 SWAP2 1EF6 39 CODECOPY 1EF7 60 PUSH1 0x40 1EF9 01 ADD 1EFA 91 SWAP2 1EFB 50 POP 1EFC 50 POP 1EFD 60 PUSH1 0x40 1EFF 51 MLOAD 1F00 80 DUP1 1F01 91 SWAP2 1F02 03 SUB 1F03 90 SWAP1 1F04 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1EDA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1EE7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1EEB memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @1EF6 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2ed2:0x2ef7] // @1F04 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1F05: // Incoming jump from 0x1EB4, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1F1E stack[-5] } 1F05 5B JUMPDEST 1F06 60 PUSH1 0x00 1F08 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F1D 16 AND 1F1E 85 DUP6 1F1F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F34 16 AND 1F35 14 EQ 1F36 15 ISZERO 1F37 61 PUSH2 0x1f8b 1F3A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f8b, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1F3B: // Incoming jump from 0x1F3A, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1F3D memory[0x40:0x60] // @1F85 memory[0x40:0x60] // @1F8A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1F3B 60 PUSH1 0x40 1F3D 51 MLOAD 1F3E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1F5F 81 DUP2 1F60 52 MSTORE 1F61 60 PUSH1 0x04 1F63 01 ADD 1F64 80 DUP1 1F65 80 DUP1 1F66 60 PUSH1 0x20 1F68 01 ADD 1F69 82 DUP3 1F6A 81 DUP2 1F6B 03 SUB 1F6C 82 DUP3 1F6D 52 MSTORE 1F6E 60 PUSH1 0x23 1F70 81 DUP2 1F71 52 MSTORE 1F72 60 PUSH1 0x20 1F74 01 ADD 1F75 80 DUP1 1F76 61 PUSH2 0x2e3f 1F79 60 PUSH1 0x23 1F7B 91 SWAP2 1F7C 39 CODECOPY 1F7D 60 PUSH1 0x40 1F7F 01 ADD 1F80 91 SWAP2 1F81 50 POP 1F82 50 POP 1F83 60 PUSH1 0x40 1F85 51 MLOAD 1F86 80 DUP1 1F87 91 SWAP2 1F88 03 SUB 1F89 90 SWAP1 1F8A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1F60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1F6D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1F71 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @1F7C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x2e3f:0x2e62] // @1F8A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1F8B: // Incoming jump from 0x1F3A, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1F8F stack[-6] // @1F90 stack[-5] // @1F91 stack[-4] // } 1F8B 5B JUMPDEST 1F8C 61 PUSH2 0x1f96 1F8F 86 DUP7 1F90 86 DUP7 1F91 86 DUP7 1F92 61 PUSH2 0x2e39 1F95 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F8C stack[0] = 0x1f96 // @1F8F stack[1] = stack[-6] // @1F90 stack[2] = stack[-5] // @1F91 stack[3] = stack[-4] // } // Block ends with call to 0x2e39, returns to 0x1F96 label_1F96: // Incoming return from call to 0x2E39 at 0x1F95 // Inputs[5] // { // @1F9A stack[-4] // @1F9D memory[0x40:0x60] // @1FB7 stack[-6] // @1FF1 memory[0x00:0x40] // @1FF2 storage[keccak256(memory[0x00:0x40])] // } 1F96 5B JUMPDEST 1F97 61 PUSH2 0x2001 1F9A 84 DUP5 1F9B 60 PUSH1 0x40 1F9D 51 MLOAD 1F9E 80 DUP1 1F9F 60 PUSH1 0x60 1FA1 01 ADD 1FA2 60 PUSH1 0x40 1FA4 52 MSTORE 1FA5 80 DUP1 1FA6 60 PUSH1 0x26 1FA8 81 DUP2 1FA9 52 MSTORE 1FAA 60 PUSH1 0x20 1FAC 01 ADD 1FAD 61 PUSH2 0x2e84 1FB0 60 PUSH1 0x26 1FB2 91 SWAP2 1FB3 39 CODECOPY 1FB4 60 PUSH1 0x00 1FB6 80 DUP1 1FB7 8A DUP11 1FB8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FCD 16 AND 1FCE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FE3 16 AND 1FE4 81 DUP2 1FE5 52 MSTORE 1FE6 60 PUSH1 0x20 1FE8 01 ADD 1FE9 90 SWAP1 1FEA 81 DUP2 1FEB 52 MSTORE 1FEC 60 PUSH1 0x20 1FEE 01 ADD 1FEF 60 PUSH1 0x00 1FF1 20 SHA3 1FF2 54 SLOAD 1FF3 61 PUSH2 0x2cf1 1FF6 90 SWAP1 1FF7 92 SWAP3 1FF8 91 SWAP2 1FF9 90 SWAP1 1FFA 63 PUSH4 0xffffffff 1FFF 16 AND 2000 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1F97 stack[0] = 0x2001 // @1FA4 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @1FA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 // @1FB3 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x2e84:0x2eaa] // @1FE5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1FEB memory[0x20:0x40] = 0x00 // @1FF7 stack[1] = storage[keccak256(memory[0x00:0x40])] // @1FF8 stack[2] = stack[-4] // @1FF9 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x2cf1, returns to 0x2001 label_2001: // Incoming return from call to 0x2CF1 at 0x2000 // Inputs[7] // { // @2005 stack[-7] // @203F memory[0x00:0x40] // @2040 stack[-1] // @2047 stack[-5] // @204B stack[-6] // @2085 memory[0x00:0x40] // @2086 storage[keccak256(memory[0x00:0x40])] // } 2001 5B JUMPDEST 2002 60 PUSH1 0x00 2004 80 DUP1 2005 88 DUP9 2006 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 201B 16 AND 201C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2031 16 AND 2032 81 DUP2 2033 52 MSTORE 2034 60 PUSH1 0x20 2036 01 ADD 2037 90 SWAP1 2038 81 DUP2 2039 52 MSTORE 203A 60 PUSH1 0x20 203C 01 ADD 203D 60 PUSH1 0x00 203F 20 SHA3 2040 81 DUP2 2041 90 SWAP1 2042 55 SSTORE 2043 50 POP 2044 61 PUSH2 0x2094 2047 84 DUP5 2048 60 PUSH1 0x00 204A 80 DUP1 204B 88 DUP9 204C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2061 16 AND 2062 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2077 16 AND 2078 81 DUP2 2079 52 MSTORE 207A 60 PUSH1 0x20 207C 01 ADD 207D 90 SWAP1 207E 81 DUP2 207F 52 MSTORE 2080 60 PUSH1 0x20 2082 01 ADD 2083 60 PUSH1 0x00 2085 20 SHA3 2086 54 SLOAD 2087 61 PUSH2 0x2db1 208A 90 SWAP1 208B 91 SWAP2 208C 90 SWAP1 208D 63 PUSH4 0xffffffff 2092 16 AND 2093 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @2033 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2039 memory[0x20:0x40] = 0x00 // @2042 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2044 stack[-1] = 0x2094 // @2079 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @207F memory[0x20:0x40] = 0x00 // @208B stack[0] = storage[keccak256(memory[0x00:0x40])] // @208C stack[1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x2db1, returns to 0x2094 label_2094: // Incoming return from call to 0x2DB1 at 0x2093 // Inputs[8] // { // @2098 stack[-6] // @20D2 memory[0x00:0x40] // @20D3 stack[-1] // @20EE stack[-7] // @2126 stack[-5] // @2129 memory[0x40:0x60] // @2136 memory[0x40:0x60] // @213B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2094 5B JUMPDEST 2095 60 PUSH1 0x00 2097 80 DUP1 2098 87 DUP8 2099 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20AE 16 AND 20AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20C4 16 AND 20C5 81 DUP2 20C6 52 MSTORE 20C7 60 PUSH1 0x20 20C9 01 ADD 20CA 90 SWAP1 20CB 81 DUP2 20CC 52 MSTORE 20CD 60 PUSH1 0x20 20CF 01 ADD 20D0 60 PUSH1 0x00 20D2 20 SHA3 20D3 81 DUP2 20D4 90 SWAP1 20D5 55 SSTORE 20D6 50 POP 20D7 84 DUP5 20D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20ED 16 AND 20EE 86 DUP7 20EF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2104 16 AND 2105 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2126 86 DUP7 2127 60 PUSH1 0x40 2129 51 MLOAD 212A 80 DUP1 212B 82 DUP3 212C 81 DUP2 212D 52 MSTORE 212E 60 PUSH1 0x20 2130 01 ADD 2131 91 SWAP2 2132 50 POP 2133 50 POP 2134 60 PUSH1 0x40 2136 51 MLOAD 2137 80 DUP1 2138 91 SWAP2 2139 03 SUB 213A 90 SWAP1 213B A3 LOG3 213C 61 PUSH2 0x2ce7 213F 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @20C6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @20CC memory[0x20:0x40] = 0x00 // @20D5 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @212D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @213B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to 0x2ce7 label_2140: // Incoming jump from 0x1E7F, if !(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) // Inputs[3] // { // @2149 stack[-3] // @2183 memory[0x00:0x40] // @2187 storage[keccak256(memory[0x00:0x40])] // } 2140 5B JUMPDEST 2141 60 PUSH1 0x01 2143 15 ISZERO 2144 15 ISZERO 2145 60 PUSH1 0x02 2147 60 PUSH1 0x00 2149 85 DUP6 214A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 215F 16 AND 2160 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2175 16 AND 2176 81 DUP2 2177 52 MSTORE 2178 60 PUSH1 0x20 217A 01 ADD 217B 90 SWAP1 217C 81 DUP2 217D 52 MSTORE 217E 60 PUSH1 0x20 2180 01 ADD 2181 60 PUSH1 0x00 2183 20 SHA3 2184 60 PUSH1 0x00 2186 90 SWAP1 2187 54 SLOAD 2188 90 SWAP1 2189 61 PUSH2 0x0100 218C 0A EXP 218D 90 SWAP1 218E 04 DIV 218F 60 PUSH1 0xff 2191 16 AND 2192 15 ISZERO 2193 15 ISZERO 2194 14 EQ 2195 15 ISZERO 2196 61 PUSH2 0x2558 2199 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2177 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @217D memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x2558, if !(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) label_219A: // Incoming jump from 0x2199, if not !(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) // Inputs[2] // { // @219F storage[0x0b] // @21D3 stack[-3] // } 219A 60 PUSH1 0x0b 219C 60 PUSH1 0x00 219E 90 SWAP1 219F 54 SLOAD 21A0 90 SWAP1 21A1 61 PUSH2 0x0100 21A4 0A EXP 21A5 90 SWAP1 21A6 04 DIV 21A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21BC 16 AND 21BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21D2 16 AND 21D3 83 DUP4 21D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21E9 16 AND 21EA 14 EQ 21EB 80 DUP1 21EC 61 PUSH2 0x2242 21EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21EA stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x2242, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 label_21F0: // Incoming jump from 0x21EF, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 // Inputs[2] // { // @21F6 storage[0x0c] // @222A stack[-3] // } 21F0 50 POP 21F1 60 PUSH1 0x0c 21F3 60 PUSH1 0x00 21F5 90 SWAP1 21F6 54 SLOAD 21F7 90 SWAP1 21F8 61 PUSH2 0x0100 21FB 0A EXP 21FC 90 SWAP1 21FD 04 DIV 21FE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2213 16 AND 2214 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2229 16 AND 222A 82 DUP3 222B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2240 16 AND 2241 14 EQ 2242 5B JUMPDEST 2243 61 PUSH2 0x2297 2246 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2297, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0c] / 0x0100 ** 0x00 label_2247: // Incoming jump from 0x2246, if not stack[-1] // Incoming jump from 0x2246, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0c] / 0x0100 ** 0x00 // Inputs[3] // { // @2249 memory[0x40:0x60] // @2291 memory[0x40:0x60] // @2296 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2247 60 PUSH1 0x40 2249 51 MLOAD 224A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 226B 81 DUP2 226C 52 MSTORE 226D 60 PUSH1 0x04 226F 01 ADD 2270 80 DUP1 2271 80 DUP1 2272 60 PUSH1 0x20 2274 01 ADD 2275 82 DUP3 2276 81 DUP2 2277 03 SUB 2278 82 DUP3 2279 52 MSTORE 227A 60 PUSH1 0x26 227C 81 DUP2 227D 52 MSTORE 227E 60 PUSH1 0x20 2280 01 ADD 2281 80 DUP1 2282 61 PUSH2 0x2e84 2285 60 PUSH1 0x26 2287 91 SWAP2 2288 39 CODECOPY 2289 60 PUSH1 0x40 228B 01 ADD 228C 91 SWAP2 228D 50 POP 228E 50 POP 228F 60 PUSH1 0x40 2291 51 MLOAD 2292 80 DUP1 2293 91 SWAP2 2294 03 SUB 2295 90 SWAP1 2296 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @226C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2279 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @227D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @2288 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x2e84:0x2eaa] // @2296 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2297: // Incoming jump from 0x2246, if stack[-1] // Incoming jump from 0x2246, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0c] / 0x0100 ** 0x00 // Inputs[1] { @22B0 stack[-6] } 2297 5B JUMPDEST 2298 60 PUSH1 0x00 229A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22AF 16 AND 22B0 86 DUP7 22B1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 22C6 16 AND 22C7 14 EQ 22C8 15 ISZERO 22C9 61 PUSH2 0x231d 22CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x231d, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_22CD: // Incoming jump from 0x22CC, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @22CF memory[0x40:0x60] // @2317 memory[0x40:0x60] // @231C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 22CD 60 PUSH1 0x40 22CF 51 MLOAD 22D0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 22F1 81 DUP2 22F2 52 MSTORE 22F3 60 PUSH1 0x04 22F5 01 ADD 22F6 80 DUP1 22F7 80 DUP1 22F8 60 PUSH1 0x20 22FA 01 ADD 22FB 82 DUP3 22FC 81 DUP2 22FD 03 SUB 22FE 82 DUP3 22FF 52 MSTORE 2300 60 PUSH1 0x25 2302 81 DUP2 2303 52 MSTORE 2304 60 PUSH1 0x20 2306 01 ADD 2307 80 DUP1 2308 61 PUSH2 0x2ed2 230B 60 PUSH1 0x25 230D 91 SWAP2 230E 39 CODECOPY 230F 60 PUSH1 0x40 2311 01 ADD 2312 91 SWAP2 2313 50 POP 2314 50 POP 2315 60 PUSH1 0x40 2317 51 MLOAD 2318 80 DUP1 2319 91 SWAP2 231A 03 SUB 231B 90 SWAP1 231C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @22F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @22FF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2303 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @230E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2ed2:0x2ef7] // @231C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_231D: // Incoming jump from 0x22CC, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2336 stack[-5] } 231D 5B JUMPDEST 231E 60 PUSH1 0x00 2320 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2335 16 AND 2336 85 DUP6 2337 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 234C 16 AND 234D 14 EQ 234E 15 ISZERO 234F 61 PUSH2 0x23a3 2352 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x23a3, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2353: // Incoming jump from 0x2352, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2355 memory[0x40:0x60] // @239D memory[0x40:0x60] // @23A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2353 60 PUSH1 0x40 2355 51 MLOAD 2356 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2377 81 DUP2 2378 52 MSTORE 2379 60 PUSH1 0x04 237B 01 ADD 237C 80 DUP1 237D 80 DUP1 237E 60 PUSH1 0x20 2380 01 ADD 2381 82 DUP3 2382 81 DUP2 2383 03 SUB 2384 82 DUP3 2385 52 MSTORE 2386 60 PUSH1 0x23 2388 81 DUP2 2389 52 MSTORE 238A 60 PUSH1 0x20 238C 01 ADD 238D 80 DUP1 238E 61 PUSH2 0x2e3f 2391 60 PUSH1 0x23 2393 91 SWAP2 2394 39 CODECOPY 2395 60 PUSH1 0x40 2397 01 ADD 2398 91 SWAP2 2399 50 POP 239A 50 POP 239B 60 PUSH1 0x40 239D 51 MLOAD 239E 80 DUP1 239F 91 SWAP2 23A0 03 SUB 23A1 90 SWAP1 23A2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2378 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2385 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2389 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @2394 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x2e3f:0x2e62] // @23A2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_23A3: // Incoming jump from 0x2352, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @23A7 stack[-6] // @23A8 stack[-5] // @23A9 stack[-4] // } 23A3 5B JUMPDEST 23A4 61 PUSH2 0x23ae 23A7 86 DUP7 23A8 86 DUP7 23A9 86 DUP7 23AA 61 PUSH2 0x2e39 23AD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @23A4 stack[0] = 0x23ae // @23A7 stack[1] = stack[-6] // @23A8 stack[2] = stack[-5] // @23A9 stack[3] = stack[-4] // } // Block ends with call to 0x2e39, returns to 0x23AE label_23AE: // Incoming return from call to 0x2E39 at 0x23AD // Inputs[5] // { // @23B2 stack[-4] // @23B5 memory[0x40:0x60] // @23CF stack[-6] // @2409 memory[0x00:0x40] // @240A storage[keccak256(memory[0x00:0x40])] // } 23AE 5B JUMPDEST 23AF 61 PUSH2 0x2419 23B2 84 DUP5 23B3 60 PUSH1 0x40 23B5 51 MLOAD 23B6 80 DUP1 23B7 60 PUSH1 0x60 23B9 01 ADD 23BA 60 PUSH1 0x40 23BC 52 MSTORE 23BD 80 DUP1 23BE 60 PUSH1 0x26 23C0 81 DUP2 23C1 52 MSTORE 23C2 60 PUSH1 0x20 23C4 01 ADD 23C5 61 PUSH2 0x2e84 23C8 60 PUSH1 0x26 23CA 91 SWAP2 23CB 39 CODECOPY 23CC 60 PUSH1 0x00 23CE 80 DUP1 23CF 8A DUP11 23D0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23E5 16 AND 23E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23FB 16 AND 23FC 81 DUP2 23FD 52 MSTORE 23FE 60 PUSH1 0x20 2400 01 ADD 2401 90 SWAP1 2402 81 DUP2 2403 52 MSTORE 2404 60 PUSH1 0x20 2406 01 ADD 2407 60 PUSH1 0x00 2409 20 SHA3 240A 54 SLOAD 240B 61 PUSH2 0x2cf1 240E 90 SWAP1 240F 92 SWAP3 2410 91 SWAP2 2411 90 SWAP1 2412 63 PUSH4 0xffffffff 2417 16 AND 2418 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @23AF stack[0] = 0x2419 // @23BC memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @23C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 // @23CB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x2e84:0x2eaa] // @23FD memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2403 memory[0x20:0x40] = 0x00 // @240F stack[1] = storage[keccak256(memory[0x00:0x40])] // @2410 stack[2] = stack[-4] // @2411 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x2cf1, returns to 0x2419 label_2419: // Incoming return from call to 0x2CF1 at 0x2418 // Inputs[7] // { // @241D stack[-7] // @2457 memory[0x00:0x40] // @2458 stack[-1] // @245F stack[-5] // @2463 stack[-6] // @249D memory[0x00:0x40] // @249E storage[keccak256(memory[0x00:0x40])] // } 2419 5B JUMPDEST 241A 60 PUSH1 0x00 241C 80 DUP1 241D 88 DUP9 241E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2433 16 AND 2434 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2449 16 AND 244A 81 DUP2 244B 52 MSTORE 244C 60 PUSH1 0x20 244E 01 ADD 244F 90 SWAP1 2450 81 DUP2 2451 52 MSTORE 2452 60 PUSH1 0x20 2454 01 ADD 2455 60 PUSH1 0x00 2457 20 SHA3 2458 81 DUP2 2459 90 SWAP1 245A 55 SSTORE 245B 50 POP 245C 61 PUSH2 0x24ac 245F 84 DUP5 2460 60 PUSH1 0x00 2462 80 DUP1 2463 88 DUP9 2464 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2479 16 AND 247A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 248F 16 AND 2490 81 DUP2 2491 52 MSTORE 2492 60 PUSH1 0x20 2494 01 ADD 2495 90 SWAP1 2496 81 DUP2 2497 52 MSTORE 2498 60 PUSH1 0x20 249A 01 ADD 249B 60 PUSH1 0x00 249D 20 SHA3 249E 54 SLOAD 249F 61 PUSH2 0x2db1 24A2 90 SWAP1 24A3 91 SWAP2 24A4 90 SWAP1 24A5 63 PUSH4 0xffffffff 24AA 16 AND 24AB 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @244B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2451 memory[0x20:0x40] = 0x00 // @245A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @245C stack[-1] = 0x24ac // @2491 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2497 memory[0x20:0x40] = 0x00 // @24A3 stack[0] = storage[keccak256(memory[0x00:0x40])] // @24A4 stack[1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x2db1, returns to 0x24AC label_24AC: // Incoming return from call to 0x2DB1 at 0x24AB // Inputs[8] // { // @24B0 stack[-6] // @24EA memory[0x00:0x40] // @24EB stack[-1] // @2506 stack[-7] // @253E stack[-5] // @2541 memory[0x40:0x60] // @254E memory[0x40:0x60] // @2553 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 24AC 5B JUMPDEST 24AD 60 PUSH1 0x00 24AF 80 DUP1 24B0 87 DUP8 24B1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24C6 16 AND 24C7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24DC 16 AND 24DD 81 DUP2 24DE 52 MSTORE 24DF 60 PUSH1 0x20 24E1 01 ADD 24E2 90 SWAP1 24E3 81 DUP2 24E4 52 MSTORE 24E5 60 PUSH1 0x20 24E7 01 ADD 24E8 60 PUSH1 0x00 24EA 20 SHA3 24EB 81 DUP2 24EC 90 SWAP1 24ED 55 SSTORE 24EE 50 POP 24EF 84 DUP5 24F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2505 16 AND 2506 86 DUP7 2507 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 251C 16 AND 251D 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 253E 86 DUP7 253F 60 PUSH1 0x40 2541 51 MLOAD 2542 80 DUP1 2543 82 DUP3 2544 81 DUP2 2545 52 MSTORE 2546 60 PUSH1 0x20 2548 01 ADD 2549 91 SWAP2 254A 50 POP 254B 50 POP 254C 60 PUSH1 0x40 254E 51 MLOAD 254F 80 DUP1 2550 91 SWAP2 2551 03 SUB 2552 90 SWAP1 2553 A3 LOG3 2554 61 PUSH2 0x2ce6 2557 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @24DE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @24E4 memory[0x20:0x40] = 0x00 // @24ED storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2545 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @2553 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to 0x2ce6 label_2558: // Incoming jump from 0x2199, if !(!!(0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00) == !!0x01) // Inputs[2] // { // @255B storage[0x03] // @255C stack[-1] // } 2558 5B JUMPDEST 2559 60 PUSH1 0x03 255B 54 SLOAD 255C 81 DUP2 255D 10 LT 255E 15 ISZERO 255F 61 PUSH2 0x292a 2562 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x292a, if !(stack[-1] < storage[0x03]) label_2563: // Incoming jump from 0x2562, if not !(stack[-1] < storage[0x03]) // Inputs[2] // { // @2568 storage[0x0b] // @259C stack[-2] // } 2563 60 PUSH1 0x0b 2565 60 PUSH1 0x00 2567 90 SWAP1 2568 54 SLOAD 2569 90 SWAP1 256A 61 PUSH2 0x0100 256D 0A EXP 256E 90 SWAP1 256F 04 DIV 2570 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2585 16 AND 2586 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 259B 16 AND 259C 82 DUP3 259D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25B2 16 AND 25B3 14 EQ 25B4 15 ISZERO 25B5 61 PUSH2 0x2669 25B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2669, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00) label_25B9: // Incoming jump from 0x25B8, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00) // Inputs[6] // { // @25BF stack[-3] // @25F9 memory[0x00:0x40] // @2601 storage[keccak256(memory[0x00:0x40])] // @2651 memory[0x00:0x40] // @2659 storage[keccak256(memory[0x00:0x40])] // @2682 stack[-6] // } 25B9 60 PUSH1 0x01 25BB 60 PUSH1 0x02 25BD 60 PUSH1 0x00 25BF 85 DUP6 25C0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25D5 16 AND 25D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25EB 16 AND 25EC 81 DUP2 25ED 52 MSTORE 25EE 60 PUSH1 0x20 25F0 01 ADD 25F1 90 SWAP1 25F2 81 DUP2 25F3 52 MSTORE 25F4 60 PUSH1 0x20 25F6 01 ADD 25F7 60 PUSH1 0x00 25F9 20 SHA3 25FA 60 PUSH1 0x00 25FC 61 PUSH2 0x0100 25FF 0A EXP 2600 81 DUP2 2601 54 SLOAD 2602 81 DUP2 2603 60 PUSH1 0xff 2605 02 MUL 2606 19 NOT 2607 16 AND 2608 90 SWAP1 2609 83 DUP4 260A 15 ISZERO 260B 15 ISZERO 260C 02 MUL 260D 17 OR 260E 90 SWAP1 260F 55 SSTORE 2610 50 POP 2611 60 PUSH1 0x00 2613 60 PUSH1 0x01 2615 60 PUSH1 0x00 2617 85 DUP6 2618 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 262D 16 AND 262E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2643 16 AND 2644 81 DUP2 2645 52 MSTORE 2646 60 PUSH1 0x20 2648 01 ADD 2649 90 SWAP1 264A 81 DUP2 264B 52 MSTORE 264C 60 PUSH1 0x20 264E 01 ADD 264F 60 PUSH1 0x00 2651 20 SHA3 2652 60 PUSH1 0x00 2654 61 PUSH2 0x0100 2657 0A EXP 2658 81 DUP2 2659 54 SLOAD 265A 81 DUP2 265B 60 PUSH1 0xff 265D 02 MUL 265E 19 NOT 265F 16 AND 2660 90 SWAP1 2661 83 DUP4 2662 15 ISZERO 2663 15 ISZERO 2664 02 MUL 2665 17 OR 2666 90 SWAP1 2667 55 SSTORE 2668 50 POP 2669 5B JUMPDEST 266A 60 PUSH1 0x00 266C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2681 16 AND 2682 86 DUP7 2683 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2698 16 AND 2699 14 EQ 269A 15 ISZERO 269B 61 PUSH2 0x26ef 269E 57 *JUMPI // Stack delta = +0 // Outputs[6] // { // @25ED memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @25F3 memory[0x20:0x40] = 0x02 // @260F storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @2645 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @264B memory[0x20:0x40] = 0x01 // @2667 storage[keccak256(memory[0x00:0x40])] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with conditional jump to 0x26ef, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_269F: // Incoming jump from 0x269E, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Incoming jump from 0x269E, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @26A1 memory[0x40:0x60] // @26E9 memory[0x40:0x60] // @26EE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 269F 60 PUSH1 0x40 26A1 51 MLOAD 26A2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 26C3 81 DUP2 26C4 52 MSTORE 26C5 60 PUSH1 0x04 26C7 01 ADD 26C8 80 DUP1 26C9 80 DUP1 26CA 60 PUSH1 0x20 26CC 01 ADD 26CD 82 DUP3 26CE 81 DUP2 26CF 03 SUB 26D0 82 DUP3 26D1 52 MSTORE 26D2 60 PUSH1 0x25 26D4 81 DUP2 26D5 52 MSTORE 26D6 60 PUSH1 0x20 26D8 01 ADD 26D9 80 DUP1 26DA 61 PUSH2 0x2ed2 26DD 60 PUSH1 0x25 26DF 91 SWAP2 26E0 39 CODECOPY 26E1 60 PUSH1 0x40 26E3 01 ADD 26E4 91 SWAP2 26E5 50 POP 26E6 50 POP 26E7 60 PUSH1 0x40 26E9 51 MLOAD 26EA 80 DUP1 26EB 91 SWAP2 26EC 03 SUB 26ED 90 SWAP1 26EE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @26C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @26D1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @26D5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @26E0 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2ed2:0x2ef7] // @26EE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_26EF: // Incoming jump from 0x269E, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Incoming jump from 0x269E, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2708 stack[-5] } 26EF 5B JUMPDEST 26F0 60 PUSH1 0x00 26F2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2707 16 AND 2708 85 DUP6 2709 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 271E 16 AND 271F 14 EQ 2720 15 ISZERO 2721 61 PUSH2 0x2775 2724 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2775, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2725: // Incoming jump from 0x2724, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2727 memory[0x40:0x60] // @276F memory[0x40:0x60] // @2774 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2725 60 PUSH1 0x40 2727 51 MLOAD 2728 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2749 81 DUP2 274A 52 MSTORE 274B 60 PUSH1 0x04 274D 01 ADD 274E 80 DUP1 274F 80 DUP1 2750 60 PUSH1 0x20 2752 01 ADD 2753 82 DUP3 2754 81 DUP2 2755 03 SUB 2756 82 DUP3 2757 52 MSTORE 2758 60 PUSH1 0x23 275A 81 DUP2 275B 52 MSTORE 275C 60 PUSH1 0x20 275E 01 ADD 275F 80 DUP1 2760 61 PUSH2 0x2e3f 2763 60 PUSH1 0x23 2765 91 SWAP2 2766 39 CODECOPY 2767 60 PUSH1 0x40 2769 01 ADD 276A 91 SWAP2 276B 50 POP 276C 50 POP 276D 60 PUSH1 0x40 276F 51 MLOAD 2770 80 DUP1 2771 91 SWAP2 2772 03 SUB 2773 90 SWAP1 2774 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @274A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2757 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @275B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @2766 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x2e3f:0x2e62] // @2774 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2775: // Incoming jump from 0x2724, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2779 stack[-6] // @277A stack[-5] // @277B stack[-4] // } 2775 5B JUMPDEST 2776 61 PUSH2 0x2780 2779 86 DUP7 277A 86 DUP7 277B 86 DUP7 277C 61 PUSH2 0x2e39 277F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2776 stack[0] = 0x2780 // @2779 stack[1] = stack[-6] // @277A stack[2] = stack[-5] // @277B stack[3] = stack[-4] // } // Block ends with call to 0x2e39, returns to 0x2780 label_2780: // Incoming return from call to 0x2E39 at 0x277F // Inputs[5] // { // @2784 stack[-4] // @2787 memory[0x40:0x60] // @27A1 stack[-6] // @27DB memory[0x00:0x40] // @27DC storage[keccak256(memory[0x00:0x40])] // } 2780 5B JUMPDEST 2781 61 PUSH2 0x27eb 2784 84 DUP5 2785 60 PUSH1 0x40 2787 51 MLOAD 2788 80 DUP1 2789 60 PUSH1 0x60 278B 01 ADD 278C 60 PUSH1 0x40 278E 52 MSTORE 278F 80 DUP1 2790 60 PUSH1 0x26 2792 81 DUP2 2793 52 MSTORE 2794 60 PUSH1 0x20 2796 01 ADD 2797 61 PUSH2 0x2e84 279A 60 PUSH1 0x26 279C 91 SWAP2 279D 39 CODECOPY 279E 60 PUSH1 0x00 27A0 80 DUP1 27A1 8A DUP11 27A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27B7 16 AND 27B8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27CD 16 AND 27CE 81 DUP2 27CF 52 MSTORE 27D0 60 PUSH1 0x20 27D2 01 ADD 27D3 90 SWAP1 27D4 81 DUP2 27D5 52 MSTORE 27D6 60 PUSH1 0x20 27D8 01 ADD 27D9 60 PUSH1 0x00 27DB 20 SHA3 27DC 54 SLOAD 27DD 61 PUSH2 0x2cf1 27E0 90 SWAP1 27E1 92 SWAP3 27E2 91 SWAP2 27E3 90 SWAP1 27E4 63 PUSH4 0xffffffff 27E9 16 AND 27EA 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @2781 stack[0] = 0x27eb // @278E memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @2793 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 // @279D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x2e84:0x2eaa] // @27CF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @27D5 memory[0x20:0x40] = 0x00 // @27E1 stack[1] = storage[keccak256(memory[0x00:0x40])] // @27E2 stack[2] = stack[-4] // @27E3 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x2cf1, returns to 0x27EB label_27EB: // Incoming return from call to 0x2CF1 at 0x27EA // Inputs[7] // { // @27EF stack[-7] // @2829 memory[0x00:0x40] // @282A stack[-1] // @2831 stack[-5] // @2835 stack[-6] // @286F memory[0x00:0x40] // @2870 storage[keccak256(memory[0x00:0x40])] // } 27EB 5B JUMPDEST 27EC 60 PUSH1 0x00 27EE 80 DUP1 27EF 88 DUP9 27F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2805 16 AND 2806 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 281B 16 AND 281C 81 DUP2 281D 52 MSTORE 281E 60 PUSH1 0x20 2820 01 ADD 2821 90 SWAP1 2822 81 DUP2 2823 52 MSTORE 2824 60 PUSH1 0x20 2826 01 ADD 2827 60 PUSH1 0x00 2829 20 SHA3 282A 81 DUP2 282B 90 SWAP1 282C 55 SSTORE 282D 50 POP 282E 61 PUSH2 0x287e 2831 84 DUP5 2832 60 PUSH1 0x00 2834 80 DUP1 2835 88 DUP9 2836 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 284B 16 AND 284C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2861 16 AND 2862 81 DUP2 2863 52 MSTORE 2864 60 PUSH1 0x20 2866 01 ADD 2867 90 SWAP1 2868 81 DUP2 2869 52 MSTORE 286A 60 PUSH1 0x20 286C 01 ADD 286D 60 PUSH1 0x00 286F 20 SHA3 2870 54 SLOAD 2871 61 PUSH2 0x2db1 2874 90 SWAP1 2875 91 SWAP2 2876 90 SWAP1 2877 63 PUSH4 0xffffffff 287C 16 AND 287D 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @281D memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2823 memory[0x20:0x40] = 0x00 // @282C storage[keccak256(memory[0x00:0x40])] = stack[-1] // @282E stack[-1] = 0x287e // @2863 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2869 memory[0x20:0x40] = 0x00 // @2875 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2876 stack[1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x2db1, returns to 0x287E label_287E: // Incoming return from call to 0x2DB1 at 0x287D // Inputs[8] // { // @2882 stack[-6] // @28BC memory[0x00:0x40] // @28BD stack[-1] // @28D8 stack[-7] // @2910 stack[-5] // @2913 memory[0x40:0x60] // @2920 memory[0x40:0x60] // @2925 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 287E 5B JUMPDEST 287F 60 PUSH1 0x00 2881 80 DUP1 2882 87 DUP8 2883 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2898 16 AND 2899 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28AE 16 AND 28AF 81 DUP2 28B0 52 MSTORE 28B1 60 PUSH1 0x20 28B3 01 ADD 28B4 90 SWAP1 28B5 81 DUP2 28B6 52 MSTORE 28B7 60 PUSH1 0x20 28B9 01 ADD 28BA 60 PUSH1 0x00 28BC 20 SHA3 28BD 81 DUP2 28BE 90 SWAP1 28BF 55 SSTORE 28C0 50 POP 28C1 84 DUP5 28C2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28D7 16 AND 28D8 86 DUP7 28D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28EE 16 AND 28EF 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2910 86 DUP7 2911 60 PUSH1 0x40 2913 51 MLOAD 2914 80 DUP1 2915 82 DUP3 2916 81 DUP2 2917 52 MSTORE 2918 60 PUSH1 0x20 291A 01 ADD 291B 91 SWAP2 291C 50 POP 291D 50 POP 291E 60 PUSH1 0x40 2920 51 MLOAD 2921 80 DUP1 2922 91 SWAP2 2923 03 SUB 2924 90 SWAP1 2925 A3 LOG3 2926 61 PUSH2 0x2ce5 2929 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @28B0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @28B6 memory[0x20:0x40] = 0x00 // @28BF storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2917 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @2925 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to 0x2ce5 label_292A: // Incoming jump from 0x2562, if !(stack[-1] < storage[0x03]) // Inputs[2] // { // @2930 storage[0x0b] // @2964 stack[-3] // } 292A 5B JUMPDEST 292B 60 PUSH1 0x0b 292D 60 PUSH1 0x00 292F 90 SWAP1 2930 54 SLOAD 2931 90 SWAP1 2932 61 PUSH2 0x0100 2935 0A EXP 2936 90 SWAP1 2937 04 DIV 2938 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 294D 16 AND 294E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2963 16 AND 2964 83 DUP4 2965 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 297A 16 AND 297B 14 EQ 297C 80 DUP1 297D 61 PUSH2 0x29d3 2980 57 *JUMPI // Stack delta = +1 // Outputs[1] { @297B stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 } // Block ends with conditional jump to 0x29d3, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 label_2981: // Incoming jump from 0x2980, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0b] / 0x0100 ** 0x00 // Inputs[2] // { // @2987 storage[0x0c] // @29BB stack[-3] // } 2981 50 POP 2982 60 PUSH1 0x0c 2984 60 PUSH1 0x00 2986 90 SWAP1 2987 54 SLOAD 2988 90 SWAP1 2989 61 PUSH2 0x0100 298C 0A EXP 298D 90 SWAP1 298E 04 DIV 298F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29A4 16 AND 29A5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29BA 16 AND 29BB 82 DUP3 29BC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29D1 16 AND 29D2 14 EQ 29D3 5B JUMPDEST 29D4 61 PUSH2 0x2a28 29D7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2a28, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0c] / 0x0100 ** 0x00 label_29D8: // Incoming jump from 0x29D7, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0c] / 0x0100 ** 0x00 // Incoming jump from 0x29D7, if not stack[-1] // Inputs[3] // { // @29DA memory[0x40:0x60] // @2A22 memory[0x40:0x60] // @2A27 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 29D8 60 PUSH1 0x40 29DA 51 MLOAD 29DB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 29FC 81 DUP2 29FD 52 MSTORE 29FE 60 PUSH1 0x04 2A00 01 ADD 2A01 80 DUP1 2A02 80 DUP1 2A03 60 PUSH1 0x20 2A05 01 ADD 2A06 82 DUP3 2A07 81 DUP2 2A08 03 SUB 2A09 82 DUP3 2A0A 52 MSTORE 2A0B 60 PUSH1 0x26 2A0D 81 DUP2 2A0E 52 MSTORE 2A0F 60 PUSH1 0x20 2A11 01 ADD 2A12 80 DUP1 2A13 61 PUSH2 0x2e84 2A16 60 PUSH1 0x26 2A18 91 SWAP2 2A19 39 CODECOPY 2A1A 60 PUSH1 0x40 2A1C 01 ADD 2A1D 91 SWAP2 2A1E 50 POP 2A1F 50 POP 2A20 60 PUSH1 0x40 2A22 51 MLOAD 2A23 80 DUP1 2A24 91 SWAP2 2A25 03 SUB 2A26 90 SWAP1 2A27 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @29FD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2A0A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2A0E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @2A19 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x2e84:0x2eaa] // @2A27 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2A28: // Incoming jump from 0x29D7, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0c] / 0x0100 ** 0x00 // Incoming jump from 0x29D7, if stack[-1] // Inputs[1] { @2A41 stack[-6] } 2A28 5B JUMPDEST 2A29 60 PUSH1 0x00 2A2B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A40 16 AND 2A41 86 DUP7 2A42 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A57 16 AND 2A58 14 EQ 2A59 15 ISZERO 2A5A 61 PUSH2 0x2aae 2A5D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2aae, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2A5E: // Incoming jump from 0x2A5D, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2A60 memory[0x40:0x60] // @2AA8 memory[0x40:0x60] // @2AAD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2A5E 60 PUSH1 0x40 2A60 51 MLOAD 2A61 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2A82 81 DUP2 2A83 52 MSTORE 2A84 60 PUSH1 0x04 2A86 01 ADD 2A87 80 DUP1 2A88 80 DUP1 2A89 60 PUSH1 0x20 2A8B 01 ADD 2A8C 82 DUP3 2A8D 81 DUP2 2A8E 03 SUB 2A8F 82 DUP3 2A90 52 MSTORE 2A91 60 PUSH1 0x25 2A93 81 DUP2 2A94 52 MSTORE 2A95 60 PUSH1 0x20 2A97 01 ADD 2A98 80 DUP1 2A99 61 PUSH2 0x2ed2 2A9C 60 PUSH1 0x25 2A9E 91 SWAP2 2A9F 39 CODECOPY 2AA0 60 PUSH1 0x40 2AA2 01 ADD 2AA3 91 SWAP2 2AA4 50 POP 2AA5 50 POP 2AA6 60 PUSH1 0x40 2AA8 51 MLOAD 2AA9 80 DUP1 2AAA 91 SWAP2 2AAB 03 SUB 2AAC 90 SWAP1 2AAD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2A83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2A90 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2A94 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @2A9F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2ed2:0x2ef7] // @2AAD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2AAE: // Incoming jump from 0x2A5D, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-6] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2AC7 stack[-5] } 2AAE 5B JUMPDEST 2AAF 60 PUSH1 0x00 2AB1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2AC6 16 AND 2AC7 85 DUP6 2AC8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2ADD 16 AND 2ADE 14 EQ 2ADF 15 ISZERO 2AE0 61 PUSH2 0x2b34 2AE3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2b34, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2AE4: // Incoming jump from 0x2AE3, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2AE6 memory[0x40:0x60] // @2B2E memory[0x40:0x60] // @2B33 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2AE4 60 PUSH1 0x40 2AE6 51 MLOAD 2AE7 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2B08 81 DUP2 2B09 52 MSTORE 2B0A 60 PUSH1 0x04 2B0C 01 ADD 2B0D 80 DUP1 2B0E 80 DUP1 2B0F 60 PUSH1 0x20 2B11 01 ADD 2B12 82 DUP3 2B13 81 DUP2 2B14 03 SUB 2B15 82 DUP3 2B16 52 MSTORE 2B17 60 PUSH1 0x23 2B19 81 DUP2 2B1A 52 MSTORE 2B1B 60 PUSH1 0x20 2B1D 01 ADD 2B1E 80 DUP1 2B1F 61 PUSH2 0x2e3f 2B22 60 PUSH1 0x23 2B24 91 SWAP2 2B25 39 CODECOPY 2B26 60 PUSH1 0x40 2B28 01 ADD 2B29 91 SWAP2 2B2A 50 POP 2B2B 50 POP 2B2C 60 PUSH1 0x40 2B2E 51 MLOAD 2B2F 80 DUP1 2B30 91 SWAP2 2B31 03 SUB 2B32 90 SWAP1 2B33 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2B09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2B16 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2B1A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @2B25 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x2e3f:0x2e62] // @2B33 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2B34: // Incoming jump from 0x2AE3, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2B38 stack[-6] // @2B39 stack[-5] // @2B3A stack[-4] // } 2B34 5B JUMPDEST 2B35 61 PUSH2 0x2b3f 2B38 86 DUP7 2B39 86 DUP7 2B3A 86 DUP7 2B3B 61 PUSH2 0x2e39 2B3E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2B35 stack[0] = 0x2b3f // @2B38 stack[1] = stack[-6] // @2B39 stack[2] = stack[-5] // @2B3A stack[3] = stack[-4] // } // Block ends with call to 0x2e39, returns to 0x2B3F label_2B3F: // Incoming return from call to 0x2E39 at 0x2B3E // Inputs[5] // { // @2B43 stack[-4] // @2B46 memory[0x40:0x60] // @2B60 stack[-6] // @2B9A memory[0x00:0x40] // @2B9B storage[keccak256(memory[0x00:0x40])] // } 2B3F 5B JUMPDEST 2B40 61 PUSH2 0x2baa 2B43 84 DUP5 2B44 60 PUSH1 0x40 2B46 51 MLOAD 2B47 80 DUP1 2B48 60 PUSH1 0x60 2B4A 01 ADD 2B4B 60 PUSH1 0x40 2B4D 52 MSTORE 2B4E 80 DUP1 2B4F 60 PUSH1 0x26 2B51 81 DUP2 2B52 52 MSTORE 2B53 60 PUSH1 0x20 2B55 01 ADD 2B56 61 PUSH2 0x2e84 2B59 60 PUSH1 0x26 2B5B 91 SWAP2 2B5C 39 CODECOPY 2B5D 60 PUSH1 0x00 2B5F 80 DUP1 2B60 8A DUP11 2B61 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B76 16 AND 2B77 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B8C 16 AND 2B8D 81 DUP2 2B8E 52 MSTORE 2B8F 60 PUSH1 0x20 2B91 01 ADD 2B92 90 SWAP1 2B93 81 DUP2 2B94 52 MSTORE 2B95 60 PUSH1 0x20 2B97 01 ADD 2B98 60 PUSH1 0x00 2B9A 20 SHA3 2B9B 54 SLOAD 2B9C 61 PUSH2 0x2cf1 2B9F 90 SWAP1 2BA0 92 SWAP3 2BA1 91 SWAP2 2BA2 90 SWAP1 2BA3 63 PUSH4 0xffffffff 2BA8 16 AND 2BA9 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @2B40 stack[0] = 0x2baa // @2B4D memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @2B52 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 // @2B5C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x2e84:0x2eaa] // @2B8E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2B94 memory[0x20:0x40] = 0x00 // @2BA0 stack[1] = storage[keccak256(memory[0x00:0x40])] // @2BA1 stack[2] = stack[-4] // @2BA2 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x2cf1, returns to 0x2BAA label_2BAA: // Incoming return from call to 0x2CF1 at 0x2BA9 // Inputs[7] // { // @2BAE stack[-7] // @2BE8 memory[0x00:0x40] // @2BE9 stack[-1] // @2BF0 stack[-5] // @2BF4 stack[-6] // @2C2E memory[0x00:0x40] // @2C2F storage[keccak256(memory[0x00:0x40])] // } 2BAA 5B JUMPDEST 2BAB 60 PUSH1 0x00 2BAD 80 DUP1 2BAE 88 DUP9 2BAF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BC4 16 AND 2BC5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BDA 16 AND 2BDB 81 DUP2 2BDC 52 MSTORE 2BDD 60 PUSH1 0x20 2BDF 01 ADD 2BE0 90 SWAP1 2BE1 81 DUP2 2BE2 52 MSTORE 2BE3 60 PUSH1 0x20 2BE5 01 ADD 2BE6 60 PUSH1 0x00 2BE8 20 SHA3 2BE9 81 DUP2 2BEA 90 SWAP1 2BEB 55 SSTORE 2BEC 50 POP 2BED 61 PUSH2 0x2c3d 2BF0 84 DUP5 2BF1 60 PUSH1 0x00 2BF3 80 DUP1 2BF4 88 DUP9 2BF5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C0A 16 AND 2C0B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C20 16 AND 2C21 81 DUP2 2C22 52 MSTORE 2C23 60 PUSH1 0x20 2C25 01 ADD 2C26 90 SWAP1 2C27 81 DUP2 2C28 52 MSTORE 2C29 60 PUSH1 0x20 2C2B 01 ADD 2C2C 60 PUSH1 0x00 2C2E 20 SHA3 2C2F 54 SLOAD 2C30 61 PUSH2 0x2db1 2C33 90 SWAP1 2C34 91 SWAP2 2C35 90 SWAP1 2C36 63 PUSH4 0xffffffff 2C3B 16 AND 2C3C 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @2BDC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @2BE2 memory[0x20:0x40] = 0x00 // @2BEB storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2BED stack[-1] = 0x2c3d // @2C22 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2C28 memory[0x20:0x40] = 0x00 // @2C34 stack[0] = storage[keccak256(memory[0x00:0x40])] // @2C35 stack[1] = stack[-5] // } // Block ends with call to 0xffffffff & 0x2db1, returns to 0x2C3D label_2C3D: // Incoming return from call to 0x2DB1 at 0x2C3C // Inputs[9] // { // @2C41 stack[-6] // @2C7B memory[0x00:0x40] // @2C7C stack[-1] // @2C97 stack[-7] // @2CCF stack[-5] // @2CD2 memory[0x40:0x60] // @2CDF memory[0x40:0x60] // @2CE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2CF0 stack[-8] // } 2C3D 5B JUMPDEST 2C3E 60 PUSH1 0x00 2C40 80 DUP1 2C41 87 DUP8 2C42 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C57 16 AND 2C58 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C6D 16 AND 2C6E 81 DUP2 2C6F 52 MSTORE 2C70 60 PUSH1 0x20 2C72 01 ADD 2C73 90 SWAP1 2C74 81 DUP2 2C75 52 MSTORE 2C76 60 PUSH1 0x20 2C78 01 ADD 2C79 60 PUSH1 0x00 2C7B 20 SHA3 2C7C 81 DUP2 2C7D 90 SWAP1 2C7E 55 SSTORE 2C7F 50 POP 2C80 84 DUP5 2C81 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C96 16 AND 2C97 86 DUP7 2C98 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CAD 16 AND 2CAE 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2CCF 86 DUP7 2CD0 60 PUSH1 0x40 2CD2 51 MLOAD 2CD3 80 DUP1 2CD4 82 DUP3 2CD5 81 DUP2 2CD6 52 MSTORE 2CD7 60 PUSH1 0x20 2CD9 01 ADD 2CDA 91 SWAP2 2CDB 50 POP 2CDC 50 POP 2CDD 60 PUSH1 0x40 2CDF 51 MLOAD 2CE0 80 DUP1 2CE1 91 SWAP2 2CE2 03 SUB 2CE3 90 SWAP1 2CE4 A3 LOG3 2CE5 5B JUMPDEST 2CE6 5B JUMPDEST 2CE7 5B JUMPDEST 2CE8 5B JUMPDEST 2CE9 5B JUMPDEST 2CEA 50 POP 2CEB 50 POP 2CEC 50 POP 2CED 50 POP 2CEE 50 POP 2CEF 50 POP 2CF0 56 *JUMP // Stack delta = -8 // Outputs[5] // { // @2C6F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @2C75 memory[0x20:0x40] = 0x00 // @2C7E storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2CD6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-5] // @2CE4 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-8] label_2CF1: // Incoming call from 0x1CE6, returns to 0x1CE7 // Incoming call from 0x27EA, returns to 0x27EB // Incoming jump from 0x0B51 // Incoming call from 0x2418, returns to 0x2419 // Incoming call from 0x2000, returns to 0x2001 // Incoming call from 0x188A, returns to 0x188B // Incoming call from 0x2BA9, returns to 0x2BAA // Inputs[3] // { // @2CF4 stack[-3] // @2CF5 stack[-2] // @2CF8 stack[-1] // } 2CF1 5B JUMPDEST 2CF2 60 PUSH1 0x00 2CF4 83 DUP4 2CF5 83 DUP4 2CF6 11 GT 2CF7 15 ISZERO 2CF8 82 DUP3 2CF9 90 SWAP1 2CFA 61 PUSH2 0x2d9e 2CFD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2CF2 stack[0] = 0x00 // @2CF9 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2d9e, if !(stack[-2] > stack[-3]) label_2CFE: // Incoming jump from 0x2CFD, if not !(stack[-2] > stack[-3]) // Inputs[4] // { // @2D00 memory[0x40:0x60] // @2D31 stack[-1] // @2D34 memory[stack[-1]:stack[-1] + 0x20] // @2D3D memory[stack[-1]:stack[-1] + 0x20] // } 2CFE 60 PUSH1 0x40 2D00 51 MLOAD 2D01 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2D22 81 DUP2 2D23 52 MSTORE 2D24 60 PUSH1 0x04 2D26 01 ADD 2D27 80 DUP1 2D28 80 DUP1 2D29 60 PUSH1 0x20 2D2B 01 ADD 2D2C 82 DUP3 2D2D 81 DUP2 2D2E 03 SUB 2D2F 82 DUP3 2D30 52 MSTORE 2D31 83 DUP4 2D32 81 DUP2 2D33 81 DUP2 2D34 51 MLOAD 2D35 81 DUP2 2D36 52 MSTORE 2D37 60 PUSH1 0x20 2D39 01 ADD 2D3A 91 SWAP2 2D3B 50 POP 2D3C 80 DUP1 2D3D 51 MLOAD 2D3E 90 SWAP1 2D3F 60 PUSH1 0x20 2D41 01 ADD 2D42 90 SWAP1 2D43 80 DUP1 2D44 83 DUP4 2D45 83 DUP4 2D46 60 PUSH1 0x00 2D48 5B JUMPDEST 2D49 83 DUP4 2D4A 81 DUP2 2D4B 10 LT 2D4C 15 ISZERO 2D4D 61 PUSH2 0x2d63 2D50 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @2D23 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2D26 stack[0] = 0x04 + memory[0x40:0x60] // @2D27 stack[1] = 0x04 + memory[0x40:0x60] // @2D30 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2D36 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2D3A stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2D42 stack[3] = 0x20 + stack[-1] // @2D42 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @2D43 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @2D44 stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2D45 stack[7] = 0x20 + stack[-1] // @2D46 stack[8] = 0x00 // } // Block ends with conditional jump to 0x2d63, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_2D51: // Incoming jump from 0x2D50, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2D50, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @2D51 stack[-1] // @2D52 stack[-2] // @2D54 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2D56 stack[-3] // } 2D51 80 DUP1 2D52 82 DUP3 2D53 01 ADD 2D54 51 MLOAD 2D55 81 DUP2 2D56 84 DUP5 2D57 01 ADD 2D58 52 MSTORE 2D59 60 PUSH1 0x20 2D5B 81 DUP2 2D5C 01 ADD 2D5D 90 SWAP1 2D5E 50 POP 2D5F 61 PUSH2 0x2d48 2D62 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2D58 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2D5D stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x2d48 label_2D63: // Incoming jump from 0x2D50, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2D50, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @2D68 stack[-6] // @2D68 stack[-5] // @2D6A stack[-7] // } 2D63 5B JUMPDEST 2D64 50 POP 2D65 50 POP 2D66 50 POP 2D67 50 POP 2D68 90 SWAP1 2D69 50 POP 2D6A 90 SWAP1 2D6B 81 DUP2 2D6C 01 ADD 2D6D 90 SWAP1 2D6E 60 PUSH1 0x1f 2D70 16 AND 2D71 80 DUP1 2D72 15 ISZERO 2D73 61 PUSH2 0x2d90 2D76 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2D6D stack[-7] = stack[-5] + stack[-7] // @2D70 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2d90, if !(0x1f & stack[-5]) label_2D77: // Incoming jump from 0x2D76, if not !(0x1f & stack[-5]) // Inputs[6] // { // @2D77 stack[-1] // @2D78 stack[-2] // @2D7B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2D92 stack[-5] // @2D98 memory[0x40:0x60] // @2D9D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 2D77 80 DUP1 2D78 82 DUP3 2D79 03 SUB 2D7A 80 DUP1 2D7B 51 MLOAD 2D7C 60 PUSH1 0x01 2D7E 83 DUP4 2D7F 60 PUSH1 0x20 2D81 03 SUB 2D82 61 PUSH2 0x0100 2D85 0A EXP 2D86 03 SUB 2D87 19 NOT 2D88 16 AND 2D89 81 DUP2 2D8A 52 MSTORE 2D8B 60 PUSH1 0x20 2D8D 01 ADD 2D8E 91 SWAP2 2D8F 50 POP 2D90 5B JUMPDEST 2D91 50 POP 2D92 92 SWAP3 2D93 50 POP 2D94 50 POP 2D95 50 POP 2D96 60 PUSH1 0x40 2D98 51 MLOAD 2D99 80 DUP1 2D9A 91 SWAP2 2D9B 03 SUB 2D9C 90 SWAP1 2D9D FD *REVERT // Stack delta = -5 // Outputs[2] // { // @2D8A 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] // @2D9D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_2D9E: // Incoming jump from 0x2CFD, if !(stack[-2] > stack[-3]) // Inputs[4] // { // @2DA2 stack[-4] // @2DA3 stack[-5] // @2DA8 stack[-2] // @2DAB stack[-6] // } 2D9E 5B JUMPDEST 2D9F 50 POP 2DA0 60 PUSH1 0x00 2DA2 83 DUP4 2DA3 85 DUP6 2DA4 03 SUB 2DA5 90 SWAP1 2DA6 50 POP 2DA7 80 DUP1 2DA8 91 SWAP2 2DA9 50 POP 2DAA 50 POP 2DAB 93 SWAP4 2DAC 92 SWAP3 2DAD 50 POP 2DAE 50 POP 2DAF 50 POP 2DB0 56 *JUMP // Stack delta = -5 // Outputs[1] { @2DAB stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_2DB1: // Incoming call from 0x0CC9, returns to 0x0CCA // Incoming call from 0x2C3C, returns to 0x2C3D // Incoming call from 0x287D, returns to 0x287E // Incoming call from 0x0C50, returns to 0x0C51 // Incoming call from 0x24AB, returns to 0x24AC // Incoming call from 0x191D, returns to 0x191E // Incoming call from 0x1D79, returns to 0x1D7A // Incoming call from 0x2093, returns to 0x2094 // Inputs[2] // { // @2DB5 stack[-1] // @2DB6 stack[-2] // } 2DB1 5B JUMPDEST 2DB2 60 PUSH1 0x00 2DB4 80 DUP1 2DB5 82 DUP3 2DB6 84 DUP5 2DB7 01 ADD 2DB8 90 SWAP1 2DB9 50 POP 2DBA 83 DUP4 2DBB 81 DUP2 2DBC 10 LT 2DBD 15 ISZERO 2DBE 61 PUSH2 0x2e2f 2DC1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2DB2 stack[0] = 0x00 // @2DB8 stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x2e2f, if !(stack[-2] + stack[-1] < stack[-2]) label_2DC2: // Incoming jump from 0x2DC1, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @2DC4 memory[0x40:0x60] // @2E29 memory[0x40:0x60] // @2E2E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2DC2 60 PUSH1 0x40 2DC4 51 MLOAD 2DC5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2DE6 81 DUP2 2DE7 52 MSTORE 2DE8 60 PUSH1 0x04 2DEA 01 ADD 2DEB 80 DUP1 2DEC 80 DUP1 2DED 60 PUSH1 0x20 2DEF 01 ADD 2DF0 82 DUP3 2DF1 81 DUP2 2DF2 03 SUB 2DF3 82 DUP3 2DF4 52 MSTORE 2DF5 60 PUSH1 0x1b 2DF7 81 DUP2 2DF8 52 MSTORE 2DF9 60 PUSH1 0x20 2DFB 01 ADD 2DFC 80 DUP1 2DFD 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 2E1E 81 DUP2 2E1F 52 MSTORE 2E20 50 POP 2E21 60 PUSH1 0x20 2E23 01 ADD 2E24 91 SWAP2 2E25 50 POP 2E26 50 POP 2E27 60 PUSH1 0x40 2E29 51 MLOAD 2E2A 80 DUP1 2E2B 91 SWAP2 2E2C 03 SUB 2E2D 90 SWAP1 2E2E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2DE7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2DF4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2DF8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1b // @2E1F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @2E2E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2E2F: // Incoming jump from 0x2DC1, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @2E30 stack[-1] // @2E31 stack[-2] // @2E34 stack[-5] // @2E35 stack[-4] // } 2E2F 5B JUMPDEST 2E30 80 DUP1 2E31 91 SWAP2 2E32 50 POP 2E33 50 POP 2E34 92 SWAP3 2E35 91 SWAP2 2E36 50 POP 2E37 50 POP 2E38 56 *JUMP // Stack delta = -4 // Outputs[1] { @2E34 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2E39: // Incoming call from 0x181F, returns to 0x1820 // Incoming call from 0x1C7B, returns to 0x1C7C // Incoming call from 0x1F95, returns to 0x1F96 // Incoming call from 0x277F, returns to 0x2780 // Incoming call from 0x2B3E, returns to 0x2B3F // Incoming call from 0x23AD, returns to 0x23AE // Inputs[1] { @2E3D stack[-4] } 2E39 5B JUMPDEST 2E3A 50 POP 2E3B 50 POP 2E3C 50 POP 2E3D 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] 2E3E FE *ASSERT 2E3F 45 GASLIMIT 2E40 52 MSTORE 2E41 43 NUMBER 2E42 32 ORIGIN 2E43 30 ADDRESS 2E44 3A GASPRICE 2E45 20 SHA3 2E46 74 PUSH21 0x72616e7366657220746f20746865207a65726f2061 2E5C 64 PUSH5 0x6472657373 2E62 45 GASLIMIT 2E63 52 MSTORE 2E64 43 NUMBER 2E65 32 ORIGIN 2E66 30 ADDRESS 2E67 3A GASPRICE 2E68 20 SHA3 2E69 61 PUSH2 0x7070 2E6C 72 PUSH19 0x6f766520746f20746865207a65726f20616464 2E80 72 PUSH19 0x65737345524332303a207472616e7366657220 2E94 61 PUSH2 0x6d6f 2E97 75 PUSH22 0x6e7420657863656564732062616c616e636545524332 2EAE 30 ADDRESS 2EAF 3A GASPRICE 2EB0 20 SHA3 2EB1 74 PUSH21 0x72616e7366657220616d6f756e7420657863656564 2EC7 73 PUSH20 0x20616c6c6f77616e636545524332303a20747261 2EDC 6E PUSH15 0x736665722066726f6d20746865207a 2EEC 65 PUSH6 0x726f20616464 2EF3 72 PUSH19 0x65737345524332303a20617070726f76652066 2F07 72 PUSH19 0x6f6d20746865207a65726f2061646472657373 2F1B A2 LOG2 2F1C 64 PUSH5 0x6970667358 2F22 22 22 2F23 12 SLT 2F24 20 SHA3 2F25 B2 SWAP 2F26 CF CF 2F27 07 SMOD 2F28 9D SWAP14 2F29 33 CALLER 2F2A 6E PUSH15 0xdcda3a28242633a1c0c8810adf742d 2F3A FD *REVERT 2F3B 60 PUSH1 0x02 2F3D 5C 5C 2F3E 95 SWAP6 2F3F 1F 1F 2F40 1A BYTE 2F41 01 ADD 2F42 40 BLOCKHASH 2F43 18 XOR 2F44 A5 A5 2F45 64 PUSH5 0x736f6c6343 2F4B 00 *STOP 2F4C 06 MOD 2F4D 06 MOD 2F4E 00 *STOP 2F4F 33 CALLER