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 0x0158 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0158, 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 0x70a08231 0026 11 GT 0027 61 PUSH2 0x00c3 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00c3, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xd95b6371 0031 11 GT 0032 61 PUSH2 0x007c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xd95b6371 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xd95b6371 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xd95b6371 003C 14 EQ 003D 61 PUSH2 0x08aa 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08aa, if 0xd95b6371 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xd95b6371 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xdd62ed3e 0047 14 EQ 0048 61 PUSH2 0x08d8 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08d8, if 0xdd62ed3e == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xfad8b32a 0052 14 EQ 0053 61 PUSH2 0x0906 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0906, if 0xfad8b32a == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xfad8b32a == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xfc673c4f 005D 14 EQ 005E 61 PUSH2 0x092c 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x092c, if 0xfc673c4f == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xfc673c4f == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xfe9d9303 0068 14 EQ 0069 61 PUSH2 0x0a6a 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a6a, if 0xfe9d9303 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xfe9d9303 == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xff0b9c90 0073 14 EQ 0074 61 PUSH2 0x0b15 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b15, if 0xff0b9c90 == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xff0b9c90 == stack[-1] 0078 61 PUSH2 0x0158 007B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0158 label_007C: // Incoming jump from 0x0035, if 0xd95b6371 > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0x70a08231 0083 14 EQ 0084 61 PUSH2 0x05c6 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c6, if 0x70a08231 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x70a08231 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x959b8c3f 008E 14 EQ 008F 61 PUSH2 0x05ec 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ec, if 0x959b8c3f == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x959b8c3f == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0x95d89b41 0099 14 EQ 009A 61 PUSH2 0x0612 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0612, if 0x95d89b41 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0x95d89b41 == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0x9bd9bbc6 00A4 14 EQ 00A5 61 PUSH2 0x061a 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x061a, if 0x9bd9bbc6 == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0x9bd9bbc6 == stack[-1] // Inputs[1] { @00A9 stack[-1] } 00A9 80 DUP1 00AA 63 PUSH4 0xa9059cbb 00AF 14 EQ 00B0 61 PUSH2 0x06d3 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d3, if 0xa9059cbb == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xa9059cbb == stack[-1] // Inputs[1] { @00B4 stack[-1] } 00B4 80 DUP1 00B5 63 PUSH4 0xca275931 00BA 14 EQ 00BB 61 PUSH2 0x06ff 00BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ff, if 0xca275931 == stack[-1] label_00BF: // Incoming jump from 0x00BE, if not 0xca275931 == stack[-1] 00BF 61 PUSH2 0x0158 00C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0158 label_00C3: // Incoming jump from 0x002A, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00C4 stack[-1] } 00C3 5B JUMPDEST 00C4 80 DUP1 00C5 63 PUSH4 0x3b8e6f2e 00CA 11 GT 00CB 61 PUSH2 0x0115 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0115, if 0x3b8e6f2e > stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x3b8e6f2e > stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x3b8e6f2e 00D5 14 EQ 00D6 61 PUSH2 0x02e0 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e0, if 0x3b8e6f2e == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x3b8e6f2e == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x47d28372 00E0 14 EQ 00E1 61 PUSH2 0x030c 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030c, if 0x47d28372 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x47d28372 == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x4d12d4b6 00EB 14 EQ 00EC 61 PUSH2 0x0314 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0314, if 0x4d12d4b6 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x4d12d4b6 == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0x556f0dc7 00F6 14 EQ 00F7 61 PUSH2 0x0451 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0451, if 0x556f0dc7 == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0x556f0dc7 == stack[-1] // Inputs[1] { @00FB stack[-1] } 00FB 80 DUP1 00FC 63 PUSH4 0x5aa6e675 0101 14 EQ 0102 61 PUSH2 0x0459 0105 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0459, if 0x5aa6e675 == stack[-1] label_0106: // Incoming jump from 0x0105, if not 0x5aa6e675 == stack[-1] // Inputs[1] { @0106 stack[-1] } 0106 80 DUP1 0107 63 PUSH4 0x62ad1b83 010C 14 EQ 010D 61 PUSH2 0x047d 0110 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047d, if 0x62ad1b83 == stack[-1] label_0111: // Incoming jump from 0x0110, if not 0x62ad1b83 == stack[-1] 0111 61 PUSH2 0x0158 0114 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0158 label_0115: // Incoming jump from 0x00CE, if 0x3b8e6f2e > stack[-1] // Inputs[1] { @0116 stack[-1] } 0115 5B JUMPDEST 0116 80 DUP1 0117 63 PUSH4 0x06e48538 011C 14 EQ 011D 61 PUSH2 0x015d 0120 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015d, if 0x06e48538 == stack[-1] label_0121: // Incoming jump from 0x0120, if not 0x06e48538 == stack[-1] // Inputs[1] { @0121 stack[-1] } 0121 80 DUP1 0122 63 PUSH4 0x06fdde03 0127 14 EQ 0128 61 PUSH2 0x01b5 012B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b5, if 0x06fdde03 == stack[-1] label_012C: // Incoming jump from 0x012B, if not 0x06fdde03 == stack[-1] // Inputs[1] { @012C stack[-1] } 012C 80 DUP1 012D 63 PUSH4 0x095ea7b3 0132 14 EQ 0133 61 PUSH2 0x0232 0136 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0232, if 0x095ea7b3 == stack[-1] label_0137: // Incoming jump from 0x0136, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0137 stack[-1] } 0137 80 DUP1 0138 63 PUSH4 0x18160ddd 013D 14 EQ 013E 61 PUSH2 0x0272 0141 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0272, if 0x18160ddd == stack[-1] label_0142: // Incoming jump from 0x0141, if not 0x18160ddd == stack[-1] // Inputs[1] { @0142 stack[-1] } 0142 80 DUP1 0143 63 PUSH4 0x23b872dd 0148 14 EQ 0149 61 PUSH2 0x028c 014C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028c, if 0x23b872dd == stack[-1] label_014D: // Incoming jump from 0x014C, if not 0x23b872dd == stack[-1] // Inputs[1] { @014D stack[-1] } 014D 80 DUP1 014E 63 PUSH4 0x313ce567 0153 14 EQ 0154 61 PUSH2 0x02c2 0157 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c2, if 0x313ce567 == stack[-1] label_0158: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x007B // Incoming jump from 0x0114 // Incoming jump from 0x00C2 // Incoming jump from 0x0157, if not 0x313ce567 == stack[-1] // Inputs[1] { @015C memory[0x00:0x00] } 0158 5B JUMPDEST 0159 60 PUSH1 0x00 015B 80 DUP1 015C FD *REVERT // Stack delta = +0 // Outputs[1] { @015C revert(memory[0x00:0x00]); } // Block terminates label_015D: // Incoming jump from 0x0120, if 0x06e48538 == stack[-1] 015D 5B JUMPDEST 015E 61 PUSH2 0x0165 0161 61 PUSH2 0x0b1d 0164 56 *JUMP // Stack delta = +1 // Outputs[1] { @015E stack[0] = 0x0165 } // Block ends with call to 0x0b1d, returns to 0x0165 label_0165: // Incoming return from call to 0x0B1D at 0x0164 // Inputs[4] // { // @0169 memory[0x40:0x60] // @016F stack[-1] // @0170 memory[stack[-1]:stack[-1] + 0x20] // @0176 memory[stack[-1]:stack[-1] + 0x20] // } 0165 5B JUMPDEST 0166 60 PUSH1 0x40 0168 80 DUP1 0169 51 MLOAD 016A 60 PUSH1 0x20 016C 80 DUP1 016D 82 DUP3 016E 52 MSTORE 016F 83 DUP4 0170 51 MLOAD 0171 81 DUP2 0172 83 DUP4 0173 01 ADD 0174 52 MSTORE 0175 83 DUP4 0176 51 MLOAD 0177 91 SWAP2 0178 92 SWAP3 0179 83 DUP4 017A 92 SWAP3 017B 90 SWAP1 017C 83 DUP4 017D 01 ADD 017E 91 SWAP2 017F 85 DUP6 0180 81 DUP2 0181 01 ADD 0182 91 SWAP2 0183 02 MUL 0184 80 DUP1 0185 83 DUP4 0186 83 DUP4 0187 60 PUSH1 0x00 0189 5B JUMPDEST 018A 83 DUP4 018B 81 DUP2 018C 10 LT 018D 15 ISZERO 018E 61 PUSH2 0x01a1 0191 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @016E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @0174 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0178 stack[0] = memory[0x40:0x60] // @017A stack[1] = memory[0x40:0x60] // @017E stack[2] = memory[0x40:0x60] + 0x40 // @0182 stack[3] = 0x20 + stack[-1] // @0183 stack[4] = memory[stack[-1]:stack[-1] + 0x20] * 0x20 // @0184 stack[5] = memory[stack[-1]:stack[-1] + 0x20] * 0x20 // @0185 stack[6] = memory[0x40:0x60] + 0x40 // @0186 stack[7] = 0x20 + stack[-1] // @0187 stack[8] = 0x00 // } // Block ends with conditional jump to 0x01a1, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) label_0192: // Incoming jump from 0x0191, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) // Incoming jump from 0x0191, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0192 stack[-2] // @0193 stack[-1] // @0195 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0196 stack[-3] // } 0192 81 DUP2 0193 81 DUP2 0194 01 ADD 0195 51 MLOAD 0196 83 DUP4 0197 82 DUP3 0198 01 ADD 0199 52 MSTORE 019A 60 PUSH1 0x20 019C 01 ADD 019D 61 PUSH2 0x0189 01A0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0199 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @019C stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0189 label_01A1: // Incoming jump from 0x0191, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20] * 0x20) // Incoming jump from 0x0191, if !(stack[-1] < stack[-4]) // Inputs[6] // { // @01A6 stack[-6] // @01A6 stack[-5] // @01A8 stack[-7] // @01A9 stack[-10] // @01AF memory[0x40:0x60] // @01B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]] // } 01A1 5B JUMPDEST 01A2 50 POP 01A3 50 POP 01A4 50 POP 01A5 50 POP 01A6 90 SWAP1 01A7 50 POP 01A8 01 ADD 01A9 92 SWAP3 01AA 50 POP 01AB 50 POP 01AC 50 POP 01AD 60 PUSH1 0x40 01AF 51 MLOAD 01B0 80 DUP1 01B1 91 SWAP2 01B2 03 SUB 01B3 90 SWAP1 01B4 F3 *RETURN // Stack delta = -10 // Outputs[1] { @01B4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-5] + stack[-7]) - memory[0x40:0x60]]; } // Block terminates label_01B5: // Incoming jump from 0x012B, if 0x06fdde03 == stack[-1] 01B5 5B JUMPDEST 01B6 61 PUSH2 0x01bd 01B9 61 PUSH2 0x0b80 01BC 56 *JUMP // Stack delta = +1 // Outputs[1] { @01B6 stack[0] = 0x01bd } // Block ends with call to 0x0b80, returns to 0x01BD label_01BD: // Incoming return from call to 0x0B80 at 0x01BC // Incoming return from call to 0x1226 at 0x0619 // Inputs[4] // { // @01C1 memory[0x40:0x60] // @01C7 stack[-1] // @01C8 memory[stack[-1]:stack[-1] + 0x20] // @01CE memory[stack[-1]:stack[-1] + 0x20] // } 01BD 5B JUMPDEST 01BE 60 PUSH1 0x40 01C0 80 DUP1 01C1 51 MLOAD 01C2 60 PUSH1 0x20 01C4 80 DUP1 01C5 82 DUP3 01C6 52 MSTORE 01C7 83 DUP4 01C8 51 MLOAD 01C9 81 DUP2 01CA 83 DUP4 01CB 01 ADD 01CC 52 MSTORE 01CD 83 DUP4 01CE 51 MLOAD 01CF 91 SWAP2 01D0 92 SWAP3 01D1 83 DUP4 01D2 92 SWAP3 01D3 90 SWAP1 01D4 83 DUP4 01D5 01 ADD 01D6 91 SWAP2 01D7 85 DUP6 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 0x01f7 01E7 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @01C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @01CC memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @01D0 stack[0] = memory[0x40:0x60] // @01D2 stack[1] = memory[0x40:0x60] // @01D6 stack[2] = memory[0x40:0x60] + 0x40 // @01D9 stack[3] = stack[-1] + 0x20 // @01D9 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @01DA stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @01DB stack[6] = memory[0x40:0x60] + 0x40 // @01DC stack[7] = stack[-1] + 0x20 // @01DD stack[8] = 0x00 // } // Block ends with conditional jump to 0x01f7, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_01E8: // Incoming jump from 0x01E7, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x01E7, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @01E8 stack[-2] // @01E9 stack[-1] // @01EB memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @01EC stack[-3] // } 01E8 81 DUP2 01E9 81 DUP2 01EA 01 ADD 01EB 51 MLOAD 01EC 83 DUP4 01ED 82 DUP3 01EE 01 ADD 01EF 52 MSTORE 01F0 60 PUSH1 0x20 01F2 01 ADD 01F3 61 PUSH2 0x01df 01F6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01EF memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @01F2 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x01df label_01F7: // Incoming jump from 0x01E7, if !(stack[-1] < stack[-4]) // Incoming jump from 0x01E7, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @01FC stack[-6] // @01FC stack[-5] // @01FE stack[-7] // } 01F7 5B JUMPDEST 01F8 50 POP 01F9 50 POP 01FA 50 POP 01FB 50 POP 01FC 90 SWAP1 01FD 50 POP 01FE 90 SWAP1 01FF 81 DUP2 0200 01 ADD 0201 90 SWAP1 0202 60 PUSH1 0x1f 0204 16 AND 0205 80 DUP1 0206 15 ISZERO 0207 61 PUSH2 0x0224 020A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0201 stack[-7] = stack[-5] + stack[-7] // @0204 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0224, if !(0x1f & stack[-5]) label_020B: // Incoming jump from 0x020A, if not !(0x1f & stack[-5]) // Inputs[6] // { // @020B stack[-1] // @020C stack[-2] // @020F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0226 stack[-5] // @022C memory[0x40:0x60] // @0231 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 020B 80 DUP1 020C 82 DUP3 020D 03 SUB 020E 80 DUP1 020F 51 MLOAD 0210 60 PUSH1 0x01 0212 83 DUP4 0213 60 PUSH1 0x20 0215 03 SUB 0216 61 PUSH2 0x0100 0219 0A EXP 021A 03 SUB 021B 19 NOT 021C 16 AND 021D 81 DUP2 021E 52 MSTORE 021F 60 PUSH1 0x20 0221 01 ADD 0222 91 SWAP2 0223 50 POP 0224 5B JUMPDEST 0225 50 POP 0226 92 SWAP3 0227 50 POP 0228 50 POP 0229 50 POP 022A 60 PUSH1 0x40 022C 51 MLOAD 022D 80 DUP1 022E 91 SWAP2 022F 03 SUB 0230 90 SWAP1 0231 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @021E 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] // @0231 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0232: // Incoming jump from 0x0136, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0239 msg.data.length } 0232 5B JUMPDEST 0233 61 PUSH2 0x025e 0236 60 PUSH1 0x04 0238 80 DUP1 0239 36 CALLDATASIZE 023A 03 SUB 023B 60 PUSH1 0x40 023D 81 DUP2 023E 10 LT 023F 15 ISZERO 0240 61 PUSH2 0x0248 0243 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0233 stack[0] = 0x025e // @0236 stack[1] = 0x04 // @023A stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0248, if !(msg.data.length - 0x04 < 0x40) label_0244: // Incoming jump from 0x0243, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0247 memory[0x00:0x00] } 0244 60 PUSH1 0x00 0246 80 DUP1 0247 FD *REVERT // Stack delta = +0 // Outputs[1] { @0247 revert(memory[0x00:0x00]); } // Block terminates label_0248: // Incoming jump from 0x0243, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0252 stack[-2] // @0253 msg.data[stack[-2]:stack[-2] + 0x20] // @0259 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0248 5B JUMPDEST 0249 50 POP 024A 60 PUSH1 0x01 024C 60 PUSH1 0x01 024E 60 PUSH1 0xa0 0250 1B SHL 0251 03 SUB 0252 81 DUP2 0253 35 CALLDATALOAD 0254 16 AND 0255 90 SWAP1 0256 60 PUSH1 0x20 0258 01 ADD 0259 35 CALLDATALOAD 025A 61 PUSH2 0x0c0d 025D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0255 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0259 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0c0d label_025E: // Incoming return from call to 0x08C0 at 0x08BB // Inputs[4] // { // @0262 memory[0x40:0x60] // @0263 stack[-1] // @0268 memory[0x40:0x60] // @0271 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 025E 5B JUMPDEST 025F 60 PUSH1 0x40 0261 80 DUP1 0262 51 MLOAD 0263 91 SWAP2 0264 15 ISZERO 0265 15 ISZERO 0266 82 DUP3 0267 52 MSTORE 0268 51 MLOAD 0269 90 SWAP1 026A 81 DUP2 026B 90 SWAP1 026C 03 SUB 026D 60 PUSH1 0x20 026F 01 ADD 0270 90 SWAP1 0271 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0267 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0271 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0272: // Incoming jump from 0x0141, if 0x18160ddd == stack[-1] 0272 5B JUMPDEST 0273 61 PUSH2 0x027a 0276 61 PUSH2 0x0c31 0279 56 *JUMP // Stack delta = +1 // Outputs[1] { @0273 stack[0] = 0x027a } // Block ends with call to 0x0c31, returns to 0x027A label_027A: // Incoming return from call to 0x0C31 at 0x0279 // Incoming return from call to 0x18A0 at 0x0B1C // Incoming return from call to 0x1024 at 0x0458 // Incoming return from call to 0x08EE at 0x08E9 // Incoming return from call to 0x0DFE at 0x0313 // Incoming return from call to 0x02F6 at 0x02F1 // Inputs[4] // { // @027E memory[0x40:0x60] // @027F stack[-1] // @0282 memory[0x40:0x60] // @028B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 027A 5B JUMPDEST 027B 60 PUSH1 0x40 027D 80 DUP1 027E 51 MLOAD 027F 91 SWAP2 0280 82 DUP3 0281 52 MSTORE 0282 51 MLOAD 0283 90 SWAP1 0284 81 DUP2 0285 90 SWAP1 0286 03 SUB 0287 60 PUSH1 0x20 0289 01 ADD 028A 90 SWAP1 028B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0281 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @028B return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_028C: // Incoming jump from 0x014C, if 0x23b872dd == stack[-1] // Inputs[1] { @0293 msg.data.length } 028C 5B JUMPDEST 028D 61 PUSH2 0x025e 0290 60 PUSH1 0x04 0292 80 DUP1 0293 36 CALLDATASIZE 0294 03 SUB 0295 60 PUSH1 0x60 0297 81 DUP2 0298 10 LT 0299 15 ISZERO 029A 61 PUSH2 0x02a2 029D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @028D stack[0] = 0x025e // @0290 stack[1] = 0x04 // @0294 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x02a2, if !(msg.data.length - 0x04 < 0x60) label_029E: // Incoming jump from 0x029D, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @02A1 memory[0x00:0x00] } 029E 60 PUSH1 0x00 02A0 80 DUP1 02A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A1 revert(memory[0x00:0x00]); } // Block terminates label_02A2: // Incoming jump from 0x029D, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @02AC stack[-2] // @02AD msg.data[stack[-2]:stack[-2] + 0x20] // @02B5 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02BD msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 02A2 5B JUMPDEST 02A3 50 POP 02A4 60 PUSH1 0x01 02A6 60 PUSH1 0x01 02A8 60 PUSH1 0xa0 02AA 1B SHL 02AB 03 SUB 02AC 81 DUP2 02AD 35 CALLDATALOAD 02AE 81 DUP2 02AF 16 AND 02B0 91 SWAP2 02B1 60 PUSH1 0x20 02B3 81 DUP2 02B4 01 ADD 02B5 35 CALLDATALOAD 02B6 90 SWAP1 02B7 91 SWAP2 02B8 16 AND 02B9 90 SWAP1 02BA 60 PUSH1 0x40 02BC 01 ADD 02BD 35 CALLDATALOAD 02BE 61 PUSH2 0x0c37 02C1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @02B0 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @02B9 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @02BD stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0c37 label_02C2: // Incoming jump from 0x0157, if 0x313ce567 == stack[-1] 02C2 5B JUMPDEST 02C3 61 PUSH2 0x02ca 02C6 61 PUSH2 0x0dba 02C9 56 *JUMP // Stack delta = +1 // Outputs[1] { @02C3 stack[0] = 0x02ca } // Block ends with call to 0x0dba, returns to 0x02CA label_02CA: // Incoming return from call to 0x0DBA at 0x02C9 // Inputs[4] // { // @02CE memory[0x40:0x60] // @02D2 stack[-1] // @02D6 memory[0x40:0x60] // @02DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 02CA 5B JUMPDEST 02CB 60 PUSH1 0x40 02CD 80 DUP1 02CE 51 MLOAD 02CF 60 PUSH1 0xff 02D1 90 SWAP1 02D2 92 SWAP3 02D3 16 AND 02D4 82 DUP3 02D5 52 MSTORE 02D6 51 MLOAD 02D7 90 SWAP1 02D8 81 DUP2 02D9 90 SWAP1 02DA 03 SUB 02DB 60 PUSH1 0x20 02DD 01 ADD 02DE 90 SWAP1 02DF F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @02DF return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_02E0: // Incoming jump from 0x00D9, if 0x3b8e6f2e == stack[-1] // Inputs[1] { @02E7 msg.data.length } 02E0 5B JUMPDEST 02E1 61 PUSH2 0x027a 02E4 60 PUSH1 0x04 02E6 80 DUP1 02E7 36 CALLDATASIZE 02E8 03 SUB 02E9 60 PUSH1 0x40 02EB 81 DUP2 02EC 10 LT 02ED 15 ISZERO 02EE 61 PUSH2 0x02f6 02F1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02E1 stack[0] = 0x027a // @02E4 stack[1] = 0x04 // @02E8 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02f6, returns to 0x027A, if !(msg.data.length - 0x04 < 0x40) label_02F2: // Incoming jump from 0x02F1, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @02F5 memory[0x00:0x00] } 02F2 60 PUSH1 0x00 02F4 80 DUP1 02F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F5 revert(memory[0x00:0x00]); } // Block terminates label_02F6: // Incoming call from 0x02F1, returns to 0x027A, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0300 stack[-2] // @0301 msg.data[stack[-2]:stack[-2] + 0x20] // @0307 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 02F6 5B JUMPDEST 02F7 50 POP 02F8 60 PUSH1 0x01 02FA 60 PUSH1 0x01 02FC 60 PUSH1 0xa0 02FE 1B SHL 02FF 03 SUB 0300 81 DUP2 0301 35 CALLDATALOAD 0302 16 AND 0303 90 SWAP1 0304 60 PUSH1 0x20 0306 01 ADD 0307 35 CALLDATALOAD 0308 61 PUSH2 0x0dbf 030B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0303 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0307 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0dbf label_030C: // Incoming jump from 0x00E4, if 0x47d28372 == stack[-1] 030C 5B JUMPDEST 030D 61 PUSH2 0x027a 0310 61 PUSH2 0x0dfe 0313 56 *JUMP // Stack delta = +1 // Outputs[1] { @030D stack[0] = 0x027a } // Block ends with call to 0x0dfe, returns to 0x027A label_0314: // Incoming jump from 0x00EF, if 0x4d12d4b6 == stack[-1] // Inputs[1] { @031B msg.data.length } 0314 5B JUMPDEST 0315 61 PUSH2 0x044f 0318 60 PUSH1 0x04 031A 80 DUP1 031B 36 CALLDATASIZE 031C 03 SUB 031D 60 PUSH1 0x80 031F 81 DUP2 0320 10 LT 0321 15 ISZERO 0322 61 PUSH2 0x032a 0325 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0315 stack[0] = 0x044f // @0318 stack[1] = 0x04 // @031C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x032a, if !(msg.data.length - 0x04 < 0x80) label_0326: // Incoming jump from 0x0325, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0329 memory[0x00:0x00] } 0326 60 PUSH1 0x00 0328 80 DUP1 0329 FD *REVERT // Stack delta = +0 // Outputs[1] { @0329 revert(memory[0x00:0x00]); } // Block terminates label_032A: // Incoming jump from 0x0325, if !(msg.data.length - 0x04 < 0x80) // Inputs[4] // { // @0333 stack[-2] // @0334 msg.data[stack[-2]:stack[-2] + 0x20] // @0337 stack[-1] // @0343 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 032A 5B JUMPDEST 032B 60 PUSH1 0x01 032D 60 PUSH1 0x01 032F 60 PUSH1 0xa0 0331 1B SHL 0332 03 SUB 0333 82 DUP3 0334 35 CALLDATALOAD 0335 16 AND 0336 91 SWAP2 0337 90 SWAP1 0338 81 DUP2 0339 01 ADD 033A 90 SWAP1 033B 60 PUSH1 0x40 033D 81 DUP2 033E 01 ADD 033F 60 PUSH1 0x20 0341 82 DUP3 0342 01 ADD 0343 35 CALLDATALOAD 0344 60 PUSH1 0x01 0346 60 PUSH1 0x20 0348 1B SHL 0349 81 DUP2 034A 11 GT 034B 15 ISZERO 034C 61 PUSH2 0x0354 034F 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0336 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @033A stack[0] = stack[-2] // @033A stack[-1] = stack[-2] + stack[-1] // @033E stack[1] = stack[-2] + 0x40 // @0343 stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x0354, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) label_0350: // Incoming jump from 0x034F, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0353 memory[0x00:0x00] } 0350 60 PUSH1 0x00 0352 80 DUP1 0353 FD *REVERT // Stack delta = +0 // Outputs[1] { @0353 revert(memory[0x00:0x00]); } // Block terminates label_0354: // Incoming jump from 0x034F, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0355 stack[-3] // @0356 stack[-1] // @0357 stack[-4] // } 0354 5B JUMPDEST 0355 82 DUP3 0356 01 ADD 0357 83 DUP4 0358 60 PUSH1 0x20 035A 82 DUP3 035B 01 ADD 035C 11 GT 035D 15 ISZERO 035E 61 PUSH2 0x0366 0361 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0356 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0366, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0362: // Incoming jump from 0x0361, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0365 memory[0x00:0x00] } 0362 60 PUSH1 0x00 0364 80 DUP1 0365 FD *REVERT // Stack delta = +0 // Outputs[1] { @0365 revert(memory[0x00:0x00]); } // Block terminates label_0366: // Incoming jump from 0x0361, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0367 stack[-1] // @0368 msg.data[stack[-1]:stack[-1] + 0x20] // @036D stack[-2] // @036E stack[-4] // } 0366 5B JUMPDEST 0367 80 DUP1 0368 35 CALLDATALOAD 0369 90 SWAP1 036A 60 PUSH1 0x20 036C 01 ADD 036D 91 SWAP2 036E 84 DUP5 036F 60 PUSH1 0x01 0371 83 DUP4 0372 02 MUL 0373 84 DUP5 0374 01 ADD 0375 11 GT 0376 60 PUSH1 0x01 0378 60 PUSH1 0x20 037A 1B SHL 037B 83 DUP4 037C 11 GT 037D 17 OR 037E 15 ISZERO 037F 61 PUSH2 0x0387 0382 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0369 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @036D stack[0] = stack[-2] // @036D stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0387, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0383: // Incoming jump from 0x0382, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0386 memory[0x00:0x00] } 0383 60 PUSH1 0x00 0385 80 DUP1 0386 FD *REVERT // Stack delta = +0 // Outputs[1] { @0386 revert(memory[0x00:0x00]); } // Block terminates label_0387: // Incoming jump from 0x0382, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @0388 stack[-1] // @0388 stack[-3] // @0389 stack[-2] // @039A memory[0x40:0x60] // @03B1 msg.data[stack[-3]:stack[-3] + stack[-2]] // @03BC stack[-5] // @03BD stack[-4] // @03C5 msg.data[stack[-1]:stack[-1] + 0x20] // } 0387 5B JUMPDEST 0388 91 SWAP2 0389 90 SWAP1 038A 80 DUP1 038B 80 DUP1 038C 60 PUSH1 0x1f 038E 01 ADD 038F 60 PUSH1 0x20 0391 80 DUP1 0392 91 SWAP2 0393 04 DIV 0394 02 MUL 0395 60 PUSH1 0x20 0397 01 ADD 0398 60 PUSH1 0x40 039A 51 MLOAD 039B 90 SWAP1 039C 81 DUP2 039D 01 ADD 039E 60 PUSH1 0x40 03A0 52 MSTORE 03A1 80 DUP1 03A2 93 SWAP4 03A3 92 SWAP3 03A4 91 SWAP2 03A5 90 SWAP1 03A6 81 DUP2 03A7 81 DUP2 03A8 52 MSTORE 03A9 60 PUSH1 0x20 03AB 01 ADD 03AC 83 DUP4 03AD 83 DUP4 03AE 80 DUP1 03AF 82 DUP3 03B0 84 DUP5 03B1 37 CALLDATACOPY 03B2 60 PUSH1 0x00 03B4 92 SWAP3 03B5 01 ADD 03B6 91 SWAP2 03B7 90 SWAP1 03B8 91 SWAP2 03B9 52 MSTORE 03BA 50 POP 03BB 92 SWAP3 03BC 95 SWAP6 03BD 94 SWAP5 03BE 93 SWAP4 03BF 60 PUSH1 0x20 03C1 81 DUP2 03C2 01 ADD 03C3 93 SWAP4 03C4 50 POP 03C5 35 CALLDATALOAD 03C6 91 SWAP2 03C7 50 POP 03C8 50 POP 03C9 60 PUSH1 0x01 03CB 60 PUSH1 0x20 03CD 1B SHL 03CE 81 DUP2 03CF 11 GT 03D0 15 ISZERO 03D1 61 PUSH2 0x03d9 03D4 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @03A0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @03A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @03B1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @03B9 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @03BC stack[-5] = memory[0x40:0x60] // @03BD stack[-4] = stack[-5] // @03BE stack[-3] = stack[-4] // @03C3 stack[-2] = stack[-1] + 0x20 // @03C6 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x03d9, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_03D5: // Incoming jump from 0x03D4, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @03D8 memory[0x00:0x00] } 03D5 60 PUSH1 0x00 03D7 80 DUP1 03D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D8 revert(memory[0x00:0x00]); } // Block terminates label_03D9: // Incoming jump from 0x03D4, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @03DA stack[-3] // @03DB stack[-1] // @03DC stack[-4] // } 03D9 5B JUMPDEST 03DA 82 DUP3 03DB 01 ADD 03DC 83 DUP4 03DD 60 PUSH1 0x20 03DF 82 DUP3 03E0 01 ADD 03E1 11 GT 03E2 15 ISZERO 03E3 61 PUSH2 0x03eb 03E6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03DB stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x03eb, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_03E7: // Incoming jump from 0x03E6, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @03EA memory[0x00:0x00] } 03E7 60 PUSH1 0x00 03E9 80 DUP1 03EA FD *REVERT // Stack delta = +0 // Outputs[1] { @03EA revert(memory[0x00:0x00]); } // Block terminates label_03EB: // Incoming jump from 0x03E6, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @03EC stack[-1] // @03ED msg.data[stack[-1]:stack[-1] + 0x20] // @03F2 stack[-2] // @03F3 stack[-4] // } 03EB 5B JUMPDEST 03EC 80 DUP1 03ED 35 CALLDATALOAD 03EE 90 SWAP1 03EF 60 PUSH1 0x20 03F1 01 ADD 03F2 91 SWAP2 03F3 84 DUP5 03F4 60 PUSH1 0x01 03F6 83 DUP4 03F7 02 MUL 03F8 84 DUP5 03F9 01 ADD 03FA 11 GT 03FB 60 PUSH1 0x01 03FD 60 PUSH1 0x20 03FF 1B SHL 0400 83 DUP4 0401 11 GT 0402 17 OR 0403 15 ISZERO 0404 61 PUSH2 0x040c 0407 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @03EE stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @03F2 stack[0] = stack[-2] // @03F2 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x040c, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0408: // Incoming jump from 0x0407, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @040B memory[0x00:0x00] } 0408 60 PUSH1 0x00 040A 80 DUP1 040B FD *REVERT // Stack delta = +0 // Outputs[1] { @040B revert(memory[0x00:0x00]); } // Block terminates label_040C: // Incoming jump from 0x0407, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @040D stack[-1] // @040D stack[-3] // @040E stack[-2] // @041F memory[0x40:0x60] // @0436 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0441 stack[-5] // @0445 msg.data[stack[-1]:stack[-1] + 0x20] // @0446 stack[-4] // } 040C 5B JUMPDEST 040D 91 SWAP2 040E 90 SWAP1 040F 80 DUP1 0410 80 DUP1 0411 60 PUSH1 0x1f 0413 01 ADD 0414 60 PUSH1 0x20 0416 80 DUP1 0417 91 SWAP2 0418 04 DIV 0419 02 MUL 041A 60 PUSH1 0x20 041C 01 ADD 041D 60 PUSH1 0x40 041F 51 MLOAD 0420 90 SWAP1 0421 81 DUP2 0422 01 ADD 0423 60 PUSH1 0x40 0425 52 MSTORE 0426 80 DUP1 0427 93 SWAP4 0428 92 SWAP3 0429 91 SWAP2 042A 90 SWAP1 042B 81 DUP2 042C 81 DUP2 042D 52 MSTORE 042E 60 PUSH1 0x20 0430 01 ADD 0431 83 DUP4 0432 83 DUP4 0433 80 DUP1 0434 82 DUP3 0435 84 DUP5 0436 37 CALLDATACOPY 0437 60 PUSH1 0x00 0439 92 SWAP3 043A 01 ADD 043B 91 SWAP2 043C 90 SWAP1 043D 91 SWAP2 043E 52 MSTORE 043F 50 POP 0440 92 SWAP3 0441 95 SWAP6 0442 50 POP 0443 50 POP 0444 91 SWAP2 0445 35 CALLDATALOAD 0446 92 SWAP3 0447 50 POP 0448 61 PUSH2 0x0e08 044B 91 SWAP2 044C 50 POP 044D 50 POP 044E 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @0425 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @042D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0436 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @043E memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0441 stack[-5] = memory[0x40:0x60] // @0446 stack[-4] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x0e08 label_044F: // Incoming return from call to 0x091C at 0x0917 // Incoming return from call to 0x0602 at 0x05FD 044F 5B JUMPDEST 0450 00 *STOP // Stack delta = +0 // Outputs[1] { @0450 stop(); } // Block terminates label_0451: // Incoming jump from 0x00FA, if 0x556f0dc7 == stack[-1] 0451 5B JUMPDEST 0452 61 PUSH2 0x027a 0455 61 PUSH2 0x1024 0458 56 *JUMP // Stack delta = +1 // Outputs[1] { @0452 stack[0] = 0x027a } // Block ends with call to 0x1024, returns to 0x027A label_0459: // Incoming jump from 0x0105, if 0x5aa6e675 == stack[-1] 0459 5B JUMPDEST 045A 61 PUSH2 0x0461 045D 61 PUSH2 0x1029 0460 56 *JUMP // Stack delta = +1 // Outputs[1] { @045A stack[0] = 0x0461 } // Block ends with call to 0x1029, returns to 0x0461 label_0461: // Incoming return from call to 0x1029 at 0x0460 // Inputs[4] // { // @0465 memory[0x40:0x60] // @046F stack[-1] // @0473 memory[0x40:0x60] // @047C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0461 5B JUMPDEST 0462 60 PUSH1 0x40 0464 80 DUP1 0465 51 MLOAD 0466 60 PUSH1 0x01 0468 60 PUSH1 0x01 046A 60 PUSH1 0xa0 046C 1B SHL 046D 03 SUB 046E 90 SWAP1 046F 92 SWAP3 0470 16 AND 0471 82 DUP3 0472 52 MSTORE 0473 51 MLOAD 0474 90 SWAP1 0475 81 DUP2 0476 90 SWAP1 0477 03 SUB 0478 60 PUSH1 0x20 047A 01 ADD 047B 90 SWAP1 047C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0472 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @047C return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_047D: // Incoming jump from 0x0110, if 0x62ad1b83 == stack[-1] // Inputs[1] { @0484 msg.data.length } 047D 5B JUMPDEST 047E 61 PUSH2 0x044f 0481 60 PUSH1 0x04 0483 80 DUP1 0484 36 CALLDATASIZE 0485 03 SUB 0486 60 PUSH1 0xa0 0488 81 DUP2 0489 10 LT 048A 15 ISZERO 048B 61 PUSH2 0x0493 048E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @047E stack[0] = 0x044f // @0481 stack[1] = 0x04 // @0485 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0493, if !(msg.data.length - 0x04 < 0xa0) label_048F: // Incoming jump from 0x048E, if not !(msg.data.length - 0x04 < 0xa0) // Inputs[1] { @0492 memory[0x00:0x00] } 048F 60 PUSH1 0x00 0491 80 DUP1 0492 FD *REVERT // Stack delta = +0 // Outputs[1] { @0492 revert(memory[0x00:0x00]); } // Block terminates label_0493: // Incoming jump from 0x048E, if !(msg.data.length - 0x04 < 0xa0) // Inputs[6] // { // @049C stack[-2] // @049D msg.data[stack[-2]:stack[-2] + 0x20] // @04A5 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @04A9 stack[-1] // @04AE msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @04BC msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 0493 5B JUMPDEST 0494 60 PUSH1 0x01 0496 60 PUSH1 0x01 0498 60 PUSH1 0xa0 049A 1B SHL 049B 03 SUB 049C 82 DUP3 049D 35 CALLDATALOAD 049E 81 DUP2 049F 16 AND 04A0 92 SWAP3 04A1 60 PUSH1 0x20 04A3 81 DUP2 04A4 01 ADD 04A5 35 CALLDATALOAD 04A6 90 SWAP1 04A7 91 SWAP2 04A8 16 AND 04A9 91 SWAP2 04AA 60 PUSH1 0x40 04AC 82 DUP3 04AD 01 ADD 04AE 35 CALLDATALOAD 04AF 91 SWAP2 04B0 90 SWAP1 04B1 81 DUP2 04B2 01 ADD 04B3 90 SWAP1 04B4 60 PUSH1 0x80 04B6 81 DUP2 04B7 01 ADD 04B8 60 PUSH1 0x60 04BA 82 DUP3 04BB 01 ADD 04BC 35 CALLDATALOAD 04BD 60 PUSH1 0x01 04BF 60 PUSH1 0x20 04C1 1B SHL 04C2 81 DUP2 04C3 11 GT 04C4 15 ISZERO 04C5 61 PUSH2 0x04cd 04C8 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @04A0 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @04A9 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @04AF stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @04B3 stack[1] = stack[-2] + stack[-1] // @04B3 stack[2] = stack[-2] // @04B7 stack[3] = stack[-2] + 0x80 // @04BC stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x04cd, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) label_04C9: // Incoming jump from 0x04C8, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[1] { @04CC memory[0x00:0x00] } 04C9 60 PUSH1 0x00 04CB 80 DUP1 04CC FD *REVERT // Stack delta = +0 // Outputs[1] { @04CC revert(memory[0x00:0x00]); } // Block terminates label_04CD: // Incoming jump from 0x04C8, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @04CE stack[-3] // @04CF stack[-1] // @04D0 stack[-4] // } 04CD 5B JUMPDEST 04CE 82 DUP3 04CF 01 ADD 04D0 83 DUP4 04D1 60 PUSH1 0x20 04D3 82 DUP3 04D4 01 ADD 04D5 11 GT 04D6 15 ISZERO 04D7 61 PUSH2 0x04df 04DA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @04CF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x04df, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_04DB: // Incoming jump from 0x04DA, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @04DE memory[0x00:0x00] } 04DB 60 PUSH1 0x00 04DD 80 DUP1 04DE FD *REVERT // Stack delta = +0 // Outputs[1] { @04DE revert(memory[0x00:0x00]); } // Block terminates label_04DF: // Incoming jump from 0x04DA, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @04E0 stack[-1] // @04E1 msg.data[stack[-1]:stack[-1] + 0x20] // @04E6 stack[-2] // @04E7 stack[-4] // } 04DF 5B JUMPDEST 04E0 80 DUP1 04E1 35 CALLDATALOAD 04E2 90 SWAP1 04E3 60 PUSH1 0x20 04E5 01 ADD 04E6 91 SWAP2 04E7 84 DUP5 04E8 60 PUSH1 0x01 04EA 83 DUP4 04EB 02 MUL 04EC 84 DUP5 04ED 01 ADD 04EE 11 GT 04EF 60 PUSH1 0x01 04F1 60 PUSH1 0x20 04F3 1B SHL 04F4 83 DUP4 04F5 11 GT 04F6 17 OR 04F7 15 ISZERO 04F8 61 PUSH2 0x0500 04FB 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @04E2 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @04E6 stack[0] = stack[-2] // @04E6 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0500, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_04FC: // Incoming jump from 0x04FB, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @04FF memory[0x00:0x00] } 04FC 60 PUSH1 0x00 04FE 80 DUP1 04FF FD *REVERT // Stack delta = +0 // Outputs[1] { @04FF revert(memory[0x00:0x00]); } // Block terminates label_0500: // Incoming jump from 0x04FB, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @0501 stack[-1] // @0501 stack[-3] // @0502 stack[-2] // @0513 memory[0x40:0x60] // @052A msg.data[stack[-3]:stack[-3] + stack[-2]] // @0535 stack[-5] // @0536 stack[-4] // @053E msg.data[stack[-1]:stack[-1] + 0x20] // } 0500 5B JUMPDEST 0501 91 SWAP2 0502 90 SWAP1 0503 80 DUP1 0504 80 DUP1 0505 60 PUSH1 0x1f 0507 01 ADD 0508 60 PUSH1 0x20 050A 80 DUP1 050B 91 SWAP2 050C 04 DIV 050D 02 MUL 050E 60 PUSH1 0x20 0510 01 ADD 0511 60 PUSH1 0x40 0513 51 MLOAD 0514 90 SWAP1 0515 81 DUP2 0516 01 ADD 0517 60 PUSH1 0x40 0519 52 MSTORE 051A 80 DUP1 051B 93 SWAP4 051C 92 SWAP3 051D 91 SWAP2 051E 90 SWAP1 051F 81 DUP2 0520 81 DUP2 0521 52 MSTORE 0522 60 PUSH1 0x20 0524 01 ADD 0525 83 DUP4 0526 83 DUP4 0527 80 DUP1 0528 82 DUP3 0529 84 DUP5 052A 37 CALLDATACOPY 052B 60 PUSH1 0x00 052D 92 SWAP3 052E 01 ADD 052F 91 SWAP2 0530 90 SWAP1 0531 91 SWAP2 0532 52 MSTORE 0533 50 POP 0534 92 SWAP3 0535 95 SWAP6 0536 94 SWAP5 0537 93 SWAP4 0538 60 PUSH1 0x20 053A 81 DUP2 053B 01 ADD 053C 93 SWAP4 053D 50 POP 053E 35 CALLDATALOAD 053F 91 SWAP2 0540 50 POP 0541 50 POP 0542 60 PUSH1 0x01 0544 60 PUSH1 0x20 0546 1B SHL 0547 81 DUP2 0548 11 GT 0549 15 ISZERO 054A 61 PUSH2 0x0552 054D 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0519 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0521 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @052A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0532 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0535 stack[-5] = memory[0x40:0x60] // @0536 stack[-4] = stack[-5] // @0537 stack[-3] = stack[-4] // @053C stack[-2] = stack[-1] + 0x20 // @053F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0552, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_054E: // Incoming jump from 0x054D, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0551 memory[0x00:0x00] } 054E 60 PUSH1 0x00 0550 80 DUP1 0551 FD *REVERT // Stack delta = +0 // Outputs[1] { @0551 revert(memory[0x00:0x00]); } // Block terminates label_0552: // Incoming jump from 0x054D, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0553 stack[-3] // @0554 stack[-1] // @0555 stack[-4] // } 0552 5B JUMPDEST 0553 82 DUP3 0554 01 ADD 0555 83 DUP4 0556 60 PUSH1 0x20 0558 82 DUP3 0559 01 ADD 055A 11 GT 055B 15 ISZERO 055C 61 PUSH2 0x0564 055F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0554 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0564, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0560: // Incoming jump from 0x055F, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0563 memory[0x00:0x00] } 0560 60 PUSH1 0x00 0562 80 DUP1 0563 FD *REVERT // Stack delta = +0 // Outputs[1] { @0563 revert(memory[0x00:0x00]); } // Block terminates label_0564: // Incoming jump from 0x055F, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0565 stack[-1] // @0566 msg.data[stack[-1]:stack[-1] + 0x20] // @056B stack[-2] // @056C stack[-4] // } 0564 5B JUMPDEST 0565 80 DUP1 0566 35 CALLDATALOAD 0567 90 SWAP1 0568 60 PUSH1 0x20 056A 01 ADD 056B 91 SWAP2 056C 84 DUP5 056D 60 PUSH1 0x01 056F 83 DUP4 0570 02 MUL 0571 84 DUP5 0572 01 ADD 0573 11 GT 0574 60 PUSH1 0x01 0576 60 PUSH1 0x20 0578 1B SHL 0579 83 DUP4 057A 11 GT 057B 17 OR 057C 15 ISZERO 057D 61 PUSH2 0x0585 0580 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0567 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @056B stack[0] = stack[-2] // @056B stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0585, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0581: // Incoming jump from 0x0580, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0584 memory[0x00:0x00] } 0581 60 PUSH1 0x00 0583 80 DUP1 0584 FD *REVERT // Stack delta = +0 // Outputs[1] { @0584 revert(memory[0x00:0x00]); } // Block terminates label_0585: // Incoming jump from 0x0580, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0586 stack[-3] // @0586 stack[-1] // @0587 stack[-2] // @0598 memory[0x40:0x60] // @05AF msg.data[stack[-3]:stack[-3] + stack[-2]] // @05BA stack[-5] // @05BF stack[-4] // } 0585 5B JUMPDEST 0586 91 SWAP2 0587 90 SWAP1 0588 80 DUP1 0589 80 DUP1 058A 60 PUSH1 0x1f 058C 01 ADD 058D 60 PUSH1 0x20 058F 80 DUP1 0590 91 SWAP2 0591 04 DIV 0592 02 MUL 0593 60 PUSH1 0x20 0595 01 ADD 0596 60 PUSH1 0x40 0598 51 MLOAD 0599 90 SWAP1 059A 81 DUP2 059B 01 ADD 059C 60 PUSH1 0x40 059E 52 MSTORE 059F 80 DUP1 05A0 93 SWAP4 05A1 92 SWAP3 05A2 91 SWAP2 05A3 90 SWAP1 05A4 81 DUP2 05A5 81 DUP2 05A6 52 MSTORE 05A7 60 PUSH1 0x20 05A9 01 ADD 05AA 83 DUP4 05AB 83 DUP4 05AC 80 DUP1 05AD 82 DUP3 05AE 84 DUP5 05AF 37 CALLDATACOPY 05B0 60 PUSH1 0x00 05B2 92 SWAP3 05B3 01 ADD 05B4 91 SWAP2 05B5 90 SWAP1 05B6 91 SWAP2 05B7 52 MSTORE 05B8 50 POP 05B9 92 SWAP3 05BA 95 SWAP6 05BB 50 POP 05BC 61 PUSH2 0x1038 05BF 94 SWAP5 05C0 50 POP 05C1 50 POP 05C2 50 POP 05C3 50 POP 05C4 50 POP 05C5 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @059E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @05A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @05AF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @05B7 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @05BA stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1038 label_05C6: // Incoming jump from 0x0087, if 0x70a08231 == stack[-1] // Inputs[1] { @05CD msg.data.length } 05C6 5B JUMPDEST 05C7 61 PUSH2 0x027a 05CA 60 PUSH1 0x04 05CC 80 DUP1 05CD 36 CALLDATASIZE 05CE 03 SUB 05CF 60 PUSH1 0x20 05D1 81 DUP2 05D2 10 LT 05D3 15 ISZERO 05D4 61 PUSH2 0x05dc 05D7 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05C7 stack[0] = 0x027a // @05CA stack[1] = 0x04 // @05CE stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x05dc, if !(msg.data.length - 0x04 < 0x20) label_05D8: // Incoming jump from 0x05D7, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05DB memory[0x00:0x00] } 05D8 60 PUSH1 0x00 05DA 80 DUP1 05DB FD *REVERT // Stack delta = +0 // Outputs[1] { @05DB revert(memory[0x00:0x00]); } // Block terminates label_05DC: // Incoming jump from 0x05D7, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @05DE stack[-2] // @05DE msg.data[stack[-2]:stack[-2] + 0x20] // } 05DC 5B JUMPDEST 05DD 50 POP 05DE 35 CALLDATALOAD 05DF 60 PUSH1 0x01 05E1 60 PUSH1 0x01 05E3 60 PUSH1 0xa0 05E5 1B SHL 05E6 03 SUB 05E7 16 AND 05E8 61 PUSH2 0x109b 05EB 56 *JUMP // Stack delta = -1 // Outputs[1] { @05E7 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x109b label_05EC: // Incoming jump from 0x0092, if 0x959b8c3f == stack[-1] // Inputs[1] { @05F3 msg.data.length } 05EC 5B JUMPDEST 05ED 61 PUSH2 0x044f 05F0 60 PUSH1 0x04 05F2 80 DUP1 05F3 36 CALLDATASIZE 05F4 03 SUB 05F5 60 PUSH1 0x20 05F7 81 DUP2 05F8 10 LT 05F9 15 ISZERO 05FA 61 PUSH2 0x0602 05FD 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05ED stack[0] = 0x044f // @05F0 stack[1] = 0x04 // @05F4 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0602, returns to 0x044F, if !(msg.data.length - 0x04 < 0x20) label_05FE: // Incoming jump from 0x05FD, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0601 memory[0x00:0x00] } 05FE 60 PUSH1 0x00 0600 80 DUP1 0601 FD *REVERT // Stack delta = +0 // Outputs[1] { @0601 revert(memory[0x00:0x00]); } // Block terminates label_0602: // Incoming call from 0x05FD, returns to 0x044F, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0604 msg.data[stack[-2]:stack[-2] + 0x20] // @0604 stack[-2] // } 0602 5B JUMPDEST 0603 50 POP 0604 35 CALLDATALOAD 0605 60 PUSH1 0x01 0607 60 PUSH1 0x01 0609 60 PUSH1 0xa0 060B 1B SHL 060C 03 SUB 060D 16 AND 060E 61 PUSH2 0x10da 0611 56 *JUMP // Stack delta = -1 // Outputs[1] { @060D stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x10da label_0612: // Incoming jump from 0x009D, if 0x95d89b41 == stack[-1] 0612 5B JUMPDEST 0613 61 PUSH2 0x01bd 0616 61 PUSH2 0x1226 0619 56 *JUMP // Stack delta = +1 // Outputs[1] { @0613 stack[0] = 0x01bd } // Block ends with call to 0x1226, returns to 0x01BD label_061A: // Incoming jump from 0x00A8, if 0x9bd9bbc6 == stack[-1] // Inputs[1] { @0621 msg.data.length } 061A 5B JUMPDEST 061B 61 PUSH2 0x044f 061E 60 PUSH1 0x04 0620 80 DUP1 0621 36 CALLDATASIZE 0622 03 SUB 0623 60 PUSH1 0x60 0625 81 DUP2 0626 10 LT 0627 15 ISZERO 0628 61 PUSH2 0x0630 062B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @061B stack[0] = 0x044f // @061E stack[1] = 0x04 // @0622 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0630, if !(msg.data.length - 0x04 < 0x60) label_062C: // Incoming jump from 0x062B, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @062F memory[0x00:0x00] } 062C 60 PUSH1 0x00 062E 80 DUP1 062F FD *REVERT // Stack delta = +0 // Outputs[1] { @062F revert(memory[0x00:0x00]); } // Block terminates label_0630: // Incoming jump from 0x062B, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0639 stack[-2] // @063A msg.data[stack[-2]:stack[-2] + 0x20] // @0641 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0642 stack[-1] // @064E msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 0630 5B JUMPDEST 0631 60 PUSH1 0x01 0633 60 PUSH1 0x01 0635 60 PUSH1 0xa0 0637 1B SHL 0638 03 SUB 0639 82 DUP3 063A 35 CALLDATALOAD 063B 16 AND 063C 91 SWAP2 063D 60 PUSH1 0x20 063F 81 DUP2 0640 01 ADD 0641 35 CALLDATALOAD 0642 91 SWAP2 0643 81 DUP2 0644 01 ADD 0645 90 SWAP1 0646 60 PUSH1 0x60 0648 81 DUP2 0649 01 ADD 064A 60 PUSH1 0x40 064C 82 DUP3 064D 01 ADD 064E 35 CALLDATALOAD 064F 60 PUSH1 0x01 0651 60 PUSH1 0x20 0653 1B SHL 0654 81 DUP2 0655 11 GT 0656 15 ISZERO 0657 61 PUSH2 0x065f 065A 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @063C stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0642 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0645 stack[0] = stack[-2] + stack[-1] // @0645 stack[1] = stack[-2] // @0649 stack[2] = stack[-2] + 0x60 // @064E stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x065f, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_065B: // Incoming jump from 0x065A, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @065E memory[0x00:0x00] } 065B 60 PUSH1 0x00 065D 80 DUP1 065E FD *REVERT // Stack delta = +0 // Outputs[1] { @065E revert(memory[0x00:0x00]); } // Block terminates label_065F: // Incoming jump from 0x065A, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0660 stack[-3] // @0661 stack[-1] // @0662 stack[-4] // } 065F 5B JUMPDEST 0660 82 DUP3 0661 01 ADD 0662 83 DUP4 0663 60 PUSH1 0x20 0665 82 DUP3 0666 01 ADD 0667 11 GT 0668 15 ISZERO 0669 61 PUSH2 0x0671 066C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0661 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0671, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_066D: // Incoming jump from 0x066C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0670 memory[0x00:0x00] } 066D 60 PUSH1 0x00 066F 80 DUP1 0670 FD *REVERT // Stack delta = +0 // Outputs[1] { @0670 revert(memory[0x00:0x00]); } // Block terminates label_0671: // Incoming jump from 0x066C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0672 stack[-1] // @0673 msg.data[stack[-1]:stack[-1] + 0x20] // @0678 stack[-2] // @0679 stack[-4] // } 0671 5B JUMPDEST 0672 80 DUP1 0673 35 CALLDATALOAD 0674 90 SWAP1 0675 60 PUSH1 0x20 0677 01 ADD 0678 91 SWAP2 0679 84 DUP5 067A 60 PUSH1 0x01 067C 83 DUP4 067D 02 MUL 067E 84 DUP5 067F 01 ADD 0680 11 GT 0681 60 PUSH1 0x01 0683 60 PUSH1 0x20 0685 1B SHL 0686 83 DUP4 0687 11 GT 0688 17 OR 0689 15 ISZERO 068A 61 PUSH2 0x0692 068D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0674 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0678 stack[0] = stack[-2] // @0678 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0692, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_068E: // Incoming jump from 0x068D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0691 memory[0x00:0x00] } 068E 60 PUSH1 0x00 0690 80 DUP1 0691 FD *REVERT // Stack delta = +0 // Outputs[1] { @0691 revert(memory[0x00:0x00]); } // Block terminates label_0692: // Incoming jump from 0x068D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0693 stack[-1] // @0693 stack[-3] // @0694 stack[-2] // @06A5 memory[0x40:0x60] // @06BC msg.data[stack[-3]:stack[-3] + stack[-2]] // @06C7 stack[-5] // @06CC stack[-4] // } 0692 5B JUMPDEST 0693 91 SWAP2 0694 90 SWAP1 0695 80 DUP1 0696 80 DUP1 0697 60 PUSH1 0x1f 0699 01 ADD 069A 60 PUSH1 0x20 069C 80 DUP1 069D 91 SWAP2 069E 04 DIV 069F 02 MUL 06A0 60 PUSH1 0x20 06A2 01 ADD 06A3 60 PUSH1 0x40 06A5 51 MLOAD 06A6 90 SWAP1 06A7 81 DUP2 06A8 01 ADD 06A9 60 PUSH1 0x40 06AB 52 MSTORE 06AC 80 DUP1 06AD 93 SWAP4 06AE 92 SWAP3 06AF 91 SWAP2 06B0 90 SWAP1 06B1 81 DUP2 06B2 81 DUP2 06B3 52 MSTORE 06B4 60 PUSH1 0x20 06B6 01 ADD 06B7 83 DUP4 06B8 83 DUP4 06B9 80 DUP1 06BA 82 DUP3 06BB 84 DUP5 06BC 37 CALLDATACOPY 06BD 60 PUSH1 0x00 06BF 92 SWAP3 06C0 01 ADD 06C1 91 SWAP2 06C2 90 SWAP1 06C3 91 SWAP2 06C4 52 MSTORE 06C5 50 POP 06C6 92 SWAP3 06C7 95 SWAP6 06C8 50 POP 06C9 61 PUSH2 0x1287 06CC 94 SWAP5 06CD 50 POP 06CE 50 POP 06CF 50 POP 06D0 50 POP 06D1 50 POP 06D2 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @06AB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @06B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @06BC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @06C4 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @06C7 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1287 label_06D3: // Incoming jump from 0x00B3, if 0xa9059cbb == stack[-1] // Inputs[1] { @06DA msg.data.length } 06D3 5B JUMPDEST 06D4 61 PUSH2 0x025e 06D7 60 PUSH1 0x04 06D9 80 DUP1 06DA 36 CALLDATASIZE 06DB 03 SUB 06DC 60 PUSH1 0x40 06DE 81 DUP2 06DF 10 LT 06E0 15 ISZERO 06E1 61 PUSH2 0x06e9 06E4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06D4 stack[0] = 0x025e // @06D7 stack[1] = 0x04 // @06DB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x06e9, if !(msg.data.length - 0x04 < 0x40) label_06E5: // Incoming jump from 0x06E4, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @06E8 memory[0x00:0x00] } 06E5 60 PUSH1 0x00 06E7 80 DUP1 06E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E8 revert(memory[0x00:0x00]); } // Block terminates label_06E9: // Incoming jump from 0x06E4, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @06F3 stack[-2] // @06F4 msg.data[stack[-2]:stack[-2] + 0x20] // @06FA msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 06E9 5B JUMPDEST 06EA 50 POP 06EB 60 PUSH1 0x01 06ED 60 PUSH1 0x01 06EF 60 PUSH1 0xa0 06F1 1B SHL 06F2 03 SUB 06F3 81 DUP2 06F4 35 CALLDATALOAD 06F5 16 AND 06F6 90 SWAP1 06F7 60 PUSH1 0x20 06F9 01 ADD 06FA 35 CALLDATALOAD 06FB 61 PUSH2 0x12b9 06FE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06F6 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @06FA stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x12b9 label_06FF: // Incoming jump from 0x00BE, if 0xca275931 == stack[-1] // Inputs[1] { @0706 msg.data.length } 06FF 5B JUMPDEST 0700 61 PUSH2 0x044f 0703 60 PUSH1 0x04 0705 80 DUP1 0706 36 CALLDATASIZE 0707 03 SUB 0708 60 PUSH1 0x60 070A 81 DUP2 070B 10 LT 070C 15 ISZERO 070D 61 PUSH2 0x0715 0710 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0700 stack[0] = 0x044f // @0703 stack[1] = 0x04 // @0707 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0715, if !(msg.data.length - 0x04 < 0x60) label_0711: // Incoming jump from 0x0710, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0714 memory[0x00:0x00] } 0711 60 PUSH1 0x00 0713 80 DUP1 0714 FD *REVERT // Stack delta = +0 // Outputs[1] { @0714 revert(memory[0x00:0x00]); } // Block terminates label_0715: // Incoming jump from 0x0710, if !(msg.data.length - 0x04 < 0x60) // Inputs[3] // { // @0716 stack[-2] // @0717 stack[-1] // @071E msg.data[stack[-2]:stack[-2] + 0x20] // } 0715 5B JUMPDEST 0716 81 DUP2 0717 01 ADD 0718 90 SWAP1 0719 60 PUSH1 0x20 071B 81 DUP2 071C 01 ADD 071D 81 DUP2 071E 35 CALLDATALOAD 071F 60 PUSH1 0x01 0721 60 PUSH1 0x20 0723 1B SHL 0724 81 DUP2 0725 11 GT 0726 15 ISZERO 0727 61 PUSH2 0x072f 072A 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0718 stack[-1] = stack[-2] // @0718 stack[-2] = stack[-2] + stack[-1] // @071C stack[0] = stack[-2] + 0x20 // @071E stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x072f, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_072B: // Incoming jump from 0x072A, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @072E memory[0x00:0x00] } 072B 60 PUSH1 0x00 072D 80 DUP1 072E FD *REVERT // Stack delta = +0 // Outputs[1] { @072E revert(memory[0x00:0x00]); } // Block terminates label_072F: // Incoming jump from 0x072A, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0730 stack[-3] // @0731 stack[-1] // @0732 stack[-4] // } 072F 5B JUMPDEST 0730 82 DUP3 0731 01 ADD 0732 83 DUP4 0733 60 PUSH1 0x20 0735 82 DUP3 0736 01 ADD 0737 11 GT 0738 15 ISZERO 0739 61 PUSH2 0x0741 073C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0731 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0741, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_073D: // Incoming jump from 0x073C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0740 memory[0x00:0x00] } 073D 60 PUSH1 0x00 073F 80 DUP1 0740 FD *REVERT // Stack delta = +0 // Outputs[1] { @0740 revert(memory[0x00:0x00]); } // Block terminates label_0741: // Incoming jump from 0x073C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0742 stack[-1] // @0743 msg.data[stack[-1]:stack[-1] + 0x20] // @0748 stack[-2] // @0749 stack[-4] // } 0741 5B JUMPDEST 0742 80 DUP1 0743 35 CALLDATALOAD 0744 90 SWAP1 0745 60 PUSH1 0x20 0747 01 ADD 0748 91 SWAP2 0749 84 DUP5 074A 60 PUSH1 0x01 074C 83 DUP4 074D 02 MUL 074E 84 DUP5 074F 01 ADD 0750 11 GT 0751 60 PUSH1 0x01 0753 60 PUSH1 0x20 0755 1B SHL 0756 83 DUP4 0757 11 GT 0758 17 OR 0759 15 ISZERO 075A 61 PUSH2 0x0762 075D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0744 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0748 stack[0] = stack[-2] // @0748 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0762, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_075E: // Incoming jump from 0x075D, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0761 memory[0x00:0x00] } 075E 60 PUSH1 0x00 0760 80 DUP1 0761 FD *REVERT // Stack delta = +0 // Outputs[1] { @0761 revert(memory[0x00:0x00]); } // Block terminates label_0762: // Incoming jump from 0x075D, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @0763 stack[-1] // @0763 stack[-3] // @0764 stack[-2] // @0775 memory[0x40:0x60] // @078C msg.data[stack[-3]:stack[-3] + stack[-2]] // @0797 stack[-5] // @0798 stack[-4] // @07A0 msg.data[stack[-1]:stack[-1] + 0x20] // } 0762 5B JUMPDEST 0763 91 SWAP2 0764 90 SWAP1 0765 80 DUP1 0766 80 DUP1 0767 60 PUSH1 0x1f 0769 01 ADD 076A 60 PUSH1 0x20 076C 80 DUP1 076D 91 SWAP2 076E 04 DIV 076F 02 MUL 0770 60 PUSH1 0x20 0772 01 ADD 0773 60 PUSH1 0x40 0775 51 MLOAD 0776 90 SWAP1 0777 81 DUP2 0778 01 ADD 0779 60 PUSH1 0x40 077B 52 MSTORE 077C 80 DUP1 077D 93 SWAP4 077E 92 SWAP3 077F 91 SWAP2 0780 90 SWAP1 0781 81 DUP2 0782 81 DUP2 0783 52 MSTORE 0784 60 PUSH1 0x20 0786 01 ADD 0787 83 DUP4 0788 83 DUP4 0789 80 DUP1 078A 82 DUP3 078B 84 DUP5 078C 37 CALLDATACOPY 078D 60 PUSH1 0x00 078F 92 SWAP3 0790 01 ADD 0791 91 SWAP2 0792 90 SWAP1 0793 91 SWAP2 0794 52 MSTORE 0795 50 POP 0796 92 SWAP3 0797 95 SWAP6 0798 94 SWAP5 0799 93 SWAP4 079A 60 PUSH1 0x20 079C 81 DUP2 079D 01 ADD 079E 93 SWAP4 079F 50 POP 07A0 35 CALLDATALOAD 07A1 91 SWAP2 07A2 50 POP 07A3 50 POP 07A4 60 PUSH1 0x01 07A6 60 PUSH1 0x20 07A8 1B SHL 07A9 81 DUP2 07AA 11 GT 07AB 15 ISZERO 07AC 61 PUSH2 0x07b4 07AF 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @077B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0783 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @078C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0794 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0797 stack[-5] = memory[0x40:0x60] // @0798 stack[-4] = stack[-5] // @0799 stack[-3] = stack[-4] // @079E stack[-2] = stack[-1] + 0x20 // @07A1 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x07b4, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_07B0: // Incoming jump from 0x07AF, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @07B3 memory[0x00:0x00] } 07B0 60 PUSH1 0x00 07B2 80 DUP1 07B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B3 revert(memory[0x00:0x00]); } // Block terminates label_07B4: // Incoming jump from 0x07AF, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @07B5 stack[-3] // @07B6 stack[-1] // @07B7 stack[-4] // } 07B4 5B JUMPDEST 07B5 82 DUP3 07B6 01 ADD 07B7 83 DUP4 07B8 60 PUSH1 0x20 07BA 82 DUP3 07BB 01 ADD 07BC 11 GT 07BD 15 ISZERO 07BE 61 PUSH2 0x07c6 07C1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07B6 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x07c6, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_07C2: // Incoming jump from 0x07C1, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @07C5 memory[0x00:0x00] } 07C2 60 PUSH1 0x00 07C4 80 DUP1 07C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @07C5 revert(memory[0x00:0x00]); } // Block terminates label_07C6: // Incoming jump from 0x07C1, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @07C7 stack[-1] // @07C8 msg.data[stack[-1]:stack[-1] + 0x20] // @07CD stack[-2] // @07CE stack[-4] // } 07C6 5B JUMPDEST 07C7 80 DUP1 07C8 35 CALLDATALOAD 07C9 90 SWAP1 07CA 60 PUSH1 0x20 07CC 01 ADD 07CD 91 SWAP2 07CE 84 DUP5 07CF 60 PUSH1 0x01 07D1 83 DUP4 07D2 02 MUL 07D3 84 DUP5 07D4 01 ADD 07D5 11 GT 07D6 60 PUSH1 0x01 07D8 60 PUSH1 0x20 07DA 1B SHL 07DB 83 DUP4 07DC 11 GT 07DD 17 OR 07DE 15 ISZERO 07DF 61 PUSH2 0x07e7 07E2 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @07C9 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @07CD stack[0] = stack[-2] // @07CD stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x07e7, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_07E3: // Incoming jump from 0x07E2, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @07E6 memory[0x00:0x00] } 07E3 60 PUSH1 0x00 07E5 80 DUP1 07E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @07E6 revert(memory[0x00:0x00]); } // Block terminates label_07E7: // Incoming jump from 0x07E2, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @07E8 stack[-1] // @07E8 stack[-3] // @07E9 stack[-2] // @07FA memory[0x40:0x60] // @0811 msg.data[stack[-3]:stack[-3] + stack[-2]] // @081C stack[-5] // @081D stack[-4] // @0825 msg.data[stack[-1]:stack[-1] + 0x20] // } 07E7 5B JUMPDEST 07E8 91 SWAP2 07E9 90 SWAP1 07EA 80 DUP1 07EB 80 DUP1 07EC 60 PUSH1 0x1f 07EE 01 ADD 07EF 60 PUSH1 0x20 07F1 80 DUP1 07F2 91 SWAP2 07F3 04 DIV 07F4 02 MUL 07F5 60 PUSH1 0x20 07F7 01 ADD 07F8 60 PUSH1 0x40 07FA 51 MLOAD 07FB 90 SWAP1 07FC 81 DUP2 07FD 01 ADD 07FE 60 PUSH1 0x40 0800 52 MSTORE 0801 80 DUP1 0802 93 SWAP4 0803 92 SWAP3 0804 91 SWAP2 0805 90 SWAP1 0806 81 DUP2 0807 81 DUP2 0808 52 MSTORE 0809 60 PUSH1 0x20 080B 01 ADD 080C 83 DUP4 080D 83 DUP4 080E 80 DUP1 080F 82 DUP3 0810 84 DUP5 0811 37 CALLDATACOPY 0812 60 PUSH1 0x00 0814 92 SWAP3 0815 01 ADD 0816 91 SWAP2 0817 90 SWAP1 0818 91 SWAP2 0819 52 MSTORE 081A 50 POP 081B 92 SWAP3 081C 95 SWAP6 081D 94 SWAP5 081E 93 SWAP4 081F 60 PUSH1 0x20 0821 81 DUP2 0822 01 ADD 0823 93 SWAP4 0824 50 POP 0825 35 CALLDATALOAD 0826 91 SWAP2 0827 50 POP 0828 50 POP 0829 60 PUSH1 0x01 082B 60 PUSH1 0x20 082D 1B SHL 082E 81 DUP2 082F 11 GT 0830 15 ISZERO 0831 61 PUSH2 0x0839 0834 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0800 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0808 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0811 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0819 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @081C stack[-5] = memory[0x40:0x60] // @081D stack[-4] = stack[-5] // @081E stack[-3] = stack[-4] // @0823 stack[-2] = stack[-1] + 0x20 // @0826 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0839, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0835: // Incoming jump from 0x0834, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0838 memory[0x00:0x00] } 0835 60 PUSH1 0x00 0837 80 DUP1 0838 FD *REVERT // Stack delta = +0 // Outputs[1] { @0838 revert(memory[0x00:0x00]); } // Block terminates label_0839: // Incoming jump from 0x0834, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @083A stack[-3] // @083B stack[-1] // @083C stack[-4] // } 0839 5B JUMPDEST 083A 82 DUP3 083B 01 ADD 083C 83 DUP4 083D 60 PUSH1 0x20 083F 82 DUP3 0840 01 ADD 0841 11 GT 0842 15 ISZERO 0843 61 PUSH2 0x084b 0846 57 *JUMPI // Stack delta = +0 // Outputs[1] { @083B stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x084b, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0847: // Incoming jump from 0x0846, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @084A memory[0x00:0x00] } 0847 60 PUSH1 0x00 0849 80 DUP1 084A FD *REVERT // Stack delta = +0 // Outputs[1] { @084A revert(memory[0x00:0x00]); } // Block terminates label_084B: // Incoming jump from 0x0846, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @084C stack[-1] // @084D msg.data[stack[-1]:stack[-1] + 0x20] // @0852 stack[-2] // @0853 stack[-4] // } 084B 5B JUMPDEST 084C 80 DUP1 084D 35 CALLDATALOAD 084E 90 SWAP1 084F 60 PUSH1 0x20 0851 01 ADD 0852 91 SWAP2 0853 84 DUP5 0854 60 PUSH1 0x20 0856 83 DUP4 0857 02 MUL 0858 84 DUP5 0859 01 ADD 085A 11 GT 085B 60 PUSH1 0x01 085D 60 PUSH1 0x20 085F 1B SHL 0860 83 DUP4 0861 11 GT 0862 17 OR 0863 15 ISZERO 0864 61 PUSH2 0x086c 0867 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @084E stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0852 stack[0] = stack[-2] // @0852 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x086c, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0868: // Incoming jump from 0x0867, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @086B memory[0x00:0x00] } 0868 60 PUSH1 0x00 086A 80 DUP1 086B FD *REVERT // Stack delta = +0 // Outputs[1] { @086B revert(memory[0x00:0x00]); } // Block terminates label_086C: // Incoming jump from 0x0867, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @086D stack[-1] // @086D stack[-3] // @086E stack[-2] // @0879 memory[0x40:0x60] // @0893 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @089E stack[-5] // @08A3 stack[-4] // } 086C 5B JUMPDEST 086D 91 SWAP2 086E 90 SWAP1 086F 80 DUP1 0870 80 DUP1 0871 60 PUSH1 0x20 0873 02 MUL 0874 60 PUSH1 0x20 0876 01 ADD 0877 60 PUSH1 0x40 0879 51 MLOAD 087A 90 SWAP1 087B 81 DUP2 087C 01 ADD 087D 60 PUSH1 0x40 087F 52 MSTORE 0880 80 DUP1 0881 93 SWAP4 0882 92 SWAP3 0883 91 SWAP2 0884 90 SWAP1 0885 81 DUP2 0886 81 DUP2 0887 52 MSTORE 0888 60 PUSH1 0x20 088A 01 ADD 088B 83 DUP4 088C 83 DUP4 088D 60 PUSH1 0x20 088F 02 MUL 0890 80 DUP1 0891 82 DUP3 0892 84 DUP5 0893 37 CALLDATACOPY 0894 60 PUSH1 0x00 0896 92 SWAP3 0897 01 ADD 0898 91 SWAP2 0899 90 SWAP1 089A 91 SWAP2 089B 52 MSTORE 089C 50 POP 089D 92 SWAP3 089E 95 SWAP6 089F 50 POP 08A0 61 PUSH2 0x1392 08A3 94 SWAP5 08A4 50 POP 08A5 50 POP 08A6 50 POP 08A7 50 POP 08A8 50 POP 08A9 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @087F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0887 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0893 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @089B memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @089E stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1392 label_08AA: // Incoming jump from 0x0040, if 0xd95b6371 == stack[-1] // Inputs[1] { @08B1 msg.data.length } 08AA 5B JUMPDEST 08AB 61 PUSH2 0x025e 08AE 60 PUSH1 0x04 08B0 80 DUP1 08B1 36 CALLDATASIZE 08B2 03 SUB 08B3 60 PUSH1 0x40 08B5 81 DUP2 08B6 10 LT 08B7 15 ISZERO 08B8 61 PUSH2 0x08c0 08BB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08AB stack[0] = 0x025e // @08AE stack[1] = 0x04 // @08B2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08c0, returns to 0x025E, if !(msg.data.length - 0x04 < 0x40) label_08BC: // Incoming jump from 0x08BB, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @08BF memory[0x00:0x00] } 08BC 60 PUSH1 0x00 08BE 80 DUP1 08BF FD *REVERT // Stack delta = +0 // Outputs[1] { @08BF revert(memory[0x00:0x00]); } // Block terminates label_08C0: // Incoming call from 0x08BB, returns to 0x025E, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @08CA stack[-2] // @08CB msg.data[stack[-2]:stack[-2] + 0x20] // @08D2 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 08C0 5B JUMPDEST 08C1 50 POP 08C2 60 PUSH1 0x01 08C4 60 PUSH1 0x01 08C6 60 PUSH1 0xa0 08C8 1B SHL 08C9 03 SUB 08CA 81 DUP2 08CB 35 CALLDATALOAD 08CC 81 DUP2 08CD 16 AND 08CE 91 SWAP2 08CF 60 PUSH1 0x20 08D1 01 ADD 08D2 35 CALLDATALOAD 08D3 16 AND 08D4 61 PUSH2 0x15f9 08D7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08CE stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @08D3 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x15f9 label_08D8: // Incoming jump from 0x004B, if 0xdd62ed3e == stack[-1] // Inputs[1] { @08DF msg.data.length } 08D8 5B JUMPDEST 08D9 61 PUSH2 0x027a 08DC 60 PUSH1 0x04 08DE 80 DUP1 08DF 36 CALLDATASIZE 08E0 03 SUB 08E1 60 PUSH1 0x40 08E3 81 DUP2 08E4 10 LT 08E5 15 ISZERO 08E6 61 PUSH2 0x08ee 08E9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08D9 stack[0] = 0x027a // @08DC stack[1] = 0x04 // @08E0 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08ee, returns to 0x027A, if !(msg.data.length - 0x04 < 0x40) label_08EA: // Incoming jump from 0x08E9, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @08ED memory[0x00:0x00] } 08EA 60 PUSH1 0x00 08EC 80 DUP1 08ED FD *REVERT // Stack delta = +0 // Outputs[1] { @08ED revert(memory[0x00:0x00]); } // Block terminates label_08EE: // Incoming call from 0x08E9, returns to 0x027A, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @08F8 stack[-2] // @08F9 msg.data[stack[-2]:stack[-2] + 0x20] // @0900 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 08EE 5B JUMPDEST 08EF 50 POP 08F0 60 PUSH1 0x01 08F2 60 PUSH1 0x01 08F4 60 PUSH1 0xa0 08F6 1B SHL 08F7 03 SUB 08F8 81 DUP2 08F9 35 CALLDATALOAD 08FA 81 DUP2 08FB 16 AND 08FC 91 SWAP2 08FD 60 PUSH1 0x20 08FF 01 ADD 0900 35 CALLDATALOAD 0901 16 AND 0902 61 PUSH2 0x169b 0905 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @08FC stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0901 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x169b label_0906: // Incoming jump from 0x0056, if 0xfad8b32a == stack[-1] // Inputs[1] { @090D msg.data.length } 0906 5B JUMPDEST 0907 61 PUSH2 0x044f 090A 60 PUSH1 0x04 090C 80 DUP1 090D 36 CALLDATASIZE 090E 03 SUB 090F 60 PUSH1 0x20 0911 81 DUP2 0912 10 LT 0913 15 ISZERO 0914 61 PUSH2 0x091c 0917 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0907 stack[0] = 0x044f // @090A stack[1] = 0x04 // @090E stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x091c, returns to 0x044F, if !(msg.data.length - 0x04 < 0x20) label_0918: // Incoming jump from 0x0917, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @091B memory[0x00:0x00] } 0918 60 PUSH1 0x00 091A 80 DUP1 091B FD *REVERT // Stack delta = +0 // Outputs[1] { @091B revert(memory[0x00:0x00]); } // Block terminates label_091C: // Incoming call from 0x0917, returns to 0x044F, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @091E msg.data[stack[-2]:stack[-2] + 0x20] // @091E stack[-2] // } 091C 5B JUMPDEST 091D 50 POP 091E 35 CALLDATALOAD 091F 60 PUSH1 0x01 0921 60 PUSH1 0x01 0923 60 PUSH1 0xa0 0925 1B SHL 0926 03 SUB 0927 16 AND 0928 61 PUSH2 0x16c6 092B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0927 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x16c6 label_092C: // Incoming jump from 0x0061, if 0xfc673c4f == stack[-1] // Inputs[1] { @0933 msg.data.length } 092C 5B JUMPDEST 092D 61 PUSH2 0x044f 0930 60 PUSH1 0x04 0932 80 DUP1 0933 36 CALLDATASIZE 0934 03 SUB 0935 60 PUSH1 0x80 0937 81 DUP2 0938 10 LT 0939 15 ISZERO 093A 61 PUSH2 0x0942 093D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @092D stack[0] = 0x044f // @0930 stack[1] = 0x04 // @0934 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0942, if !(msg.data.length - 0x04 < 0x80) label_093E: // Incoming jump from 0x093D, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0941 memory[0x00:0x00] } 093E 60 PUSH1 0x00 0940 80 DUP1 0941 FD *REVERT // Stack delta = +0 // Outputs[1] { @0941 revert(memory[0x00:0x00]); } // Block terminates label_0942: // Incoming jump from 0x093D, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @094B stack[-2] // @094C msg.data[stack[-2]:stack[-2] + 0x20] // @0953 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0954 stack[-1] // @0960 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 0942 5B JUMPDEST 0943 60 PUSH1 0x01 0945 60 PUSH1 0x01 0947 60 PUSH1 0xa0 0949 1B SHL 094A 03 SUB 094B 82 DUP3 094C 35 CALLDATALOAD 094D 16 AND 094E 91 SWAP2 094F 60 PUSH1 0x20 0951 81 DUP2 0952 01 ADD 0953 35 CALLDATALOAD 0954 91 SWAP2 0955 81 DUP2 0956 01 ADD 0957 90 SWAP1 0958 60 PUSH1 0x60 095A 81 DUP2 095B 01 ADD 095C 60 PUSH1 0x40 095E 82 DUP3 095F 01 ADD 0960 35 CALLDATALOAD 0961 60 PUSH1 0x01 0963 60 PUSH1 0x20 0965 1B SHL 0966 81 DUP2 0967 11 GT 0968 15 ISZERO 0969 61 PUSH2 0x0971 096C 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @094E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0954 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0957 stack[0] = stack[-2] + stack[-1] // @0957 stack[1] = stack[-2] // @095B stack[2] = stack[-2] + 0x60 // @0960 stack[3] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x0971, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) label_096D: // Incoming jump from 0x096C, if not !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0970 memory[0x00:0x00] } 096D 60 PUSH1 0x00 096F 80 DUP1 0970 FD *REVERT // Stack delta = +0 // Outputs[1] { @0970 revert(memory[0x00:0x00]); } // Block terminates label_0971: // Incoming jump from 0x096C, if !(msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0972 stack[-3] // @0973 stack[-1] // @0974 stack[-4] // } 0971 5B JUMPDEST 0972 82 DUP3 0973 01 ADD 0974 83 DUP4 0975 60 PUSH1 0x20 0977 82 DUP3 0978 01 ADD 0979 11 GT 097A 15 ISZERO 097B 61 PUSH2 0x0983 097E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0973 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0983, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_097F: // Incoming jump from 0x097E, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0982 memory[0x00:0x00] } 097F 60 PUSH1 0x00 0981 80 DUP1 0982 FD *REVERT // Stack delta = +0 // Outputs[1] { @0982 revert(memory[0x00:0x00]); } // Block terminates label_0983: // Incoming jump from 0x097E, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0984 stack[-1] // @0985 msg.data[stack[-1]:stack[-1] + 0x20] // @098A stack[-2] // @098B stack[-4] // } 0983 5B JUMPDEST 0984 80 DUP1 0985 35 CALLDATALOAD 0986 90 SWAP1 0987 60 PUSH1 0x20 0989 01 ADD 098A 91 SWAP2 098B 84 DUP5 098C 60 PUSH1 0x01 098E 83 DUP4 098F 02 MUL 0990 84 DUP5 0991 01 ADD 0992 11 GT 0993 60 PUSH1 0x01 0995 60 PUSH1 0x20 0997 1B SHL 0998 83 DUP4 0999 11 GT 099A 17 OR 099B 15 ISZERO 099C 61 PUSH2 0x09a4 099F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0986 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @098A stack[0] = stack[-2] // @098A stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x09a4, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_09A0: // Incoming jump from 0x099F, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @09A3 memory[0x00:0x00] } 09A0 60 PUSH1 0x00 09A2 80 DUP1 09A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @09A3 revert(memory[0x00:0x00]); } // Block terminates label_09A4: // Incoming jump from 0x099F, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @09A5 stack[-1] // @09A5 stack[-3] // @09A6 stack[-2] // @09B7 memory[0x40:0x60] // @09CE msg.data[stack[-3]:stack[-3] + stack[-2]] // @09D9 stack[-5] // @09DA stack[-4] // @09E2 msg.data[stack[-1]:stack[-1] + 0x20] // } 09A4 5B JUMPDEST 09A5 91 SWAP2 09A6 90 SWAP1 09A7 80 DUP1 09A8 80 DUP1 09A9 60 PUSH1 0x1f 09AB 01 ADD 09AC 60 PUSH1 0x20 09AE 80 DUP1 09AF 91 SWAP2 09B0 04 DIV 09B1 02 MUL 09B2 60 PUSH1 0x20 09B4 01 ADD 09B5 60 PUSH1 0x40 09B7 51 MLOAD 09B8 90 SWAP1 09B9 81 DUP2 09BA 01 ADD 09BB 60 PUSH1 0x40 09BD 52 MSTORE 09BE 80 DUP1 09BF 93 SWAP4 09C0 92 SWAP3 09C1 91 SWAP2 09C2 90 SWAP1 09C3 81 DUP2 09C4 81 DUP2 09C5 52 MSTORE 09C6 60 PUSH1 0x20 09C8 01 ADD 09C9 83 DUP4 09CA 83 DUP4 09CB 80 DUP1 09CC 82 DUP3 09CD 84 DUP5 09CE 37 CALLDATACOPY 09CF 60 PUSH1 0x00 09D1 92 SWAP3 09D2 01 ADD 09D3 91 SWAP2 09D4 90 SWAP1 09D5 91 SWAP2 09D6 52 MSTORE 09D7 50 POP 09D8 92 SWAP3 09D9 95 SWAP6 09DA 94 SWAP5 09DB 93 SWAP4 09DC 60 PUSH1 0x20 09DE 81 DUP2 09DF 01 ADD 09E0 93 SWAP4 09E1 50 POP 09E2 35 CALLDATALOAD 09E3 91 SWAP2 09E4 50 POP 09E5 50 POP 09E6 60 PUSH1 0x01 09E8 60 PUSH1 0x20 09EA 1B SHL 09EB 81 DUP2 09EC 11 GT 09ED 15 ISZERO 09EE 61 PUSH2 0x09f6 09F1 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @09BD memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @09C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @09CE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @09D6 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @09D9 stack[-5] = memory[0x40:0x60] // @09DA stack[-4] = stack[-5] // @09DB stack[-3] = stack[-4] // @09E0 stack[-2] = stack[-1] + 0x20 // @09E3 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x09f6, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_09F2: // Incoming jump from 0x09F1, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @09F5 memory[0x00:0x00] } 09F2 60 PUSH1 0x00 09F4 80 DUP1 09F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @09F5 revert(memory[0x00:0x00]); } // Block terminates label_09F6: // Incoming jump from 0x09F1, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @09F7 stack[-3] // @09F8 stack[-1] // @09F9 stack[-4] // } 09F6 5B JUMPDEST 09F7 82 DUP3 09F8 01 ADD 09F9 83 DUP4 09FA 60 PUSH1 0x20 09FC 82 DUP3 09FD 01 ADD 09FE 11 GT 09FF 15 ISZERO 0A00 61 PUSH2 0x0a08 0A03 57 *JUMPI // Stack delta = +0 // Outputs[1] { @09F8 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0a08, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0A04: // Incoming jump from 0x0A03, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0A07 memory[0x00:0x00] } 0A04 60 PUSH1 0x00 0A06 80 DUP1 0A07 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A07 revert(memory[0x00:0x00]); } // Block terminates label_0A08: // Incoming jump from 0x0A03, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0A09 stack[-1] // @0A0A msg.data[stack[-1]:stack[-1] + 0x20] // @0A0F stack[-2] // @0A10 stack[-4] // } 0A08 5B JUMPDEST 0A09 80 DUP1 0A0A 35 CALLDATALOAD 0A0B 90 SWAP1 0A0C 60 PUSH1 0x20 0A0E 01 ADD 0A0F 91 SWAP2 0A10 84 DUP5 0A11 60 PUSH1 0x01 0A13 83 DUP4 0A14 02 MUL 0A15 84 DUP5 0A16 01 ADD 0A17 11 GT 0A18 60 PUSH1 0x01 0A1A 60 PUSH1 0x20 0A1C 1B SHL 0A1D 83 DUP4 0A1E 11 GT 0A1F 17 OR 0A20 15 ISZERO 0A21 61 PUSH2 0x0a29 0A24 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0A0B stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0A0F stack[0] = stack[-2] // @0A0F stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0a29, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0A25: // Incoming jump from 0x0A24, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0A28 memory[0x00:0x00] } 0A25 60 PUSH1 0x00 0A27 80 DUP1 0A28 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A28 revert(memory[0x00:0x00]); } // Block terminates label_0A29: // Incoming jump from 0x0A24, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0A2A stack[-1] // @0A2A stack[-3] // @0A2B stack[-2] // @0A3C memory[0x40:0x60] // @0A53 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0A5E stack[-5] // @0A63 stack[-4] // } 0A29 5B JUMPDEST 0A2A 91 SWAP2 0A2B 90 SWAP1 0A2C 80 DUP1 0A2D 80 DUP1 0A2E 60 PUSH1 0x1f 0A30 01 ADD 0A31 60 PUSH1 0x20 0A33 80 DUP1 0A34 91 SWAP2 0A35 04 DIV 0A36 02 MUL 0A37 60 PUSH1 0x20 0A39 01 ADD 0A3A 60 PUSH1 0x40 0A3C 51 MLOAD 0A3D 90 SWAP1 0A3E 81 DUP2 0A3F 01 ADD 0A40 60 PUSH1 0x40 0A42 52 MSTORE 0A43 80 DUP1 0A44 93 SWAP4 0A45 92 SWAP3 0A46 91 SWAP2 0A47 90 SWAP1 0A48 81 DUP2 0A49 81 DUP2 0A4A 52 MSTORE 0A4B 60 PUSH1 0x20 0A4D 01 ADD 0A4E 83 DUP4 0A4F 83 DUP4 0A50 80 DUP1 0A51 82 DUP3 0A52 84 DUP5 0A53 37 CALLDATACOPY 0A54 60 PUSH1 0x00 0A56 92 SWAP3 0A57 01 ADD 0A58 91 SWAP2 0A59 90 SWAP1 0A5A 91 SWAP2 0A5B 52 MSTORE 0A5C 50 POP 0A5D 92 SWAP3 0A5E 95 SWAP6 0A5F 50 POP 0A60 61 PUSH2 0x1812 0A63 94 SWAP5 0A64 50 POP 0A65 50 POP 0A66 50 POP 0A67 50 POP 0A68 50 POP 0A69 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0A42 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0A4A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0A53 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0A5B memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0A5E stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1812 label_0A6A: // Incoming jump from 0x006C, if 0xfe9d9303 == stack[-1] // Inputs[1] { @0A71 msg.data.length } 0A6A 5B JUMPDEST 0A6B 61 PUSH2 0x044f 0A6E 60 PUSH1 0x04 0A70 80 DUP1 0A71 36 CALLDATASIZE 0A72 03 SUB 0A73 60 PUSH1 0x40 0A75 81 DUP2 0A76 10 LT 0A77 15 ISZERO 0A78 61 PUSH2 0x0a80 0A7B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A6B stack[0] = 0x044f // @0A6E stack[1] = 0x04 // @0A72 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0a80, if !(msg.data.length - 0x04 < 0x40) label_0A7C: // Incoming jump from 0x0A7B, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0A7F memory[0x00:0x00] } 0A7C 60 PUSH1 0x00 0A7E 80 DUP1 0A7F FD *REVERT // Stack delta = +0 // Outputs[1] { @0A7F revert(memory[0x00:0x00]); } // Block terminates label_0A80: // Incoming jump from 0x0A7B, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0A81 stack[-2] // @0A82 msg.data[stack[-2]:stack[-2] + 0x20] // @0A84 stack[-1] // @0A90 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 0A80 5B JUMPDEST 0A81 81 DUP2 0A82 35 CALLDATALOAD 0A83 91 SWAP2 0A84 90 SWAP1 0A85 81 DUP2 0A86 01 ADD 0A87 90 SWAP1 0A88 60 PUSH1 0x40 0A8A 81 DUP2 0A8B 01 ADD 0A8C 60 PUSH1 0x20 0A8E 82 DUP3 0A8F 01 ADD 0A90 35 CALLDATALOAD 0A91 60 PUSH1 0x01 0A93 60 PUSH1 0x20 0A95 1B SHL 0A96 81 DUP2 0A97 11 GT 0A98 15 ISZERO 0A99 61 PUSH2 0x0aa1 0A9C 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0A83 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0A87 stack[0] = stack[-2] // @0A87 stack[-1] = stack[-2] + stack[-1] // @0A8B stack[1] = stack[-2] + 0x40 // @0A90 stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x0aa1, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) label_0A9D: // Incoming jump from 0x0A9C, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[1] { @0AA0 memory[0x00:0x00] } 0A9D 60 PUSH1 0x00 0A9F 80 DUP1 0AA0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AA0 revert(memory[0x00:0x00]); } // Block terminates label_0AA1: // Incoming jump from 0x0A9C, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0AA2 stack[-3] // @0AA3 stack[-1] // @0AA4 stack[-4] // } 0AA1 5B JUMPDEST 0AA2 82 DUP3 0AA3 01 ADD 0AA4 83 DUP4 0AA5 60 PUSH1 0x20 0AA7 82 DUP3 0AA8 01 ADD 0AA9 11 GT 0AAA 15 ISZERO 0AAB 61 PUSH2 0x0ab3 0AAE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0AA3 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0ab3, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0AAF: // Incoming jump from 0x0AAE, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0AB2 memory[0x00:0x00] } 0AAF 60 PUSH1 0x00 0AB1 80 DUP1 0AB2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AB2 revert(memory[0x00:0x00]); } // Block terminates label_0AB3: // Incoming jump from 0x0AAE, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0AB4 stack[-1] // @0AB5 msg.data[stack[-1]:stack[-1] + 0x20] // @0ABA stack[-2] // @0ABB stack[-4] // } 0AB3 5B JUMPDEST 0AB4 80 DUP1 0AB5 35 CALLDATALOAD 0AB6 90 SWAP1 0AB7 60 PUSH1 0x20 0AB9 01 ADD 0ABA 91 SWAP2 0ABB 84 DUP5 0ABC 60 PUSH1 0x01 0ABE 83 DUP4 0ABF 02 MUL 0AC0 84 DUP5 0AC1 01 ADD 0AC2 11 GT 0AC3 60 PUSH1 0x01 0AC5 60 PUSH1 0x20 0AC7 1B SHL 0AC8 83 DUP4 0AC9 11 GT 0ACA 17 OR 0ACB 15 ISZERO 0ACC 61 PUSH2 0x0ad4 0ACF 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0AB6 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0ABA stack[0] = stack[-2] // @0ABA stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0ad4, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0AD0: // Incoming jump from 0x0ACF, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0AD3 memory[0x00:0x00] } 0AD0 60 PUSH1 0x00 0AD2 80 DUP1 0AD3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AD3 revert(memory[0x00:0x00]); } // Block terminates label_0AD4: // Incoming jump from 0x0ACF, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0AD5 stack[-3] // @0AD5 stack[-1] // @0AD6 stack[-2] // @0AE7 memory[0x40:0x60] // @0AFE msg.data[stack[-3]:stack[-3] + stack[-2]] // @0B09 stack[-5] // @0B0E stack[-4] // } 0AD4 5B JUMPDEST 0AD5 91 SWAP2 0AD6 90 SWAP1 0AD7 80 DUP1 0AD8 80 DUP1 0AD9 60 PUSH1 0x1f 0ADB 01 ADD 0ADC 60 PUSH1 0x20 0ADE 80 DUP1 0ADF 91 SWAP2 0AE0 04 DIV 0AE1 02 MUL 0AE2 60 PUSH1 0x20 0AE4 01 ADD 0AE5 60 PUSH1 0x40 0AE7 51 MLOAD 0AE8 90 SWAP1 0AE9 81 DUP2 0AEA 01 ADD 0AEB 60 PUSH1 0x40 0AED 52 MSTORE 0AEE 80 DUP1 0AEF 93 SWAP4 0AF0 92 SWAP3 0AF1 91 SWAP2 0AF2 90 SWAP1 0AF3 81 DUP2 0AF4 81 DUP2 0AF5 52 MSTORE 0AF6 60 PUSH1 0x20 0AF8 01 ADD 0AF9 83 DUP4 0AFA 83 DUP4 0AFB 80 DUP1 0AFC 82 DUP3 0AFD 84 DUP5 0AFE 37 CALLDATACOPY 0AFF 60 PUSH1 0x00 0B01 92 SWAP3 0B02 01 ADD 0B03 91 SWAP2 0B04 90 SWAP1 0B05 91 SWAP2 0B06 52 MSTORE 0B07 50 POP 0B08 92 SWAP3 0B09 95 SWAP6 0B0A 50 POP 0B0B 61 PUSH2 0x1872 0B0E 94 SWAP5 0B0F 50 POP 0B10 50 POP 0B11 50 POP 0B12 50 POP 0B13 50 POP 0B14 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0AED memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0AF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0AFE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0B06 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0B09 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1872 label_0B15: // Incoming jump from 0x0077, if 0xff0b9c90 == stack[-1] 0B15 5B JUMPDEST 0B16 61 PUSH2 0x027a 0B19 61 PUSH2 0x18a0 0B1C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B16 stack[0] = 0x027a } // Block ends with call to 0x18a0, returns to 0x027A label_0B1D: // Incoming call from 0x0164, returns to 0x0165 // Inputs[3] // { // @0B23 storage[0x37] // @0B2D memory[0x40:0x60] // @0B40 storage[0x37] // } 0B1D 5B JUMPDEST 0B1E 60 PUSH1 0x60 0B20 60 PUSH1 0x37 0B22 80 DUP1 0B23 54 SLOAD 0B24 80 DUP1 0B25 60 PUSH1 0x20 0B27 02 MUL 0B28 60 PUSH1 0x20 0B2A 01 ADD 0B2B 60 PUSH1 0x40 0B2D 51 MLOAD 0B2E 90 SWAP1 0B2F 81 DUP2 0B30 01 ADD 0B31 60 PUSH1 0x40 0B33 52 MSTORE 0B34 80 DUP1 0B35 92 SWAP3 0B36 91 SWAP2 0B37 90 SWAP1 0B38 81 DUP2 0B39 81 DUP2 0B3A 52 MSTORE 0B3B 60 PUSH1 0x20 0B3D 01 ADD 0B3E 82 DUP3 0B3F 80 DUP1 0B40 54 SLOAD 0B41 80 DUP1 0B42 15 ISZERO 0B43 61 PUSH2 0x0b75 0B46 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0B1E stack[0] = 0x60 // @0B33 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * storage[0x37] // @0B35 stack[1] = memory[0x40:0x60] // @0B36 stack[2] = 0x37 // @0B37 stack[3] = storage[0x37] // @0B3A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x37] // @0B3D stack[4] = 0x20 + memory[0x40:0x60] // @0B3E stack[5] = 0x37 // @0B40 stack[6] = storage[0x37] // } // Block ends with conditional jump to 0x0b75, if !storage[0x37] label_0B47: // Incoming jump from 0x0B46, if not !storage[0x37] // Inputs[5] // { // @0B49 stack[-1] // @0B4A stack[-3] // @0B4D stack[-2] // @0B55 memory[0x00:0x20] // @0B59 storage[keccak256(memory[0x00:0x20])] // } 0B47 60 PUSH1 0x20 0B49 02 MUL 0B4A 82 DUP3 0B4B 01 ADD 0B4C 91 SWAP2 0B4D 90 SWAP1 0B4E 60 PUSH1 0x00 0B50 52 MSTORE 0B51 60 PUSH1 0x20 0B53 60 PUSH1 0x00 0B55 20 SHA3 0B56 90 SWAP1 0B57 5B JUMPDEST 0B58 81 DUP2 0B59 54 SLOAD 0B5A 60 PUSH1 0x01 0B5C 60 PUSH1 0x01 0B5E 60 PUSH1 0xa0 0B60 1B SHL 0B61 03 SUB 0B62 16 AND 0B63 81 DUP2 0B64 52 MSTORE 0B65 60 PUSH1 0x01 0B67 90 SWAP1 0B68 91 SWAP2 0B69 01 ADD 0B6A 90 SWAP1 0B6B 60 PUSH1 0x20 0B6D 01 ADD 0B6E 80 DUP1 0B6F 83 DUP4 0B70 11 GT 0B71 61 PUSH2 0x0b57 0B74 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0B4C stack[-3] = stack[-3] + 0x20 * stack[-1] // @0B50 memory[0x00:0x20] = stack[-2] // @0B64 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20])] // @0B6A stack[-2] = keccak256(memory[0x00:0x20]) + 0x01 // @0B6D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0b57, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_0B75: // Incoming jump from 0x0BE0 // Incoming jump from 0x0B74, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x126B, if !((storage[0x36] & !(storage[0x36] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0BC5, if !((storage[0x35] & !(storage[0x35] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0B46, if !storage[0x37] // Incoming jump from 0x1286 // Incoming jump from 0x0B74, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Inputs[3] // { // @0B7B stack[-7] // @0B7B stack[-6] // @0B7E stack[-8] // } 0B75 5B JUMPDEST 0B76 50 POP 0B77 50 POP 0B78 50 POP 0B79 50 POP 0B7A 50 POP 0B7B 90 SWAP1 0B7C 50 POP 0B7D 5B JUMPDEST 0B7E 90 SWAP1 0B7F 56 *JUMP // Stack delta = -7 // Outputs[1] { @0B7E stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0B80: // Incoming call from 0x01BC, returns to 0x01BD // Inputs[2] // { // @0B84 storage[0x35] // @0B88 memory[0x40:0x60] // } 0B80 5B JUMPDEST 0B81 60 PUSH1 0x35 0B83 80 DUP1 0B84 54 SLOAD 0B85 60 PUSH1 0x40 0B87 80 DUP1 0B88 51 MLOAD 0B89 60 PUSH1 0x20 0B8B 60 PUSH1 0x1f 0B8D 60 PUSH1 0x02 0B8F 60 PUSH1 0x00 0B91 19 NOT 0B92 61 PUSH2 0x0100 0B95 60 PUSH1 0x01 0B97 88 DUP9 0B98 16 AND 0B99 15 ISZERO 0B9A 02 MUL 0B9B 01 ADD 0B9C 90 SWAP1 0B9D 95 SWAP6 0B9E 16 AND 0B9F 94 SWAP5 0BA0 90 SWAP1 0BA1 94 SWAP5 0BA2 04 DIV 0BA3 93 SWAP4 0BA4 84 DUP5 0BA5 01 ADD 0BA6 81 DUP2 0BA7 90 SWAP1 0BA8 04 DIV 0BA9 81 DUP2 0BAA 02 MUL 0BAB 82 DUP3 0BAC 01 ADD 0BAD 81 DUP2 0BAE 01 ADD 0BAF 90 SWAP1 0BB0 92 SWAP3 0BB1 52 MSTORE 0BB2 82 DUP3 0BB3 81 DUP2 0BB4 52 MSTORE 0BB5 60 PUSH1 0x60 0BB7 93 SWAP4 0BB8 90 SWAP1 0BB9 92 SWAP3 0BBA 90 SWAP1 0BBB 91 SWAP2 0BBC 83 DUP4 0BBD 01 ADD 0BBE 82 DUP3 0BBF 82 DUP3 0BC0 80 DUP1 0BC1 15 ISZERO 0BC2 61 PUSH2 0x0b75 0BC5 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0BB1 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x35] & !(storage[0x35] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0BB4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x35] & !(storage[0x35] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0BB7 stack[0] = 0x60 // @0BB9 stack[1] = memory[0x40:0x60] // @0BBA stack[3] = (storage[0x35] & !(storage[0x35] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0BBB stack[2] = 0x35 // @0BBD stack[4] = memory[0x40:0x60] + 0x20 // @0BBE stack[5] = 0x35 // @0BBF stack[6] = (storage[0x35] & !(storage[0x35] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x0b75, if !((storage[0x35] & !(storage[0x35] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0BC6: // Incoming jump from 0x0BC5, if not !((storage[0x35] & !(storage[0x35] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0BC6 stack[-1] } 0BC6 80 DUP1 0BC7 60 PUSH1 0x1f 0BC9 10 LT 0BCA 61 PUSH2 0x0be1 0BCD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be1, if 0x1f < stack[-1] label_0BCE: // Incoming jump from 0x0BCD, if not 0x1f < stack[-1] // Inputs[4] // { // @0BD2 stack[-2] // @0BD3 storage[stack[-2]] // @0BD6 stack[-3] // @0BD8 stack[-1] // } 0BCE 61 PUSH2 0x0100 0BD1 80 DUP1 0BD2 83 DUP4 0BD3 54 SLOAD 0BD4 04 DIV 0BD5 02 MUL 0BD6 83 DUP4 0BD7 52 MSTORE 0BD8 91 SWAP2 0BD9 60 PUSH1 0x20 0BDB 01 ADD 0BDC 91 SWAP2 0BDD 61 PUSH2 0x0b75 0BE0 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0BD7 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0BDC stack[-1] = stack[-1] // @0BDC stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b75 label_0BE1: // Incoming jump from 0x0BCD, if 0x1f < stack[-1] // Incoming jump from 0x1273, if 0x1f < stack[-1] // Inputs[5] // { // @0BE2 stack[-3] // @0BE3 stack[-1] // @0BE5 stack[-2] // @0BED memory[0x00:0x20] // @0BF1 storage[keccak256(memory[0x00:0x20])] // } 0BE1 5B JUMPDEST 0BE2 82 DUP3 0BE3 01 ADD 0BE4 91 SWAP2 0BE5 90 SWAP1 0BE6 60 PUSH1 0x00 0BE8 52 MSTORE 0BE9 60 PUSH1 0x20 0BEB 60 PUSH1 0x00 0BED 20 SHA3 0BEE 90 SWAP1 0BEF 5B JUMPDEST 0BF0 81 DUP2 0BF1 54 SLOAD 0BF2 81 DUP2 0BF3 52 MSTORE 0BF4 90 SWAP1 0BF5 60 PUSH1 0x01 0BF7 01 ADD 0BF8 90 SWAP1 0BF9 60 PUSH1 0x20 0BFB 01 ADD 0BFC 80 DUP1 0BFD 83 DUP4 0BFE 11 GT 0BFF 61 PUSH2 0x0bef 0C02 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0BE4 stack[-3] = stack[-3] + stack[-1] // @0BE8 memory[0x00:0x20] = stack[-2] // @0BF3 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0BF8 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0BFB stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0bef, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0C03: // Incoming jump from 0x0C02, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0C02, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[4] // { // @0C04 stack[-2] // @0C04 stack[-6] // @0C05 stack[-8] // @0C06 stack[-7] // } 0C03 50 POP 0C04 93 SWAP4 0C05 95 SWAP6 0C06 94 SWAP5 0C07 50 POP 0C08 50 POP 0C09 50 POP 0C0A 50 POP 0C0B 50 POP 0C0C 56 *JUMP // Stack delta = -7 // Outputs[1] { @0C05 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0C0D: // Incoming jump from 0x025D 0C0D 5B JUMPDEST 0C0E 60 PUSH1 0x00 0C10 80 DUP1 0C11 61 PUSH2 0x0c18 0C14 61 PUSH2 0x18ef 0C17 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C0E stack[0] = 0x00 // @0C10 stack[1] = 0x00 // @0C11 stack[2] = 0x0c18 // } // Block ends with call to 0x18ef, returns to 0x0C18 label_0C18: // Incoming return from call to 0x18EF at 0x0C17 // Inputs[4] // { // @0C19 stack[-2] // @0C19 stack[-1] // @0C1F stack[-5] // @0C20 stack[-4] // } 0C18 5B JUMPDEST 0C19 90 SWAP1 0C1A 50 POP 0C1B 61 PUSH2 0x0c25 0C1E 81 DUP2 0C1F 85 DUP6 0C20 85 DUP6 0C21 61 PUSH2 0x18f3 0C24 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0C19 stack[-2] = stack[-1] // @0C1B stack[-1] = 0x0c25 // @0C1E stack[0] = stack[-1] // @0C1F stack[1] = stack[-5] // @0C20 stack[2] = stack[-4] // } // Block ends with call to 0x18f3, returns to 0x0C25 label_0C25: // Incoming return from call to 0x18F3 at 0x0C24 // Inputs[1] { @0C28 stack[-2] } 0C25 5B JUMPDEST 0C26 60 PUSH1 0x01 0C28 91 SWAP2 0C29 50 POP 0C2A 50 POP // Stack delta = -1 // Outputs[1] { @0C28 stack[-2] = 0x01 } // Block continues label_0C2B: // Incoming jump from 0x20E6 // Incoming jump from 0x20F0 // Incoming jump from 0x0C2A // Inputs[3] // { // @0C2C stack[-4] // @0C2C stack[-1] // @0C2D stack[-3] // } 0C2B 5B JUMPDEST 0C2C 92 SWAP3 0C2D 91 SWAP2 0C2E 50 POP 0C2F 50 POP 0C30 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C2C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0C31: // Incoming call from 0x0279, returns to 0x027A // Inputs[2] // { // @0C34 storage[0x72] // @0C35 stack[-1] // } 0C31 5B JUMPDEST 0C32 60 PUSH1 0x72 0C34 54 SLOAD 0C35 90 SWAP1 0C36 56 *JUMP // Stack delta = +0 // Outputs[1] { @0C35 stack[-1] = storage[0x72] } // Block ends with unconditional jump to stack[-1] label_0C37: // Incoming jump from 0x02C1 // Inputs[1] { @0C42 stack[-2] } 0C37 5B JUMPDEST 0C38 60 PUSH1 0x00 0C3A 60 PUSH1 0x01 0C3C 60 PUSH1 0x01 0C3E 60 PUSH1 0xa0 0C40 1B SHL 0C41 03 SUB 0C42 83 DUP4 0C43 16 AND 0C44 61 PUSH2 0x0c7e 0C47 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C38 stack[0] = 0x00 } // Block ends with conditional jump to 0x0c7e, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0C48: // Incoming jump from 0x0C47, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0C4A memory[0x40:0x60] // @0C78 memory[0x40:0x60] // @0C7D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C48 60 PUSH1 0x40 0C4A 51 MLOAD 0C4B 62 PUSH3 0x461bcd 0C4F 60 PUSH1 0xe5 0C51 1B SHL 0C52 81 DUP2 0C53 52 MSTORE 0C54 60 PUSH1 0x04 0C56 01 ADD 0C57 80 DUP1 0C58 80 DUP1 0C59 60 PUSH1 0x20 0C5B 01 ADD 0C5C 82 DUP3 0C5D 81 DUP2 0C5E 03 SUB 0C5F 82 DUP3 0C60 52 MSTORE 0C61 60 PUSH1 0x24 0C63 81 DUP2 0C64 52 MSTORE 0C65 60 PUSH1 0x20 0C67 01 ADD 0C68 80 DUP1 0C69 61 PUSH2 0x2994 0C6C 60 PUSH1 0x24 0C6E 91 SWAP2 0C6F 39 CODECOPY 0C70 60 PUSH1 0x40 0C72 01 ADD 0C73 91 SWAP2 0C74 50 POP 0C75 50 POP 0C76 60 PUSH1 0x40 0C78 51 MLOAD 0C79 80 DUP1 0C7A 91 SWAP2 0C7B 03 SUB 0C7C 90 SWAP1 0C7D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C60 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0C64 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @0C6F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x2994:0x29b8] // @0C7D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C7E: // Incoming jump from 0x0C47, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C87 stack[-4] } 0C7E 5B JUMPDEST 0C7F 60 PUSH1 0x01 0C81 60 PUSH1 0x01 0C83 60 PUSH1 0xa0 0C85 1B SHL 0C86 03 SUB 0C87 84 DUP5 0C88 16 AND 0C89 61 PUSH2 0x0cc3 0C8C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cc3, if stack[-4] & (0x01 << 0xa0) - 0x01 label_0C8D: // Incoming jump from 0x0C8C, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0C8F memory[0x40:0x60] // @0CBD memory[0x40:0x60] // @0CC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C8D 60 PUSH1 0x40 0C8F 51 MLOAD 0C90 62 PUSH3 0x461bcd 0C94 60 PUSH1 0xe5 0C96 1B SHL 0C97 81 DUP2 0C98 52 MSTORE 0C99 60 PUSH1 0x04 0C9B 01 ADD 0C9C 80 DUP1 0C9D 80 DUP1 0C9E 60 PUSH1 0x20 0CA0 01 ADD 0CA1 82 DUP3 0CA2 81 DUP2 0CA3 03 SUB 0CA4 82 DUP3 0CA5 52 MSTORE 0CA6 60 PUSH1 0x26 0CA8 81 DUP2 0CA9 52 MSTORE 0CAA 60 PUSH1 0x20 0CAC 01 ADD 0CAD 80 DUP1 0CAE 61 PUSH2 0x2a0d 0CB1 60 PUSH1 0x26 0CB3 91 SWAP2 0CB4 39 CODECOPY 0CB5 60 PUSH1 0x40 0CB7 01 ADD 0CB8 91 SWAP2 0CB9 50 POP 0CBA 50 POP 0CBB 60 PUSH1 0x40 0CBD 51 MLOAD 0CBE 80 DUP1 0CBF 91 SWAP2 0CC0 03 SUB 0CC1 90 SWAP1 0CC2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CA5 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0CA9 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @0CB4 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x2a0d:0x2a33] // @0CC2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0CC3: // Incoming jump from 0x0C8C, if stack[-4] & (0x01 << 0xa0) - 0x01 0CC3 5B JUMPDEST 0CC4 60 PUSH1 0x00 0CC6 61 PUSH2 0x0ccd 0CC9 61 PUSH2 0x18ef 0CCC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CC4 stack[0] = 0x00 // @0CC6 stack[1] = 0x0ccd // } // Block ends with call to 0x18ef, returns to 0x0CCD label_0CCD: // Incoming return from call to 0x18EF at 0x0CCC // Inputs[7] // { // @0CCE stack[-2] // @0CCE stack[-1] // @0CD4 stack[-6] // @0CD5 stack[-5] // @0CD6 stack[-4] // @0CD9 memory[0x40:0x60] // @0CE9 memory[0x40:0x60] // } 0CCD 5B JUMPDEST 0CCE 90 SWAP1 0CCF 50 POP 0CD0 61 PUSH2 0x0cfb 0CD3 81 DUP2 0CD4 86 DUP7 0CD5 86 DUP7 0CD6 86 DUP7 0CD7 60 PUSH1 0x40 0CD9 51 MLOAD 0CDA 80 DUP1 0CDB 60 PUSH1 0x20 0CDD 01 ADD 0CDE 60 PUSH1 0x40 0CE0 52 MSTORE 0CE1 80 DUP1 0CE2 60 PUSH1 0x00 0CE4 81 DUP2 0CE5 52 MSTORE 0CE6 50 POP 0CE7 60 PUSH1 0x40 0CE9 51 MLOAD 0CEA 80 DUP1 0CEB 60 PUSH1 0x20 0CED 01 ADD 0CEE 60 PUSH1 0x40 0CF0 52 MSTORE 0CF1 80 DUP1 0CF2 60 PUSH1 0x00 0CF4 81 DUP2 0CF5 52 MSTORE 0CF6 50 POP 0CF7 61 PUSH2 0x199a 0CFA 56 *JUMP // Stack delta = +6 // Outputs[12] // { // @0CCE stack[-2] = stack[-1] // @0CD0 stack[-1] = 0x0cfb // @0CD3 stack[0] = stack[-1] // @0CD4 stack[1] = stack[-6] // @0CD5 stack[2] = stack[-5] // @0CD6 stack[3] = stack[-4] // @0CD9 stack[4] = memory[0x40:0x60] // @0CE0 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0CE5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0CE9 stack[5] = memory[0x40:0x60] // @0CF0 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0CF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x199a, returns to 0x0CFB label_0CFB: // Incoming return from call to 0x199A at 0x0CFA // Inputs[6] // { // @0CFF stack[-1] // @0D00 stack[-5] // @0D01 stack[-4] // @0D02 stack[-3] // @0D05 memory[0x40:0x60] // @0D15 memory[0x40:0x60] // } 0CFB 5B JUMPDEST 0CFC 61 PUSH2 0x0d27 0CFF 81 DUP2 0D00 86 DUP7 0D01 86 DUP7 0D02 86 DUP7 0D03 60 PUSH1 0x40 0D05 51 MLOAD 0D06 80 DUP1 0D07 60 PUSH1 0x20 0D09 01 ADD 0D0A 60 PUSH1 0x40 0D0C 52 MSTORE 0D0D 80 DUP1 0D0E 60 PUSH1 0x00 0D10 81 DUP2 0D11 52 MSTORE 0D12 50 POP 0D13 60 PUSH1 0x40 0D15 51 MLOAD 0D16 80 DUP1 0D17 60 PUSH1 0x20 0D19 01 ADD 0D1A 60 PUSH1 0x40 0D1C 52 MSTORE 0D1D 80 DUP1 0D1E 60 PUSH1 0x00 0D20 81 DUP2 0D21 52 MSTORE 0D22 50 POP 0D23 61 PUSH2 0x1bba 0D26 56 *JUMP // Stack delta = +7 // Outputs[11] // { // @0CFC stack[0] = 0x0d27 // @0CFF stack[1] = stack[-1] // @0D00 stack[2] = stack[-5] // @0D01 stack[3] = stack[-4] // @0D02 stack[4] = stack[-3] // @0D05 stack[5] = memory[0x40:0x60] // @0D0C memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0D11 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0D15 stack[6] = memory[0x40:0x60] // @0D1C memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0D21 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1bba 0D27 5B JUMPDEST 0D28 61 PUSH2 0x0d81 0D2B 85 DUP6 0D2C 82 DUP3 0D2D 61 PUSH2 0x0d7c 0D30 86 DUP7 0D31 60 PUSH1 0x40 0D33 51 MLOAD 0D34 80 DUP1 0D35 60 PUSH1 0x60 0D37 01 ADD 0D38 60 PUSH1 0x40 0D3A 52 MSTORE 0D3B 80 DUP1 0D3C 60 PUSH1 0x29 0D3E 81 DUP2 0D3F 52 MSTORE 0D40 60 PUSH1 0x20 0D42 01 ADD 0D43 61 PUSH2 0x29e4 0D46 60 PUSH1 0x29 0D48 91 SWAP2 0D49 39 CODECOPY 0D4A 60 PUSH1 0x01 0D4C 60 PUSH1 0x01 0D4E 60 PUSH1 0xa0 0D50 1B SHL 0D51 03 SUB 0D52 80 DUP1 0D53 8C DUP13 0D54 16 AND 0D55 60 PUSH1 0x00 0D57 90 SWAP1 0D58 81 DUP2 0D59 52 MSTORE 0D5A 60 PUSH1 0x3b 0D5C 60 PUSH1 0x20 0D5E 90 SWAP1 0D5F 81 DUP2 0D60 52 MSTORE 0D61 60 PUSH1 0x40 0D63 80 DUP1 0D64 83 DUP4 0D65 20 SHA3 0D66 93 SWAP4 0D67 8B DUP12 0D68 16 AND 0D69 83 DUP4 0D6A 52 MSTORE 0D6B 92 SWAP3 0D6C 90 SWAP1 0D6D 52 MSTORE 0D6E 20 SHA3 0D6F 54 SLOAD 0D70 91 SWAP2 0D71 90 SWAP1 0D72 63 PUSH4 0xffffffff 0D77 61 PUSH2 0x1d47 0D7A 16 AND 0D7B 56 *JUMP 0D7C 5B JUMPDEST 0D7D 61 PUSH2 0x18f3 0D80 56 *JUMP 0D81 5B JUMPDEST 0D82 61 PUSH2 0x0daf 0D85 81 DUP2 0D86 86 DUP7 0D87 86 DUP7 0D88 86 DUP7 0D89 60 PUSH1 0x40 0D8B 51 MLOAD 0D8C 80 DUP1 0D8D 60 PUSH1 0x20 0D8F 01 ADD 0D90 60 PUSH1 0x40 0D92 52 MSTORE 0D93 80 DUP1 0D94 60 PUSH1 0x00 0D96 81 DUP2 0D97 52 MSTORE 0D98 50 POP 0D99 60 PUSH1 0x40 0D9B 51 MLOAD 0D9C 80 DUP1 0D9D 60 PUSH1 0x20 0D9F 01 ADD 0DA0 60 PUSH1 0x40 0DA2 52 MSTORE 0DA3 80 DUP1 0DA4 60 PUSH1 0x00 0DA6 81 DUP2 0DA7 52 MSTORE 0DA8 50 POP 0DA9 60 PUSH1 0x00 0DAB 61 PUSH2 0x1dde 0DAE 56 *JUMP 0DAF 5B JUMPDEST 0DB0 50 POP 0DB1 60 PUSH1 0x01 0DB3 94 SWAP5 0DB4 93 SWAP4 0DB5 50 POP 0DB6 50 POP 0DB7 50 POP 0DB8 50 POP 0DB9 56 *JUMP label_0DBA: // Incoming call from 0x02C9, returns to 0x02CA // Inputs[1] { @0DBD stack[-1] } 0DBA 5B JUMPDEST 0DBB 60 PUSH1 0x12 0DBD 90 SWAP1 0DBE 56 *JUMP // Stack delta = +0 // Outputs[1] { @0DBD stack[-1] = 0x12 } // Block ends with unconditional jump to stack[-1] label_0DBF: // Incoming jump from 0x030B // Inputs[2] // { // @0DC7 stack[-2] // @0DC8 stack[-1] // } 0DBF 5B JUMPDEST 0DC0 60 PUSH1 0x00 0DC2 60 PUSH1 0x74 0DC4 61 PUSH2 0x0dcd 0DC7 84 DUP5 0DC8 84 DUP5 0DC9 61 PUSH2 0x2056 0DCC 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0DC0 stack[0] = 0x00 // @0DC2 stack[1] = 0x74 // @0DC4 stack[2] = 0x0dcd // @0DC7 stack[3] = stack[-2] // @0DC8 stack[4] = stack[-1] // } // Block ends with call to 0x2056, returns to 0x0DCD label_0DCD: // Incoming return from call to 0x2056 at 0x0DCC // Inputs[3] // { // @0DCE stack[-2] // @0DCF storage[stack[-2]] // @0DD0 stack[-1] // } 0DCD 5B JUMPDEST 0DCE 81 DUP2 0DCF 54 SLOAD 0DD0 81 DUP2 0DD1 10 LT 0DD2 61 PUSH2 0x0dd7 0DD5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dd7, if stack[-1] < storage[stack[-2]] label_0DD6: // Incoming jump from 0x0DD5, if not stack[-1] < storage[stack[-2]] 0DD6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0DD6 assert(); } // Block terminates label_0DD7: // Incoming jump from 0x0DD5, if stack[-1] < storage[stack[-2]] // Inputs[7] // { // @0DDA stack[-2] // @0DE1 memory[0x00:0x20] // @0DEA stack[-5] // @0DF1 stack[-1] // @0DFA memory[0x00:0x40] // @0DFB storage[keccak256(memory[0x00:0x40])] // @0DFC stack[-6] // } 0DD7 5B JUMPDEST 0DD8 60 PUSH1 0x00 0DDA 91 SWAP2 0DDB 82 DUP3 0DDC 52 MSTORE 0DDD 60 PUSH1 0x20 0DDF 80 DUP1 0DE0 83 DUP4 0DE1 20 SHA3 0DE2 60 PUSH1 0x01 0DE4 60 PUSH1 0x01 0DE6 60 PUSH1 0xa0 0DE8 1B SHL 0DE9 03 SUB 0DEA 96 SWAP7 0DEB 90 SWAP1 0DEC 96 SWAP7 0DED 16 AND 0DEE 83 DUP4 0DEF 52 MSTORE 0DF0 94 SWAP5 0DF1 01 ADD 0DF2 90 SWAP1 0DF3 93 SWAP4 0DF4 52 MSTORE 0DF5 50 POP 0DF6 50 POP 0DF7 60 PUSH1 0x40 0DF9 90 SWAP1 0DFA 20 SHA3 0DFB 54 SLOAD 0DFC 90 SWAP1 0DFD 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @0DDC memory[0x00:0x20] = stack[-2] // @0DEF memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @0DF4 memory[0x20:0x40] = keccak256(memory[0x00:0x20]) + stack[-1] // @0DFC stack[-6] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-6] label_0DFE: // Incoming call from 0x0313, returns to 0x027A // Inputs[2] // { // @0E01 storage[0x74] // @0E06 stack[-1] // } 0DFE 5B JUMPDEST 0DFF 60 PUSH1 0x74 0E01 54 SLOAD 0E02 60 PUSH1 0x00 0E04 19 NOT 0E05 01 ADD 0E06 90 SWAP1 0E07 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E06 stack[-1] = ~0x00 + storage[0x74] } // Block ends with unconditional jump to stack[-1] label_0E08: // Incoming jump from 0x044E // Inputs[1] { @0E0B storage[0x00] } 0E08 5B JUMPDEST 0E09 60 PUSH1 0x00 0E0B 54 SLOAD 0E0C 61 PUSH2 0x0100 0E0F 90 SWAP1 0E10 04 DIV 0E11 60 PUSH1 0xff 0E13 16 AND 0E14 80 DUP1 0E15 61 PUSH2 0x0e21 0E18 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E13 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x0e21, if 0xff & storage[0x00] / 0x0100 label_0E19: // Incoming jump from 0x0E18, if not 0xff & storage[0x00] / 0x0100 0E19 50 POP 0E1A 61 PUSH2 0x0e21 0E1D 61 PUSH2 0x20f1 0E20 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E1A stack[-1] = 0x0e21 } // Block ends with call to 0x20f1, returns to 0x0E21 label_0E21: // Incoming return from call to 0x20F1 at 0x0E20 // Incoming jump from 0x0E18, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @0E22 stack[-1] } 0E21 5B JUMPDEST 0E22 80 DUP1 0E23 61 PUSH2 0x0e2f 0E26 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e2f, if stack[-1] label_0E27: // Incoming jump from 0x0E26, if not stack[-1] // Inputs[1] { @0E2A storage[0x00] } 0E27 50 POP 0E28 60 PUSH1 0x00 0E2A 54 SLOAD 0E2B 60 PUSH1 0xff 0E2D 16 AND 0E2E 15 ISZERO 0E2F 5B JUMPDEST 0E30 61 PUSH2 0x0e6a 0E33 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e6a, if !(0xff & storage[0x00]) label_0E34: // Incoming jump from 0x0E33, if not stack[-1] // Incoming jump from 0x0E33, if not !(0xff & storage[0x00]) // Inputs[3] // { // @0E36 memory[0x40:0x60] // @0E64 memory[0x40:0x60] // @0E69 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E34 60 PUSH1 0x40 0E36 51 MLOAD 0E37 62 PUSH3 0x461bcd 0E3B 60 PUSH1 0xe5 0E3D 1B SHL 0E3E 81 DUP2 0E3F 52 MSTORE 0E40 60 PUSH1 0x04 0E42 01 ADD 0E43 80 DUP1 0E44 80 DUP1 0E45 60 PUSH1 0x20 0E47 01 ADD 0E48 82 DUP3 0E49 81 DUP2 0E4A 03 SUB 0E4B 82 DUP3 0E4C 52 MSTORE 0E4D 60 PUSH1 0x2e 0E4F 81 DUP2 0E50 52 MSTORE 0E51 60 PUSH1 0x20 0E53 01 ADD 0E54 80 DUP1 0E55 61 PUSH2 0x2966 0E58 60 PUSH1 0x2e 0E5A 91 SWAP2 0E5B 39 CODECOPY 0E5C 60 PUSH1 0x40 0E5E 01 ADD 0E5F 91 SWAP2 0E60 50 POP 0E61 50 POP 0E62 60 PUSH1 0x40 0E64 51 MLOAD 0E65 80 DUP1 0E66 91 SWAP2 0E67 03 SUB 0E68 90 SWAP1 0E69 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E3F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E4C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0E50 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @0E5B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x2966:0x2994] // @0E69 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E6A: // Incoming jump from 0x0E33, if stack[-1] // Incoming jump from 0x0E33, if !(0xff & storage[0x00]) // Inputs[1] { @0E6D storage[0x00] } 0E6A 5B JUMPDEST 0E6B 60 PUSH1 0x00 0E6D 54 SLOAD 0E6E 61 PUSH2 0x0100 0E71 90 SWAP1 0E72 04 DIV 0E73 60 PUSH1 0xff 0E75 16 AND 0E76 15 ISZERO 0E77 80 DUP1 0E78 15 ISZERO 0E79 61 PUSH2 0x0e95 0E7C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E76 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x0e95, if !!(0xff & storage[0x00] / 0x0100) label_0E7D: // Incoming jump from 0x0E7C, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[10] // { // @0E80 storage[0x00] // @0E99 storage[0x6e] // @0F0A storage[0x73] // @0F39 storage[0xf79bde9ddd17963ebce6f7d021d60de7c2bd0db944d23c900c0c0e775f530052 + storage[0x73]] // @0F42 stack[-5] // @0F4F storage[0x71] // @0F58 storage[0x73] // @0F5C memory[0x40:0x60] // @0F70 stack[-4] // @0F72 stack[-3] // } 0E7D 60 PUSH1 0x00 0E7F 80 DUP1 0E80 54 SLOAD 0E81 60 PUSH1 0xff 0E83 19 NOT 0E84 61 PUSH2 0xff00 0E87 19 NOT 0E88 90 SWAP1 0E89 91 SWAP2 0E8A 16 AND 0E8B 61 PUSH2 0x0100 0E8E 17 OR 0E8F 16 AND 0E90 60 PUSH1 0x01 0E92 17 OR 0E93 90 SWAP1 0E94 55 SSTORE 0E95 5B JUMPDEST 0E96 60 PUSH1 0x6e 0E98 80 DUP1 0E99 54 SLOAD 0E9A 60 PUSH1 0x01 0E9C 60 PUSH1 0x01 0E9E 60 PUSH1 0xa0 0EA0 1B SHL 0EA1 03 SUB 0EA2 19 NOT 0EA3 90 SWAP1 0EA4 81 DUP2 0EA5 16 AND 0EA6 73 PUSH20 0x1820a4b7618bde71dce8cdc73aab6c95905fad24 0EBB 17 OR 0EBC 90 SWAP1 0EBD 91 SWAP2 0EBE 55 SSTORE 0EBF 7F PUSH32 0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895 0EE0 60 PUSH1 0x6f 0EE2 55 SSTORE 0EE3 7F PUSH32 0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b 0F04 60 PUSH1 0x70 0F06 55 SSTORE 0F07 60 PUSH1 0x73 0F09 80 DUP1 0F0A 54 SLOAD 0F0B 60 PUSH1 0x01 0F0D 81 DUP2 0F0E 01 ADD 0F0F 82 DUP3 0F10 55 SSTORE 0F11 60 PUSH1 0x00 0F13 82 DUP3 0F14 90 SWAP1 0F15 52 MSTORE 0F16 7F PUSH32 0xf79bde9ddd17963ebce6f7d021d60de7c2bd0db944d23c900c0c0e775f530052 0F37 01 ADD 0F38 80 DUP1 0F39 54 SLOAD 0F3A 60 PUSH1 0x01 0F3C 60 PUSH1 0x01 0F3E 60 PUSH1 0xa0 0F40 1B SHL 0F41 03 SUB 0F42 89 DUP10 0F43 16 AND 0F44 90 SWAP1 0F45 84 DUP5 0F46 16 AND 0F47 81 DUP2 0F48 17 OR 0F49 90 SWAP1 0F4A 91 SWAP2 0F4B 55 SSTORE 0F4C 60 PUSH1 0x71 0F4E 80 DUP1 0F4F 54 SLOAD 0F50 90 SWAP1 0F51 93 SWAP4 0F52 16 AND 0F53 17 OR 0F54 90 SWAP1 0F55 91 SWAP2 0F56 55 SSTORE 0F57 80 DUP1 0F58 54 SLOAD 0F59 60 PUSH1 0x40 0F5B 80 DUP1 0F5C 51 MLOAD 0F5D 60 PUSH1 0x20 0F5F 83 DUP4 0F60 81 DUP2 0F61 02 MUL 0F62 82 DUP3 0F63 01 ADD 0F64 81 DUP2 0F65 01 ADD 0F66 90 SWAP1 0F67 92 SWAP3 0F68 52 MSTORE 0F69 82 DUP3 0F6A 81 DUP2 0F6B 52 MSTORE 0F6C 61 PUSH2 0x0fb6 0F6F 93 SWAP4 0F70 88 DUP9 0F71 93 SWAP4 0F72 88 DUP9 0F73 93 SWAP4 0F74 83 DUP4 0F75 01 ADD 0F76 82 DUP3 0F77 82 DUP3 0F78 80 DUP1 0F79 15 ISZERO 0F7A 61 PUSH2 0x0fac 0F7D 57 *JUMPI // Stack delta = +9 // Outputs[19] // { // @0E94 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @0EBE storage[0x6e] = 0x1820a4b7618bde71dce8cdc73aab6c95905fad24 | (~((0x01 << 0xa0) - 0x01) & storage[0x6e]) // @0EE2 storage[0x6f] = 0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895 // @0F06 storage[0x70] = 0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b // @0F10 storage[0x73] = storage[0x73] + 0x01 // @0F15 memory[0x00:0x20] = 0x73 // @0F4B storage[0xf79bde9ddd17963ebce6f7d021d60de7c2bd0db944d23c900c0c0e775f530052 + storage[0x73]] = (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0xf79bde9ddd17963ebce6f7d021d60de7c2bd0db944d23c900c0c0e775f530052 + storage[0x73]]) // @0F56 storage[0x71] = (~((0x01 << 0xa0) - 0x01) & storage[0x71]) | (stack[-5] & (0x01 << 0xa0) - 0x01) // @0F5C stack[3] = memory[0x40:0x60] // @0F68 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * storage[0x73] // @0F6B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x73] // @0F6F stack[4] = 0x73 // @0F6F stack[0] = 0x0fb6 // @0F71 stack[5] = storage[0x73] // @0F71 stack[1] = stack[-4] // @0F73 stack[2] = stack[-3] // @0F75 stack[6] = memory[0x40:0x60] + 0x20 // @0F76 stack[7] = 0x73 // @0F77 stack[8] = storage[0x73] // } // Block ends with conditional jump to 0x0fac, if !storage[0x73] label_0F7E: // Incoming jump from 0x0F7D, if not !storage[0x73] // Incoming jump from 0x0F7D, if not !storage[0x73] // Inputs[5] // { // @0F80 stack[-1] // @0F81 stack[-3] // @0F84 stack[-2] // @0F8C memory[0x00:0x20] // @0F90 storage[keccak256(memory[0x00:0x20])] // } 0F7E 60 PUSH1 0x20 0F80 02 MUL 0F81 82 DUP3 0F82 01 ADD 0F83 91 SWAP2 0F84 90 SWAP1 0F85 60 PUSH1 0x00 0F87 52 MSTORE 0F88 60 PUSH1 0x20 0F8A 60 PUSH1 0x00 0F8C 20 SHA3 0F8D 90 SWAP1 0F8E 5B JUMPDEST 0F8F 81 DUP2 0F90 54 SLOAD 0F91 60 PUSH1 0x01 0F93 60 PUSH1 0x01 0F95 60 PUSH1 0xa0 0F97 1B SHL 0F98 03 SUB 0F99 16 AND 0F9A 81 DUP2 0F9B 52 MSTORE 0F9C 60 PUSH1 0x01 0F9E 90 SWAP1 0F9F 91 SWAP2 0FA0 01 ADD 0FA1 90 SWAP1 0FA2 60 PUSH1 0x20 0FA4 01 ADD 0FA5 80 DUP1 0FA6 83 DUP4 0FA7 11 GT 0FA8 61 PUSH2 0x0f8e 0FAB 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0F83 stack[-3] = stack[-3] + 0x20 * stack[-1] // @0F87 memory[0x00:0x20] = stack[-2] // @0F9B memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x20])] // @0FA1 stack[-2] = keccak256(memory[0x00:0x20]) + 0x01 // @0FA4 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0f8e, if stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] label_0FAC: // Incoming jump from 0x0FAB, if not stack[-3] + 0x20 * stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0FAB, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0F7D, if !storage[0x73] // Incoming jump from 0x0F7D, if !storage[0x73] 0FAC 5B JUMPDEST 0FAD 50 POP 0FAE 50 POP 0FAF 50 POP 0FB0 50 POP 0FB1 50 POP 0FB2 61 PUSH2 0x1392 0FB5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to 0x1392 0FB6 5B JUMPDEST 0FB7 60 PUSH1 0x40 0FB9 80 DUP1 0FBA 51 MLOAD 0FBB 60 PUSH1 0x74 0FBD 80 DUP1 0FBE 54 SLOAD 0FBF 60 PUSH1 0x01 0FC1 01 ADD 0FC2 81 DUP2 0FC3 55 SSTORE 0FC4 60 PUSH1 0x00 0FC6 90 SWAP1 0FC7 81 DUP2 0FC8 52 MSTORE 0FC9 60 PUSH1 0x60 0FCB 82 DUP3 0FCC 01 ADD 0FCD 83 DUP4 0FCE 52 MSTORE 0FCF 60 PUSH1 0x0f 0FD1 60 PUSH1 0x20 0FD3 80 DUP1 0FD4 84 DUP5 0FD5 01 ADD 0FD6 91 SWAP2 0FD7 82 DUP3 0FD8 52 MSTORE 0FD9 6E PUSH15 0x496e697469616c204d696e74696e67 0FE9 60 PUSH1 0x88 0FEB 1B SHL 0FEC 93 SWAP4 0FED 85 DUP6 0FEE 01 ADD 0FEF 93 SWAP4 0FF0 90 SWAP1 0FF1 93 SWAP4 0FF2 52 MSTORE 0FF3 83 DUP4 0FF4 51 MLOAD 0FF5 92 SWAP3 0FF6 83 DUP4 0FF7 01 ADD 0FF8 90 SWAP1 0FF9 93 SWAP4 0FFA 52 MSTORE 0FFB 81 DUP2 0FFC 52 MSTORE 0FFD 61 PUSH2 0x100b 1000 91 SWAP2 1001 33 CALLER 1002 91 SWAP2 1003 82 DUP3 1004 91 SWAP2 1005 86 DUP7 1006 91 SWAP2 1007 61 PUSH2 0x20f7 100A 56 *JUMP 100B 5B JUMPDEST 100C 80 DUP1 100D 15 ISZERO 100E 61 PUSH2 0x101d 1011 57 *JUMPI 1012 60 PUSH1 0x00 1014 80 DUP1 1015 54 SLOAD 1016 61 PUSH2 0xff00 1019 19 NOT 101A 16 AND 101B 90 SWAP1 101C 55 SSTORE 101D 5B JUMPDEST 101E 50 POP 101F 50 POP 1020 50 POP 1021 50 POP 1022 50 POP 1023 56 *JUMP label_1024: // Incoming call from 0x0458, returns to 0x027A // Inputs[1] { @1027 stack[-1] } 1024 5B JUMPDEST 1025 60 PUSH1 0x01 1027 90 SWAP1 1028 56 *JUMP // Stack delta = +0 // Outputs[1] { @1027 stack[-1] = 0x01 } // Block ends with unconditional jump to stack[-1] label_1029: // Incoming call from 0x0460, returns to 0x0461 // Inputs[2] // { // @102C storage[0x71] // @1036 stack[-1] // } 1029 5B JUMPDEST 102A 60 PUSH1 0x71 102C 54 SLOAD 102D 60 PUSH1 0x01 102F 60 PUSH1 0x01 1031 60 PUSH1 0xa0 1033 1B SHL 1034 03 SUB 1035 16 AND 1036 81 DUP2 1037 56 *JUMP // Stack delta = +1 // Outputs[1] { @1035 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x71] } // Block ends with unconditional jump to stack[-1] label_1038: // Incoming jump from 0x05C5 1038 5B JUMPDEST 1039 61 PUSH2 0x1049 103C 61 PUSH2 0x1043 103F 61 PUSH2 0x18ef 1042 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1039 stack[0] = 0x1049 // @103C stack[1] = 0x1043 // } // Block ends with call to 0x18ef, returns to 0x1043 label_1043: // Incoming return from call to 0x18EF at 0x1042 // Inputs[1] { @1044 stack[-7] } 1043 5B JUMPDEST 1044 86 DUP7 1045 61 PUSH2 0x15f9 1048 56 *JUMP // Stack delta = +1 // Outputs[1] { @1044 stack[0] = stack[-7] } // Block ends with unconditional jump to 0x15f9 label_1049: // Incoming return from call to 0x1043 at 0x1042 // Inputs[1] { @104D stack[-1] } 1049 5B JUMPDEST 104A 61 PUSH2 0x1084 104D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1084, if stack[-1] label_104E: // Incoming jump from 0x104D, if not stack[-1] // Inputs[3] // { // @1050 memory[0x40:0x60] // @107E memory[0x40:0x60] // @1083 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 104E 60 PUSH1 0x40 1050 51 MLOAD 1051 62 PUSH3 0x461bcd 1055 60 PUSH1 0xe5 1057 1B SHL 1058 81 DUP2 1059 52 MSTORE 105A 60 PUSH1 0x04 105C 01 ADD 105D 80 DUP1 105E 80 DUP1 105F 60 PUSH1 0x20 1061 01 ADD 1062 82 DUP3 1063 81 DUP2 1064 03 SUB 1065 82 DUP3 1066 52 MSTORE 1067 60 PUSH1 0x2c 1069 81 DUP2 106A 52 MSTORE 106B 60 PUSH1 0x20 106D 01 ADD 106E 80 DUP1 106F 61 PUSH2 0x29b8 1072 60 PUSH1 0x2c 1074 91 SWAP2 1075 39 CODECOPY 1076 60 PUSH1 0x40 1078 01 ADD 1079 91 SWAP2 107A 50 POP 107B 50 POP 107C 60 PUSH1 0x40 107E 51 MLOAD 107F 80 DUP1 1080 91 SWAP2 1081 03 SUB 1082 90 SWAP1 1083 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1059 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1066 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @106A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @1075 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x29b8:0x29e4] // @1083 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1084: // Incoming jump from 0x104D, if stack[-1] 1084 5B JUMPDEST 1085 61 PUSH2 0x101d 1088 61 PUSH2 0x108f 108B 61 PUSH2 0x18ef 108E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1085 stack[0] = 0x101d // @1088 stack[1] = 0x108f // } // Block ends with call to 0x18ef, returns to 0x108F label_108F: // Incoming return from call to 0x18EF at 0x108E // Inputs[5] // { // @1090 stack[-7] // @1091 stack[-6] // @1092 stack[-5] // @1093 stack[-4] // @1094 stack[-3] // } 108F 5B JUMPDEST 1090 86 DUP7 1091 86 DUP7 1092 86 DUP7 1093 86 DUP7 1094 86 DUP7 1095 60 PUSH1 0x01 1097 61 PUSH2 0x22e7 109A 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1090 stack[0] = stack[-7] // @1091 stack[1] = stack[-6] // @1092 stack[2] = stack[-5] // @1093 stack[3] = stack[-4] // @1094 stack[4] = stack[-3] // @1095 stack[5] = 0x01 // } // Block ends with unconditional jump to 0x22e7 label_109B: // Incoming jump from 0x25E6 // Incoming jump from 0x05EB // Inputs[1] { @10A3 stack[-1] } 109B 5B JUMPDEST 109C 60 PUSH1 0x00 109E 60 PUSH1 0x74 10A0 61 PUSH2 0x10a8 10A3 83 DUP4 10A4 61 PUSH2 0x23b2 10A7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @109C stack[0] = 0x00 // @109E stack[1] = 0x74 // @10A0 stack[2] = 0x10a8 // @10A3 stack[3] = stack[-1] // } // Block ends with call to 0x23b2, returns to 0x10A8 label_10A8: // Incoming return from call to 0x23B2 at 0x10A7 // Inputs[3] // { // @10A9 stack[-2] // @10AA storage[stack[-2]] // @10AB stack[-1] // } 10A8 5B JUMPDEST 10A9 81 DUP2 10AA 54 SLOAD 10AB 81 DUP2 10AC 10 LT 10AD 61 PUSH2 0x10b2 10B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10b2, if stack[-1] < storage[stack[-2]] label_10B1: // Incoming jump from 0x10B0, if not stack[-1] < storage[stack[-2]] 10B1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @10B1 assert(); } // Block terminates label_10B2: // Incoming jump from 0x10B0, if stack[-1] < storage[stack[-2]] // Inputs[7] // { // @10B5 stack[-2] // @10BC memory[0x00:0x20] // @10C5 stack[-4] // @10CA stack[-1] // @10D1 memory[0x00:0x40] // @10D2 storage[keccak256(memory[0x00:0x40])] // @10D3 stack[-3] // } 10B2 5B JUMPDEST 10B3 60 PUSH1 0x00 10B5 91 SWAP2 10B6 82 DUP3 10B7 52 MSTORE 10B8 60 PUSH1 0x20 10BA 80 DUP1 10BB 83 DUP4 10BC 20 SHA3 10BD 60 PUSH1 0x01 10BF 60 PUSH1 0x01 10C1 60 PUSH1 0xa0 10C3 1B SHL 10C4 03 SUB 10C5 86 DUP7 10C6 16 AND 10C7 84 DUP5 10C8 52 MSTORE 10C9 90 SWAP1 10CA 91 SWAP2 10CB 01 ADD 10CC 90 SWAP1 10CD 52 MSTORE 10CE 60 PUSH1 0x40 10D0 90 SWAP1 10D1 20 SHA3 10D2 54 SLOAD 10D3 90 SWAP1 10D4 50 POP // Stack delta = -2 // Outputs[4] // { // @10B7 memory[0x00:0x20] = stack[-2] // @10C8 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @10CD memory[0x20:0x40] = stack[-1] + keccak256(memory[0x00:0x20]) // @10D3 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block continues label_10D5: // Incoming jump from 0x23FF // Incoming jump from 0x10D4 // Incoming jump from 0x23F5 // Inputs[3] // { // @10D6 stack[-1] // @10D6 stack[-3] // @10D7 stack[-2] // } 10D5 5B JUMPDEST 10D6 91 SWAP2 10D7 90 SWAP1 10D8 50 POP 10D9 56 *JUMP // Stack delta = -2 // Outputs[1] { @10D6 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_10DA: // Incoming jump from 0x0611 // Inputs[1] { @10DB stack[-1] } 10DA 5B JUMPDEST 10DB 80 DUP1 10DC 60 PUSH1 0x01 10DE 60 PUSH1 0x01 10E0 60 PUSH1 0xa0 10E2 1B SHL 10E3 03 SUB 10E4 16 AND 10E5 61 PUSH2 0x10ec 10E8 61 PUSH2 0x18ef 10EB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10E4 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @10E5 stack[1] = 0x10ec // } // Block ends with call to 0x18ef, returns to 0x10EC label_10EC: // Incoming return from call to 0x18EF at 0x10EB // Inputs[2] // { // @10F5 stack[-1] // @10F6 stack[-2] // } 10EC 5B JUMPDEST 10ED 60 PUSH1 0x01 10EF 60 PUSH1 0x01 10F1 60 PUSH1 0xa0 10F3 1B SHL 10F4 03 SUB 10F5 16 AND 10F6 14 EQ 10F7 15 ISZERO 10F8 61 PUSH2 0x1132 10FB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1132, if !((0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2]) label_10FC: // Incoming jump from 0x10FB, if not !((0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2]) // Inputs[3] // { // @10FE memory[0x40:0x60] // @112C memory[0x40:0x60] // @1131 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 10FC 60 PUSH1 0x40 10FE 51 MLOAD 10FF 62 PUSH3 0x461bcd 1103 60 PUSH1 0xe5 1105 1B SHL 1106 81 DUP2 1107 52 MSTORE 1108 60 PUSH1 0x04 110A 01 ADD 110B 80 DUP1 110C 80 DUP1 110D 60 PUSH1 0x20 110F 01 ADD 1110 82 DUP3 1111 81 DUP2 1112 03 SUB 1113 82 DUP3 1114 52 MSTORE 1115 60 PUSH1 0x24 1117 81 DUP2 1118 52 MSTORE 1119 60 PUSH1 0x20 111B 01 ADD 111C 80 DUP1 111D 61 PUSH2 0x28d4 1120 60 PUSH1 0x24 1122 91 SWAP2 1123 39 CODECOPY 1124 60 PUSH1 0x40 1126 01 ADD 1127 91 SWAP2 1128 50 POP 1129 50 POP 112A 60 PUSH1 0x40 112C 51 MLOAD 112D 80 DUP1 112E 91 SWAP2 112F 03 SUB 1130 90 SWAP1 1131 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1107 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1114 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1118 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @1123 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x28d4:0x28f8] // @1131 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1132: // Incoming jump from 0x10FB, if !((0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2]) // Inputs[3] // { // @113B stack[-1] // @114A memory[0x00:0x40] // @114B storage[keccak256(memory[0x00:0x40])] // } 1132 5B JUMPDEST 1133 60 PUSH1 0x01 1135 60 PUSH1 0x01 1137 60 PUSH1 0xa0 1139 1B SHL 113A 03 SUB 113B 81 DUP2 113C 16 AND 113D 60 PUSH1 0x00 113F 90 SWAP1 1140 81 DUP2 1141 52 MSTORE 1142 60 PUSH1 0x38 1144 60 PUSH1 0x20 1146 52 MSTORE 1147 60 PUSH1 0x40 1149 90 SWAP1 114A 20 SHA3 114B 54 SLOAD 114C 60 PUSH1 0xff 114E 16 AND 114F 15 ISZERO 1150 61 PUSH2 0x1195 1153 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1141 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1146 memory[0x20:0x40] = 0x38 // } // Block ends with conditional jump to 0x1195, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1154: // Incoming jump from 0x1153, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) 1154 60 PUSH1 0x3a 1156 60 PUSH1 0x00 1158 61 PUSH2 0x115f 115B 61 PUSH2 0x18ef 115E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1154 stack[0] = 0x3a // @1156 stack[1] = 0x00 // @1158 stack[2] = 0x115f // } // Block ends with call to 0x18ef, returns to 0x115F label_115F: // Incoming return from call to 0x18EF at 0x115E // Inputs[7] // { // @1168 stack[-1] // @116B stack[-2] // @1172 stack[-3] // @117F memory[0x00:0x00 + 0x40 + stack[-2]] // @1181 stack[-4] // @1188 memory[0x00:0x40] // @118A storage[keccak256(memory[0x00:0x40])] // } 115F 5B JUMPDEST 1160 60 PUSH1 0x01 1162 60 PUSH1 0x01 1164 60 PUSH1 0xa0 1166 1B SHL 1167 03 SUB 1168 90 SWAP1 1169 81 DUP2 116A 16 AND 116B 82 DUP3 116C 52 MSTORE 116D 60 PUSH1 0x20 116F 80 DUP1 1170 83 DUP4 1171 01 ADD 1172 93 SWAP4 1173 90 SWAP1 1174 93 SWAP4 1175 52 MSTORE 1176 60 PUSH1 0x40 1178 91 SWAP2 1179 82 DUP3 117A 01 ADD 117B 60 PUSH1 0x00 117D 90 SWAP1 117E 81 DUP2 117F 20 SHA3 1180 91 SWAP2 1181 85 DUP6 1182 16 AND 1183 81 DUP2 1184 52 MSTORE 1185 92 SWAP3 1186 52 MSTORE 1187 90 SWAP1 1188 20 SHA3 1189 80 DUP1 118A 54 SLOAD 118B 60 PUSH1 0xff 118D 19 NOT 118E 16 AND 118F 90 SWAP1 1190 55 SSTORE 1191 61 PUSH2 0x11dc 1194 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @116C memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1175 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @1184 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1186 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @1190 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x11dc label_1195: // Incoming jump from 0x1153, if !(0xff & storage[keccak256(memory[0x00:0x40])]) 1195 5B JUMPDEST 1196 60 PUSH1 0x01 1198 60 PUSH1 0x39 119A 60 PUSH1 0x00 119C 61 PUSH2 0x11a3 119F 61 PUSH2 0x18ef 11A2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1196 stack[0] = 0x01 // @1198 stack[1] = 0x39 // @119A stack[2] = 0x00 // @119C stack[3] = 0x11a3 // } // Block ends with call to 0x18ef, returns to 0x11A3 label_11A3: // Incoming return from call to 0x18EF at 0x11A2 // Inputs[8] // { // @11AC stack[-1] // @11AF stack[-2] // @11B6 stack[-3] // @11C3 memory[0x00:0x00 + 0x40 + stack[-2]] // @11C5 stack[-5] // @11CC memory[0x00:0x40] // @11CE storage[keccak256(memory[0x00:0x40])] // @11D3 stack[-4] // } 11A3 5B JUMPDEST 11A4 60 PUSH1 0x01 11A6 60 PUSH1 0x01 11A8 60 PUSH1 0xa0 11AA 1B SHL 11AB 03 SUB 11AC 90 SWAP1 11AD 81 DUP2 11AE 16 AND 11AF 82 DUP3 11B0 52 MSTORE 11B1 60 PUSH1 0x20 11B3 80 DUP1 11B4 83 DUP4 11B5 01 ADD 11B6 93 SWAP4 11B7 90 SWAP1 11B8 93 SWAP4 11B9 52 MSTORE 11BA 60 PUSH1 0x40 11BC 91 SWAP2 11BD 82 DUP3 11BE 01 ADD 11BF 60 PUSH1 0x00 11C1 90 SWAP1 11C2 81 DUP2 11C3 20 SHA3 11C4 91 SWAP2 11C5 86 DUP7 11C6 16 AND 11C7 81 DUP2 11C8 52 MSTORE 11C9 92 SWAP3 11CA 52 MSTORE 11CB 90 SWAP1 11CC 20 SHA3 11CD 80 DUP1 11CE 54 SLOAD 11CF 60 PUSH1 0xff 11D1 19 NOT 11D2 16 AND 11D3 91 SWAP2 11D4 15 ISZERO 11D5 15 ISZERO 11D6 91 SWAP2 11D7 90 SWAP1 11D8 91 SWAP2 11D9 17 OR 11DA 90 SWAP1 11DB 55 SSTORE 11DC 5B JUMPDEST 11DD 61 PUSH2 0x11e4 11E0 61 PUSH2 0x18ef 11E3 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @11B0 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @11B9 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @11C8 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @11CA memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @11DB storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @11DD stack[-4] = 0x11e4 // } // Block ends with call to 0x18ef, returns to 0x11E4 label_11E4: // Incoming return from call to 0x18EF at 0x11E3 // Incoming return from call to 0x18EF at 0x11E3 // Inputs[6] // { // @11ED stack[-1] // @11EE stack[-2] // @121B memory[0x40:0x60] // @121E memory[0x40:0x60] // @1223 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1225 stack[-3] // } 11E4 5B JUMPDEST 11E5 60 PUSH1 0x01 11E7 60 PUSH1 0x01 11E9 60 PUSH1 0xa0 11EB 1B SHL 11EC 03 SUB 11ED 16 AND 11EE 81 DUP2 11EF 60 PUSH1 0x01 11F1 60 PUSH1 0x01 11F3 60 PUSH1 0xa0 11F5 1B SHL 11F6 03 SUB 11F7 16 AND 11F8 7F PUSH32 0xf4caeb2d6ca8932a215a353d0703c326ec2d81fc68170f320eb2ab49e9df61f9 1219 60 PUSH1 0x40 121B 51 MLOAD 121C 60 PUSH1 0x40 121E 51 MLOAD 121F 80 DUP1 1220 91 SWAP2 1221 03 SUB 1222 90 SWAP1 1223 A3 LOG3 1224 50 POP 1225 56 *JUMP // Stack delta = -3 // Outputs[1] { @1223 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xf4caeb2d6ca8932a215a353d0703c326ec2d81fc68170f320eb2ab49e9df61f9, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-3] label_1226: // Incoming call from 0x0619, returns to 0x01BD // Inputs[2] // { // @122A storage[0x36] // @122E memory[0x40:0x60] // } 1226 5B JUMPDEST 1227 60 PUSH1 0x36 1229 80 DUP1 122A 54 SLOAD 122B 60 PUSH1 0x40 122D 80 DUP1 122E 51 MLOAD 122F 60 PUSH1 0x20 1231 60 PUSH1 0x1f 1233 60 PUSH1 0x02 1235 60 PUSH1 0x00 1237 19 NOT 1238 61 PUSH2 0x0100 123B 60 PUSH1 0x01 123D 88 DUP9 123E 16 AND 123F 15 ISZERO 1240 02 MUL 1241 01 ADD 1242 90 SWAP1 1243 95 SWAP6 1244 16 AND 1245 94 SWAP5 1246 90 SWAP1 1247 94 SWAP5 1248 04 DIV 1249 93 SWAP4 124A 84 DUP5 124B 01 ADD 124C 81 DUP2 124D 90 SWAP1 124E 04 DIV 124F 81 DUP2 1250 02 MUL 1251 82 DUP3 1252 01 ADD 1253 81 DUP2 1254 01 ADD 1255 90 SWAP1 1256 92 SWAP3 1257 52 MSTORE 1258 82 DUP3 1259 81 DUP2 125A 52 MSTORE 125B 60 PUSH1 0x60 125D 93 SWAP4 125E 90 SWAP1 125F 92 SWAP3 1260 90 SWAP1 1261 91 SWAP2 1262 83 DUP4 1263 01 ADD 1264 82 DUP3 1265 82 DUP3 1266 80 DUP1 1267 15 ISZERO 1268 61 PUSH2 0x0b75 126B 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1257 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x36] & !(storage[0x36] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @125A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x36] & !(storage[0x36] & 0x01) * 0x0100 + ~0x00) / 0x02 // @125D stack[0] = 0x60 // @125F stack[1] = memory[0x40:0x60] // @1260 stack[3] = (storage[0x36] & !(storage[0x36] & 0x01) * 0x0100 + ~0x00) / 0x02 // @1261 stack[2] = 0x36 // @1263 stack[4] = memory[0x40:0x60] + 0x20 // @1264 stack[5] = 0x36 // @1265 stack[6] = (storage[0x36] & !(storage[0x36] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x0b75, if !((storage[0x36] & !(storage[0x36] & 0x01) * 0x0100 + ~0x00) / 0x02) label_126C: // Incoming jump from 0x126B, if not !((storage[0x36] & !(storage[0x36] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @126C stack[-1] } 126C 80 DUP1 126D 60 PUSH1 0x1f 126F 10 LT 1270 61 PUSH2 0x0be1 1273 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0be1, if 0x1f < stack[-1] label_1274: // Incoming jump from 0x1273, if not 0x1f < stack[-1] // Inputs[4] // { // @1278 stack[-2] // @1279 storage[stack[-2]] // @127C stack[-3] // @127E stack[-1] // } 1274 61 PUSH2 0x0100 1277 80 DUP1 1278 83 DUP4 1279 54 SLOAD 127A 04 DIV 127B 02 MUL 127C 83 DUP4 127D 52 MSTORE 127E 91 SWAP2 127F 60 PUSH1 0x20 1281 01 ADD 1282 91 SWAP2 1283 61 PUSH2 0x0b75 1286 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @127D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1282 stack[-1] = stack[-1] // @1282 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b75 label_1287: // Incoming jump from 0x06D2 1287 5B JUMPDEST 1288 61 PUSH2 0x12b4 128B 61 PUSH2 0x1292 128E 61 PUSH2 0x18ef 1291 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1288 stack[0] = 0x12b4 // @128B stack[1] = 0x1292 // } // Block ends with call to 0x18ef, returns to 0x1292 label_1292: // Incoming return from call to 0x18EF at 0x1291 1292 5B JUMPDEST 1293 61 PUSH2 0x129a 1296 61 PUSH2 0x18ef 1299 56 *JUMP // Stack delta = +1 // Outputs[1] { @1293 stack[0] = 0x129a } // Block ends with call to 0x18ef, returns to 0x129A label_129A: // Incoming return from call to 0x18EF at 0x1299 // Inputs[4] // { // @129B stack[-6] // @129C stack[-5] // @129D stack[-4] // @12A0 memory[0x40:0x60] // } 129A 5B JUMPDEST 129B 85 DUP6 129C 85 DUP6 129D 85 DUP6 129E 60 PUSH1 0x40 12A0 51 MLOAD 12A1 80 DUP1 12A2 60 PUSH1 0x20 12A4 01 ADD 12A5 60 PUSH1 0x40 12A7 52 MSTORE 12A8 80 DUP1 12A9 60 PUSH1 0x00 12AB 81 DUP2 12AC 52 MSTORE 12AD 50 POP 12AE 60 PUSH1 0x01 12B0 61 PUSH2 0x22e7 12B3 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @129B stack[0] = stack[-6] // @129C stack[1] = stack[-5] // @129D stack[2] = stack[-4] // @12A0 stack[3] = memory[0x40:0x60] // @12A7 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @12AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @12AE stack[4] = 0x01 // } // Block ends with unconditional jump to 0x22e7 12B4 5B JUMPDEST 12B5 50 POP 12B6 50 POP 12B7 50 POP 12B8 56 *JUMP label_12B9: // Incoming jump from 0x06FE // Inputs[1] { @12C4 stack[-2] } 12B9 5B JUMPDEST 12BA 60 PUSH1 0x00 12BC 60 PUSH1 0x01 12BE 60 PUSH1 0x01 12C0 60 PUSH1 0xa0 12C2 1B SHL 12C3 03 SUB 12C4 83 DUP4 12C5 16 AND 12C6 61 PUSH2 0x1300 12C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12BA stack[0] = 0x00 } // Block ends with conditional jump to 0x1300, if stack[-2] & (0x01 << 0xa0) - 0x01 label_12CA: // Incoming jump from 0x12C9, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @12CC memory[0x40:0x60] // @12FA memory[0x40:0x60] // @12FF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12CA 60 PUSH1 0x40 12CC 51 MLOAD 12CD 62 PUSH3 0x461bcd 12D1 60 PUSH1 0xe5 12D3 1B SHL 12D4 81 DUP2 12D5 52 MSTORE 12D6 60 PUSH1 0x04 12D8 01 ADD 12D9 80 DUP1 12DA 80 DUP1 12DB 60 PUSH1 0x20 12DD 01 ADD 12DE 82 DUP3 12DF 81 DUP2 12E0 03 SUB 12E1 82 DUP3 12E2 52 MSTORE 12E3 60 PUSH1 0x24 12E5 81 DUP2 12E6 52 MSTORE 12E7 60 PUSH1 0x20 12E9 01 ADD 12EA 80 DUP1 12EB 61 PUSH2 0x2994 12EE 60 PUSH1 0x24 12F0 91 SWAP2 12F1 39 CODECOPY 12F2 60 PUSH1 0x40 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] // { // @12D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12E2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @12E6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @12F1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x2994:0x29b8] // @12FF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1300: // Incoming jump from 0x12C9, if stack[-2] & (0x01 << 0xa0) - 0x01 1300 5B JUMPDEST 1301 60 PUSH1 0x00 1303 61 PUSH2 0x130a 1306 61 PUSH2 0x18ef 1309 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1301 stack[0] = 0x00 // @1303 stack[1] = 0x130a // } // Block ends with call to 0x18ef, returns to 0x130A label_130A: // Incoming return from call to 0x18EF at 0x1309 // Inputs[6] // { // @130B stack[-1] // @130B stack[-2] // @1312 stack[-5] // @1313 stack[-4] // @1316 memory[0x40:0x60] // @1326 memory[0x40:0x60] // } 130A 5B JUMPDEST 130B 90 SWAP1 130C 50 POP 130D 61 PUSH2 0x1338 1310 81 DUP2 1311 82 DUP3 1312 86 DUP7 1313 86 DUP7 1314 60 PUSH1 0x40 1316 51 MLOAD 1317 80 DUP1 1318 60 PUSH1 0x20 131A 01 ADD 131B 60 PUSH1 0x40 131D 52 MSTORE 131E 80 DUP1 131F 60 PUSH1 0x00 1321 81 DUP2 1322 52 MSTORE 1323 50 POP 1324 60 PUSH1 0x40 1326 51 MLOAD 1327 80 DUP1 1328 60 PUSH1 0x20 132A 01 ADD 132B 60 PUSH1 0x40 132D 52 MSTORE 132E 80 DUP1 132F 60 PUSH1 0x00 1331 81 DUP2 1332 52 MSTORE 1333 50 POP 1334 61 PUSH2 0x199a 1337 56 *JUMP // Stack delta = +6 // Outputs[12] // { // @130B stack[-2] = stack[-1] // @130D stack[-1] = 0x1338 // @1310 stack[0] = stack[-1] // @1311 stack[1] = stack[-1] // @1312 stack[2] = stack[-5] // @1313 stack[3] = stack[-4] // @1316 stack[4] = memory[0x40:0x60] // @131D memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1322 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1326 stack[5] = memory[0x40:0x60] // @132D memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1332 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x199a, returns to 0x1338 label_1338: // Incoming return from call to 0x199A at 0x1337 // Inputs[5] // { // @133C stack[-1] // @133E stack[-4] // @133F stack[-3] // @1342 memory[0x40:0x60] // @1352 memory[0x40:0x60] // } 1338 5B JUMPDEST 1339 61 PUSH2 0x1364 133C 81 DUP2 133D 82 DUP3 133E 86 DUP7 133F 86 DUP7 1340 60 PUSH1 0x40 1342 51 MLOAD 1343 80 DUP1 1344 60 PUSH1 0x20 1346 01 ADD 1347 60 PUSH1 0x40 1349 52 MSTORE 134A 80 DUP1 134B 60 PUSH1 0x00 134D 81 DUP2 134E 52 MSTORE 134F 50 POP 1350 60 PUSH1 0x40 1352 51 MLOAD 1353 80 DUP1 1354 60 PUSH1 0x20 1356 01 ADD 1357 60 PUSH1 0x40 1359 52 MSTORE 135A 80 DUP1 135B 60 PUSH1 0x00 135D 81 DUP2 135E 52 MSTORE 135F 50 POP 1360 61 PUSH2 0x1bba 1363 56 *JUMP // Stack delta = +7 // Outputs[11] // { // @1339 stack[0] = 0x1364 // @133C stack[1] = stack[-1] // @133D stack[2] = stack[-1] // @133E stack[3] = stack[-4] // @133F stack[4] = stack[-3] // @1342 stack[5] = memory[0x40:0x60] // @1349 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @134E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1352 stack[6] = memory[0x40:0x60] // @1359 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @135E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1bba 1364 5B JUMPDEST 1365 61 PUSH2 0x0c25 1368 81 DUP2 1369 82 DUP3 136A 86 DUP7 136B 86 DUP7 136C 60 PUSH1 0x40 136E 51 MLOAD 136F 80 DUP1 1370 60 PUSH1 0x20 1372 01 ADD 1373 60 PUSH1 0x40 1375 52 MSTORE 1376 80 DUP1 1377 60 PUSH1 0x00 1379 81 DUP2 137A 52 MSTORE 137B 50 POP 137C 60 PUSH1 0x40 137E 51 MLOAD 137F 80 DUP1 1380 60 PUSH1 0x20 1382 01 ADD 1383 60 PUSH1 0x40 1385 52 MSTORE 1386 80 DUP1 1387 60 PUSH1 0x00 1389 81 DUP2 138A 52 MSTORE 138B 50 POP 138C 60 PUSH1 0x00 138E 61 PUSH2 0x1dde 1391 56 *JUMP label_1392: // Incoming jump from 0x0FB5 // Incoming jump from 0x08A9 // Inputs[1] { @1395 storage[0x00] } 1392 5B JUMPDEST 1393 60 PUSH1 0x00 1395 54 SLOAD 1396 61 PUSH2 0x0100 1399 90 SWAP1 139A 04 DIV 139B 60 PUSH1 0xff 139D 16 AND 139E 80 DUP1 139F 61 PUSH2 0x13ab 13A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @139D stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x13ab, if 0xff & storage[0x00] / 0x0100 label_13A3: // Incoming jump from 0x13A2, if not 0xff & storage[0x00] / 0x0100 13A3 50 POP 13A4 61 PUSH2 0x13ab 13A7 61 PUSH2 0x20f1 13AA 56 *JUMP // Stack delta = +0 // Outputs[1] { @13A4 stack[-1] = 0x13ab } // Block ends with call to 0x20f1, returns to 0x13AB label_13AB: // Incoming jump from 0x13A2, if 0xff & storage[0x00] / 0x0100 // Incoming return from call to 0x20F1 at 0x13AA // Inputs[1] { @13AC stack[-1] } 13AB 5B JUMPDEST 13AC 80 DUP1 13AD 61 PUSH2 0x13b9 13B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13b9, if stack[-1] label_13B1: // Incoming jump from 0x13B0, if not stack[-1] // Inputs[1] { @13B4 storage[0x00] } 13B1 50 POP 13B2 60 PUSH1 0x00 13B4 54 SLOAD 13B5 60 PUSH1 0xff 13B7 16 AND 13B8 15 ISZERO 13B9 5B JUMPDEST 13BA 61 PUSH2 0x13f4 13BD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13f4, if !(0xff & storage[0x00]) label_13BE: // Incoming jump from 0x13BD, if not !(0xff & storage[0x00]) // Incoming jump from 0x13BD, if not stack[-1] // Inputs[3] // { // @13C0 memory[0x40:0x60] // @13EE memory[0x40:0x60] // @13F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 13BE 60 PUSH1 0x40 13C0 51 MLOAD 13C1 62 PUSH3 0x461bcd 13C5 60 PUSH1 0xe5 13C7 1B SHL 13C8 81 DUP2 13C9 52 MSTORE 13CA 60 PUSH1 0x04 13CC 01 ADD 13CD 80 DUP1 13CE 80 DUP1 13CF 60 PUSH1 0x20 13D1 01 ADD 13D2 82 DUP3 13D3 81 DUP2 13D4 03 SUB 13D5 82 DUP3 13D6 52 MSTORE 13D7 60 PUSH1 0x2e 13D9 81 DUP2 13DA 52 MSTORE 13DB 60 PUSH1 0x20 13DD 01 ADD 13DE 80 DUP1 13DF 61 PUSH2 0x2966 13E2 60 PUSH1 0x2e 13E4 91 SWAP2 13E5 39 CODECOPY 13E6 60 PUSH1 0x40 13E8 01 ADD 13E9 91 SWAP2 13EA 50 POP 13EB 50 POP 13EC 60 PUSH1 0x40 13EE 51 MLOAD 13EF 80 DUP1 13F0 91 SWAP2 13F1 03 SUB 13F2 90 SWAP1 13F3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @13C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13D6 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @13DA memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @13E5 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x2966:0x2994] // @13F3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_13F4: // Incoming jump from 0x13BD, if !(0xff & storage[0x00]) // Incoming jump from 0x13BD, if stack[-1] // Inputs[1] { @13F7 storage[0x00] } 13F4 5B JUMPDEST 13F5 60 PUSH1 0x00 13F7 54 SLOAD 13F8 61 PUSH2 0x0100 13FB 90 SWAP1 13FC 04 DIV 13FD 60 PUSH1 0xff 13FF 16 AND 1400 15 ISZERO 1401 80 DUP1 1402 15 ISZERO 1403 61 PUSH2 0x141f 1406 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1400 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x141f, if !!(0xff & storage[0x00] / 0x0100) label_1407: // Incoming jump from 0x1406, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[3] // { // @140A storage[0x00] // @1420 stack[-4] // @1421 memory[stack[-4]:stack[-4] + 0x20] // } 1407 60 PUSH1 0x00 1409 80 DUP1 140A 54 SLOAD 140B 60 PUSH1 0xff 140D 19 NOT 140E 61 PUSH2 0xff00 1411 19 NOT 1412 90 SWAP1 1413 91 SWAP2 1414 16 AND 1415 61 PUSH2 0x0100 1418 17 OR 1419 16 AND 141A 60 PUSH1 0x01 141C 17 OR 141D 90 SWAP1 141E 55 SSTORE 141F 5B JUMPDEST 1420 83 DUP4 1421 51 MLOAD 1422 61 PUSH2 0x1432 1425 90 SWAP1 1426 60 PUSH1 0x35 1428 90 SWAP1 1429 60 PUSH1 0x20 142B 87 DUP8 142C 01 ADD 142D 90 SWAP1 142E 61 PUSH2 0x2772 1431 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @141E storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @1425 stack[0] = 0x1432 // @1428 stack[1] = 0x35 // @142D stack[2] = stack[-4] + 0x20 // @142D stack[3] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with unconditional jump to 0x2772 1432 5B JUMPDEST 1433 50 POP 1434 82 DUP3 1435 51 MLOAD 1436 61 PUSH2 0x1446 1439 90 SWAP1 143A 60 PUSH1 0x36 143C 90 SWAP1 143D 60 PUSH1 0x20 143F 86 DUP7 1440 01 ADD 1441 90 SWAP1 1442 61 PUSH2 0x2772 1445 56 *JUMP 1446 5B JUMPDEST 1447 50 POP 1448 81 DUP2 1449 51 MLOAD 144A 61 PUSH2 0x145a 144D 90 SWAP1 144E 60 PUSH1 0x37 1450 90 SWAP1 1451 60 PUSH1 0x20 1453 85 DUP6 1454 01 ADD 1455 90 SWAP1 1456 61 PUSH2 0x27f0 1459 56 *JUMP 145A 5B JUMPDEST 145B 50 POP 145C 60 PUSH1 0x00 145E 5B JUMPDEST 145F 60 PUSH1 0x37 1461 54 SLOAD 1462 81 DUP2 1463 10 LT 1464 15 ISZERO 1465 61 PUSH2 0x14b7 1468 57 *JUMPI 1469 60 PUSH1 0x01 146B 60 PUSH1 0x38 146D 60 PUSH1 0x00 146F 60 PUSH1 0x37 1471 84 DUP5 1472 81 DUP2 1473 54 SLOAD 1474 81 DUP2 1475 10 LT 1476 61 PUSH2 0x147b 1479 57 *JUMPI 147A FE *ASSERT 147B 5B JUMPDEST 147C 60 PUSH1 0x00 147E 91 SWAP2 147F 82 DUP3 1480 52 MSTORE 1481 60 PUSH1 0x20 1483 80 DUP1 1484 83 DUP4 1485 20 SHA3 1486 91 SWAP2 1487 90 SWAP1 1488 91 SWAP2 1489 01 ADD 148A 54 SLOAD 148B 60 PUSH1 0x01 148D 60 PUSH1 0x01 148F 60 PUSH1 0xa0 1491 1B SHL 1492 03 SUB 1493 16 AND 1494 83 DUP4 1495 52 MSTORE 1496 82 DUP3 1497 01 ADD 1498 92 SWAP3 1499 90 SWAP1 149A 92 SWAP3 149B 52 MSTORE 149C 60 PUSH1 0x40 149E 01 ADD 149F 90 SWAP1 14A0 20 SHA3 14A1 80 DUP1 14A2 54 SLOAD 14A3 60 PUSH1 0xff 14A5 19 NOT 14A6 16 AND 14A7 91 SWAP2 14A8 15 ISZERO 14A9 15 ISZERO 14AA 91 SWAP2 14AB 90 SWAP1 14AC 91 SWAP2 14AD 17 OR 14AE 90 SWAP1 14AF 55 SSTORE 14B0 60 PUSH1 0x01 14B2 01 ADD 14B3 61 PUSH2 0x145e 14B6 56 *JUMP 14B7 5B JUMPDEST 14B8 50 POP 14B9 60 PUSH1 0x40 14BB 80 DUP1 14BC 51 MLOAD 14BD 6A PUSH11 0x22a9219b9b9baa37b5b2b7 14C9 60 PUSH1 0xa9 14CB 1B SHL 14CC 81 DUP2 14CD 52 MSTORE 14CE 81 DUP2 14CF 51 MLOAD 14D0 90 SWAP1 14D1 81 DUP2 14D2 90 SWAP1 14D3 03 SUB 14D4 60 PUSH1 0x0b 14D6 01 ADD 14D7 81 DUP2 14D8 20 SHA3 14D9 63 PUSH4 0x29965a1d 14DE 60 PUSH1 0xe0 14E0 1B SHL 14E1 82 DUP3 14E2 52 MSTORE 14E3 30 ADDRESS 14E4 60 PUSH1 0x04 14E6 83 DUP4 14E7 01 ADD 14E8 81 DUP2 14E9 90 SWAP1 14EA 52 MSTORE 14EB 60 PUSH1 0x24 14ED 83 DUP4 14EE 01 ADD 14EF 91 SWAP2 14F0 90 SWAP1 14F1 91 SWAP2 14F2 52 MSTORE 14F3 60 PUSH1 0x44 14F5 82 DUP3 14F6 01 ADD 14F7 52 MSTORE 14F8 90 SWAP1 14F9 51 MLOAD 14FA 73 PUSH20 0x1820a4b7618bde71dce8cdc73aab6c95905fad24 150F 91 SWAP2 1510 63 PUSH4 0x29965a1d 1515 91 SWAP2 1516 60 PUSH1 0x64 1518 80 DUP1 1519 83 DUP4 151A 01 ADD 151B 92 SWAP3 151C 60 PUSH1 0x00 151E 92 SWAP3 151F 91 SWAP2 1520 90 SWAP1 1521 82 DUP3 1522 90 SWAP1 1523 03 SUB 1524 01 ADD 1525 81 DUP2 1526 83 DUP4 1527 87 DUP8 1528 80 DUP1 1529 3B EXTCODESIZE 152A 15 ISZERO 152B 80 DUP1 152C 15 ISZERO 152D 61 PUSH2 0x1535 1530 57 *JUMPI 1531 60 PUSH1 0x00 1533 80 DUP1 1534 FD *REVERT 1535 5B JUMPDEST 1536 50 POP 1537 5A GAS 1538 F1 CALL 1539 15 ISZERO 153A 80 DUP1 153B 15 ISZERO 153C 61 PUSH2 0x1549 153F 57 *JUMPI 1540 3D RETURNDATASIZE 1541 60 PUSH1 0x00 1543 80 DUP1 1544 3E RETURNDATACOPY 1545 3D RETURNDATASIZE 1546 60 PUSH1 0x00 1548 FD *REVERT 1549 5B JUMPDEST 154A 50 POP 154B 50 POP 154C 60 PUSH1 0x40 154E 80 DUP1 154F 51 MLOAD 1550 69 PUSH10 0x22a92199182a37b5b2b7 155B 60 PUSH1 0xb1 155D 1B SHL 155E 81 DUP2 155F 52 MSTORE 1560 81 DUP2 1561 51 MLOAD 1562 90 SWAP1 1563 81 DUP2 1564 90 SWAP1 1565 03 SUB 1566 60 PUSH1 0x0a 1568 01 ADD 1569 81 DUP2 156A 20 SHA3 156B 63 PUSH4 0x29965a1d 1570 60 PUSH1 0xe0 1572 1B SHL 1573 82 DUP3 1574 52 MSTORE 1575 30 ADDRESS 1576 60 PUSH1 0x04 1578 83 DUP4 1579 01 ADD 157A 81 DUP2 157B 90 SWAP1 157C 52 MSTORE 157D 60 PUSH1 0x24 157F 83 DUP4 1580 01 ADD 1581 91 SWAP2 1582 90 SWAP1 1583 91 SWAP2 1584 52 MSTORE 1585 60 PUSH1 0x44 1587 82 DUP3 1588 01 ADD 1589 52 MSTORE 158A 90 SWAP1 158B 51 MLOAD 158C 73 PUSH20 0x1820a4b7618bde71dce8cdc73aab6c95905fad24 15A1 93 SWAP4 15A2 50 POP 15A3 63 PUSH4 0x29965a1d 15A8 92 SWAP3 15A9 50 POP 15AA 60 PUSH1 0x64 15AC 80 DUP1 15AD 83 DUP4 15AE 01 ADD 15AF 92 SWAP3 15B0 60 PUSH1 0x00 15B2 92 SWAP3 15B3 91 SWAP2 15B4 90 SWAP1 15B5 82 DUP3 15B6 90 SWAP1 15B7 03 SUB 15B8 01 ADD 15B9 81 DUP2 15BA 83 DUP4 15BB 87 DUP8 15BC 80 DUP1 15BD 3B EXTCODESIZE 15BE 15 ISZERO 15BF 80 DUP1 15C0 15 ISZERO 15C1 61 PUSH2 0x15c9 15C4 57 *JUMPI 15C5 60 PUSH1 0x00 15C7 80 DUP1 15C8 FD *REVERT 15C9 5B JUMPDEST 15CA 50 POP 15CB 5A GAS 15CC F1 CALL 15CD 15 ISZERO 15CE 80 DUP1 15CF 15 ISZERO 15D0 61 PUSH2 0x15dd 15D3 57 *JUMPI 15D4 3D RETURNDATASIZE 15D5 60 PUSH1 0x00 15D7 80 DUP1 15D8 3E RETURNDATACOPY 15D9 3D RETURNDATASIZE 15DA 60 PUSH1 0x00 15DC FD *REVERT 15DD 5B JUMPDEST 15DE 50 POP 15DF 50 POP 15E0 50 POP 15E1 50 POP 15E2 80 DUP1 15E3 15 ISZERO 15E4 61 PUSH2 0x15f3 15E7 57 *JUMPI 15E8 60 PUSH1 0x00 15EA 80 DUP1 15EB 54 SLOAD 15EC 61 PUSH2 0xff00 15EF 19 NOT 15F0 16 AND 15F1 90 SWAP1 15F2 55 SSTORE 15F3 5B JUMPDEST 15F4 50 POP 15F5 50 POP 15F6 50 POP 15F7 50 POP 15F8 56 *JUMP label_15F9: // Incoming jump from 0x1048 // Incoming jump from 0x1822 // Incoming jump from 0x08D7 // Inputs[2] // { // @15FC stack[-1] // @1606 stack[-2] // } 15F9 5B JUMPDEST 15FA 60 PUSH1 0x00 15FC 81 DUP2 15FD 60 PUSH1 0x01 15FF 60 PUSH1 0x01 1601 60 PUSH1 0xa0 1603 1B SHL 1604 03 SUB 1605 16 AND 1606 83 DUP4 1607 60 PUSH1 0x01 1609 60 PUSH1 0x01 160B 60 PUSH1 0xa0 160D 1B SHL 160E 03 SUB 160F 16 AND 1610 14 EQ 1611 80 DUP1 1612 61 PUSH2 0x1664 1615 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @15FA stack[0] = 0x00 // @1610 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x1664, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] label_1616: // Incoming jump from 0x1615, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[3] // { // @161F stack[-4] // @162E memory[0x00:0x40] // @162F storage[keccak256(memory[0x00:0x40])] // } 1616 50 POP 1617 60 PUSH1 0x01 1619 60 PUSH1 0x01 161B 60 PUSH1 0xa0 161D 1B SHL 161E 03 SUB 161F 83 DUP4 1620 16 AND 1621 60 PUSH1 0x00 1623 90 SWAP1 1624 81 DUP2 1625 52 MSTORE 1626 60 PUSH1 0x38 1628 60 PUSH1 0x20 162A 52 MSTORE 162B 60 PUSH1 0x40 162D 90 SWAP1 162E 20 SHA3 162F 54 SLOAD 1630 60 PUSH1 0xff 1632 16 AND 1633 80 DUP1 1634 15 ISZERO 1635 61 PUSH2 0x1664 1638 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1625 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @162A memory[0x20:0x40] = 0x38 // @1632 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1664, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1639: // Incoming jump from 0x1638, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[5] // { // @1643 stack[-3] // @1655 memory[0x00:0x40] // @1657 stack[-4] // @165E memory[0x00:0x40] // @165F storage[keccak256(memory[0x00:0x40])] // } 1639 50 POP 163A 60 PUSH1 0x01 163C 60 PUSH1 0x01 163E 60 PUSH1 0xa0 1640 1B SHL 1641 03 SUB 1642 80 DUP1 1643 83 DUP4 1644 16 AND 1645 60 PUSH1 0x00 1647 90 SWAP1 1648 81 DUP2 1649 52 MSTORE 164A 60 PUSH1 0x3a 164C 60 PUSH1 0x20 164E 90 SWAP1 164F 81 DUP2 1650 52 MSTORE 1651 60 PUSH1 0x40 1653 80 DUP1 1654 83 DUP4 1655 20 SHA3 1656 93 SWAP4 1657 87 DUP8 1658 16 AND 1659 83 DUP4 165A 52 MSTORE 165B 92 SWAP3 165C 90 SWAP1 165D 52 MSTORE 165E 20 SHA3 165F 54 SLOAD 1660 60 PUSH1 0xff 1662 16 AND 1663 15 ISZERO // Stack delta = +0 // Outputs[5] // { // @1649 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1650 memory[0x20:0x40] = 0x3a // @165A memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @165D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1663 stack[-1] = !(0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block continues label_1664: // Incoming jump from 0x1638, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1615, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x1663 // Inputs[1] { @1665 stack[-1] } 1664 5B JUMPDEST 1665 80 DUP1 1666 61 PUSH2 0x1694 1669 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1694, if stack[-1] label_166A: // Incoming jump from 0x1669, if not stack[-1] // Inputs[6] // { // @1674 stack[-3] // @1686 memory[0x00:0x40] // @1688 stack[-4] // @168F memory[0x00:0x40] // @1690 storage[keccak256(memory[0x00:0x40])] // @1695 stack[-5] // } 166A 50 POP 166B 60 PUSH1 0x01 166D 60 PUSH1 0x01 166F 60 PUSH1 0xa0 1671 1B SHL 1672 03 SUB 1673 80 DUP1 1674 83 DUP4 1675 16 AND 1676 60 PUSH1 0x00 1678 90 SWAP1 1679 81 DUP2 167A 52 MSTORE 167B 60 PUSH1 0x39 167D 60 PUSH1 0x20 167F 90 SWAP1 1680 81 DUP2 1681 52 MSTORE 1682 60 PUSH1 0x40 1684 80 DUP1 1685 83 DUP4 1686 20 SHA3 1687 93 SWAP4 1688 87 DUP8 1689 16 AND 168A 83 DUP4 168B 52 MSTORE 168C 92 SWAP3 168D 90 SWAP1 168E 52 MSTORE 168F 20 SHA3 1690 54 SLOAD 1691 60 PUSH1 0xff 1693 16 AND 1694 5B JUMPDEST 1695 93 SWAP4 1696 92 SWAP3 1697 50 POP 1698 50 POP 1699 50 POP 169A 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @167A memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1681 memory[0x20:0x40] = 0x39 // @168B memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @168E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1695 stack[-5] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-5] label_169B: // Incoming jump from 0x0905 // Inputs[6] // { // @16A4 stack[-2] // @16B7 memory[0x00:0x40] // @16B8 stack[-1] // @16C2 memory[0x00:0x40] // @16C3 storage[keccak256(memory[0x00:0x40])] // @16C4 stack[-3] // } 169B 5B JUMPDEST 169C 60 PUSH1 0x01 169E 60 PUSH1 0x01 16A0 60 PUSH1 0xa0 16A2 1B SHL 16A3 03 SUB 16A4 91 SWAP2 16A5 82 DUP3 16A6 16 AND 16A7 60 PUSH1 0x00 16A9 90 SWAP1 16AA 81 DUP2 16AB 52 MSTORE 16AC 60 PUSH1 0x3b 16AE 60 PUSH1 0x20 16B0 90 SWAP1 16B1 81 DUP2 16B2 52 MSTORE 16B3 60 PUSH1 0x40 16B5 80 DUP1 16B6 83 DUP4 16B7 20 SHA3 16B8 93 SWAP4 16B9 90 SWAP1 16BA 94 SWAP5 16BB 16 AND 16BC 82 DUP3 16BD 52 MSTORE 16BE 91 SWAP2 16BF 90 SWAP1 16C0 91 SWAP2 16C1 52 MSTORE 16C2 20 SHA3 16C3 54 SLOAD 16C4 90 SWAP1 16C5 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @16AB memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @16B2 memory[0x20:0x40] = 0x3b // @16BD memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @16C1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @16C4 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_16C6: // Incoming jump from 0x092B 16C6 5B JUMPDEST 16C7 61 PUSH2 0x16ce 16CA 61 PUSH2 0x18ef 16CD 56 *JUMP // Stack delta = +1 // Outputs[1] { @16C7 stack[0] = 0x16ce } // Block ends with call to 0x18ef, returns to 0x16CE label_16CE: // Incoming return from call to 0x18EF at 0x16CD // Inputs[2] // { // @16D7 stack[-1] // @16D8 stack[-2] // } 16CE 5B JUMPDEST 16CF 60 PUSH1 0x01 16D1 60 PUSH1 0x01 16D3 60 PUSH1 0xa0 16D5 1B SHL 16D6 03 SUB 16D7 16 AND 16D8 81 DUP2 16D9 60 PUSH1 0x01 16DB 60 PUSH1 0x01 16DD 60 PUSH1 0xa0 16DF 1B SHL 16E0 03 SUB 16E1 16 AND 16E2 14 EQ 16E3 15 ISZERO 16E4 61 PUSH2 0x171e 16E7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x171e, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_16E8: // Incoming jump from 0x16E7, if not !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @16EA memory[0x40:0x60] // @1718 memory[0x40:0x60] // @171D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16E8 60 PUSH1 0x40 16EA 51 MLOAD 16EB 62 PUSH3 0x461bcd 16EF 60 PUSH1 0xe5 16F1 1B SHL 16F2 81 DUP2 16F3 52 MSTORE 16F4 60 PUSH1 0x04 16F6 01 ADD 16F7 80 DUP1 16F8 80 DUP1 16F9 60 PUSH1 0x20 16FB 01 ADD 16FC 82 DUP3 16FD 81 DUP2 16FE 03 SUB 16FF 82 DUP3 1700 52 MSTORE 1701 60 PUSH1 0x21 1703 81 DUP2 1704 52 MSTORE 1705 60 PUSH1 0x20 1707 01 ADD 1708 80 DUP1 1709 61 PUSH2 0x28f8 170C 60 PUSH1 0x21 170E 91 SWAP2 170F 39 CODECOPY 1710 60 PUSH1 0x40 1712 01 ADD 1713 91 SWAP2 1714 50 POP 1715 50 POP 1716 60 PUSH1 0x40 1718 51 MLOAD 1719 80 DUP1 171A 91 SWAP2 171B 03 SUB 171C 90 SWAP1 171D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @16F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1700 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1704 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @170F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x28f8:0x2919] // @171D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_171E: // Incoming jump from 0x16E7, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @1727 stack[-1] // @1736 memory[0x00:0x40] // @1737 storage[keccak256(memory[0x00:0x40])] // } 171E 5B JUMPDEST 171F 60 PUSH1 0x01 1721 60 PUSH1 0x01 1723 60 PUSH1 0xa0 1725 1B SHL 1726 03 SUB 1727 81 DUP2 1728 16 AND 1729 60 PUSH1 0x00 172B 90 SWAP1 172C 81 DUP2 172D 52 MSTORE 172E 60 PUSH1 0x38 1730 60 PUSH1 0x20 1732 52 MSTORE 1733 60 PUSH1 0x40 1735 90 SWAP1 1736 20 SHA3 1737 54 SLOAD 1738 60 PUSH1 0xff 173A 16 AND 173B 15 ISZERO 173C 61 PUSH2 0x178a 173F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @172D memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1732 memory[0x20:0x40] = 0x38 // } // Block ends with conditional jump to 0x178a, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1740: // Incoming jump from 0x173F, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) 1740 60 PUSH1 0x01 1742 60 PUSH1 0x3a 1744 60 PUSH1 0x00 1746 61 PUSH2 0x174d 1749 61 PUSH2 0x18ef 174C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1740 stack[0] = 0x01 // @1742 stack[1] = 0x3a // @1744 stack[2] = 0x00 // @1746 stack[3] = 0x174d // } // Block ends with call to 0x18ef, returns to 0x174D label_174D: // Incoming return from call to 0x18EF at 0x174C // Inputs[8] // { // @1756 stack[-1] // @1759 stack[-2] // @1760 stack[-3] // @176D memory[0x00:0x00 + 0x40 + stack[-2]] // @176F stack[-5] // @1776 memory[0x00:0x40] // @1778 storage[keccak256(memory[0x00:0x40])] // @177D stack[-4] // } 174D 5B JUMPDEST 174E 60 PUSH1 0x01 1750 60 PUSH1 0x01 1752 60 PUSH1 0xa0 1754 1B SHL 1755 03 SUB 1756 90 SWAP1 1757 81 DUP2 1758 16 AND 1759 82 DUP3 175A 52 MSTORE 175B 60 PUSH1 0x20 175D 80 DUP1 175E 83 DUP4 175F 01 ADD 1760 93 SWAP4 1761 90 SWAP1 1762 93 SWAP4 1763 52 MSTORE 1764 60 PUSH1 0x40 1766 91 SWAP2 1767 82 DUP3 1768 01 ADD 1769 60 PUSH1 0x00 176B 90 SWAP1 176C 81 DUP2 176D 20 SHA3 176E 91 SWAP2 176F 86 DUP7 1770 16 AND 1771 81 DUP2 1772 52 MSTORE 1773 92 SWAP3 1774 52 MSTORE 1775 90 SWAP1 1776 20 SHA3 1777 80 DUP1 1778 54 SLOAD 1779 60 PUSH1 0xff 177B 19 NOT 177C 16 AND 177D 91 SWAP2 177E 15 ISZERO 177F 15 ISZERO 1780 91 SWAP2 1781 90 SWAP1 1782 91 SWAP2 1783 17 OR 1784 90 SWAP1 1785 55 SSTORE 1786 61 PUSH2 0x17c8 1789 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @175A memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1763 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @1772 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1774 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @1785 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to 0x17c8 label_178A: // Incoming jump from 0x173F, if !(0xff & storage[keccak256(memory[0x00:0x40])]) 178A 5B JUMPDEST 178B 60 PUSH1 0x39 178D 60 PUSH1 0x00 178F 61 PUSH2 0x1796 1792 61 PUSH2 0x18ef 1795 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @178B stack[0] = 0x39 // @178D stack[1] = 0x00 // @178F stack[2] = 0x1796 // } // Block ends with call to 0x18ef, returns to 0x1796 label_1796: // Incoming return from call to 0x18EF at 0x1795 // Inputs[7] // { // @179F stack[-1] // @17A2 stack[-2] // @17A9 stack[-3] // @17B6 memory[0x00:0x00 + 0x40 + stack[-2]] // @17B8 stack[-4] // @17BF memory[0x00:0x40] // @17C1 storage[keccak256(memory[0x00:0x40])] // } 1796 5B JUMPDEST 1797 60 PUSH1 0x01 1799 60 PUSH1 0x01 179B 60 PUSH1 0xa0 179D 1B SHL 179E 03 SUB 179F 90 SWAP1 17A0 81 DUP2 17A1 16 AND 17A2 82 DUP3 17A3 52 MSTORE 17A4 60 PUSH1 0x20 17A6 80 DUP1 17A7 83 DUP4 17A8 01 ADD 17A9 93 SWAP4 17AA 90 SWAP1 17AB 93 SWAP4 17AC 52 MSTORE 17AD 60 PUSH1 0x40 17AF 91 SWAP2 17B0 82 DUP3 17B1 01 ADD 17B2 60 PUSH1 0x00 17B4 90 SWAP1 17B5 81 DUP2 17B6 20 SHA3 17B7 91 SWAP2 17B8 85 DUP6 17B9 16 AND 17BA 81 DUP2 17BB 52 MSTORE 17BC 92 SWAP3 17BD 52 MSTORE 17BE 90 SWAP1 17BF 20 SHA3 17C0 80 DUP1 17C1 54 SLOAD 17C2 60 PUSH1 0xff 17C4 19 NOT 17C5 16 AND 17C6 90 SWAP1 17C7 55 SSTORE 17C8 5B JUMPDEST 17C9 61 PUSH2 0x17d0 17CC 61 PUSH2 0x18ef 17CF 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @17A3 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @17AC memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @17BB memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @17BD memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @17C7 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @17C9 stack[-3] = 0x17d0 // } // Block ends with call to 0x18ef, returns to 0x17D0 label_17D0: // Incoming return from call to 0x18EF at 0x17CF // Incoming return from call to 0x18EF at 0x17CF // Inputs[6] // { // @17D9 stack[-1] // @17DA stack[-2] // @1807 memory[0x40:0x60] // @180A memory[0x40:0x60] // @180F memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1811 stack[-3] // } 17D0 5B JUMPDEST 17D1 60 PUSH1 0x01 17D3 60 PUSH1 0x01 17D5 60 PUSH1 0xa0 17D7 1B SHL 17D8 03 SUB 17D9 16 AND 17DA 81 DUP2 17DB 60 PUSH1 0x01 17DD 60 PUSH1 0x01 17DF 60 PUSH1 0xa0 17E1 1B SHL 17E2 03 SUB 17E3 16 AND 17E4 7F PUSH32 0x50546e66e5f44d728365dc3908c63bc5cfeeab470722c1677e3073a6ac294aa1 1805 60 PUSH1 0x40 1807 51 MLOAD 1808 60 PUSH1 0x40 180A 51 MLOAD 180B 80 DUP1 180C 91 SWAP2 180D 03 SUB 180E 90 SWAP1 180F A3 LOG3 1810 50 POP 1811 56 *JUMP // Stack delta = -3 // Outputs[1] { @180F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x50546e66e5f44d728365dc3908c63bc5cfeeab470722c1677e3073a6ac294aa1, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); } // Block ends with unconditional jump to stack[-3] label_1812: // Incoming jump from 0x0A69 1812 5B JUMPDEST 1813 61 PUSH2 0x1823 1816 61 PUSH2 0x181d 1819 61 PUSH2 0x18ef 181C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1813 stack[0] = 0x1823 // @1816 stack[1] = 0x181d // } // Block ends with call to 0x18ef, returns to 0x181D label_181D: // Incoming return from call to 0x18EF at 0x181C // Inputs[1] { @181E stack[-6] } 181D 5B JUMPDEST 181E 85 DUP6 181F 61 PUSH2 0x15f9 1822 56 *JUMP // Stack delta = +1 // Outputs[1] { @181E stack[0] = stack[-6] } // Block ends with unconditional jump to 0x15f9 label_1823: // Incoming return from call to 0x181D at 0x181C // Inputs[1] { @1827 stack[-1] } 1823 5B JUMPDEST 1824 61 PUSH2 0x185e 1827 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x185e, if stack[-1] label_1828: // Incoming jump from 0x1827, if not stack[-1] // Inputs[3] // { // @182A memory[0x40:0x60] // @1858 memory[0x40:0x60] // @185D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1828 60 PUSH1 0x40 182A 51 MLOAD 182B 62 PUSH3 0x461bcd 182F 60 PUSH1 0xe5 1831 1B SHL 1832 81 DUP2 1833 52 MSTORE 1834 60 PUSH1 0x04 1836 01 ADD 1837 80 DUP1 1838 80 DUP1 1839 60 PUSH1 0x20 183B 01 ADD 183C 82 DUP3 183D 81 DUP2 183E 03 SUB 183F 82 DUP3 1840 52 MSTORE 1841 60 PUSH1 0x2c 1843 81 DUP2 1844 52 MSTORE 1845 60 PUSH1 0x20 1847 01 ADD 1848 80 DUP1 1849 61 PUSH2 0x29b8 184C 60 PUSH1 0x2c 184E 91 SWAP2 184F 39 CODECOPY 1850 60 PUSH1 0x40 1852 01 ADD 1853 91 SWAP2 1854 50 POP 1855 50 POP 1856 60 PUSH1 0x40 1858 51 MLOAD 1859 80 DUP1 185A 91 SWAP2 185B 03 SUB 185C 90 SWAP1 185D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1833 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1840 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1844 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @184F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x29b8:0x29e4] // @185D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_185E: // Incoming jump from 0x1827, if stack[-1] 185E 5B JUMPDEST 185F 61 PUSH2 0x15f3 1862 61 PUSH2 0x1869 1865 61 PUSH2 0x18ef 1868 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @185F stack[0] = 0x15f3 // @1862 stack[1] = 0x1869 // } // Block ends with call to 0x18ef, returns to 0x1869 label_1869: // Incoming return from call to 0x18EF at 0x1868 // Inputs[4] // { // @186A stack[-6] // @186B stack[-5] // @186C stack[-4] // @186D stack[-3] // } 1869 5B JUMPDEST 186A 85 DUP6 186B 85 DUP6 186C 85 DUP6 186D 85 DUP6 186E 61 PUSH2 0x2400 1871 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @186A stack[0] = stack[-6] // @186B stack[1] = stack[-5] // @186C stack[2] = stack[-4] // @186D stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x2400 label_1872: // Incoming jump from 0x0B14 1872 5B JUMPDEST 1873 61 PUSH2 0x189c 1876 61 PUSH2 0x187d 1879 61 PUSH2 0x18ef 187C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1873 stack[0] = 0x189c // @1876 stack[1] = 0x187d // } // Block ends with call to 0x18ef, returns to 0x187D label_187D: // Incoming return from call to 0x18EF at 0x187C 187D 5B JUMPDEST 187E 61 PUSH2 0x1885 1881 61 PUSH2 0x18ef 1884 56 *JUMP // Stack delta = +1 // Outputs[1] { @187E stack[0] = 0x1885 } // Block ends with call to 0x18ef, returns to 0x1885 label_1885: // Incoming return from call to 0x18EF at 0x1884 // Inputs[3] // { // @1886 stack[-5] // @1887 stack[-4] // @188A memory[0x40:0x60] // } 1885 5B JUMPDEST 1886 84 DUP5 1887 84 DUP5 1888 60 PUSH1 0x40 188A 51 MLOAD 188B 80 DUP1 188C 60 PUSH1 0x20 188E 01 ADD 188F 60 PUSH1 0x40 1891 52 MSTORE 1892 80 DUP1 1893 60 PUSH1 0x00 1895 81 DUP2 1896 52 MSTORE 1897 50 POP 1898 61 PUSH2 0x2400 189B 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1886 stack[0] = stack[-5] // @1887 stack[1] = stack[-4] // @188A stack[2] = memory[0x40:0x60] // @1891 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1896 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x2400 189C 5B JUMPDEST 189D 50 POP 189E 50 POP 189F 56 *JUMP label_18A0: // Incoming call from 0x0B1C, returns to 0x027A // Inputs[5] // { // @18A4 storage[0x74] // @18A8 memory[0x40:0x60] // @18BF memory[0x40:0x60] // @18EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])] // @18ED stack[-1] // } 18A0 5B JUMPDEST 18A1 60 PUSH1 0x74 18A3 80 DUP1 18A4 54 SLOAD 18A5 60 PUSH1 0x40 18A7 80 DUP1 18A8 51 MLOAD 18A9 60 PUSH1 0x20 18AB 81 DUP2 18AC 01 ADD 18AD 80 DUP1 18AE 83 DUP4 18AF 52 MSTORE 18B0 60 PUSH1 0x01 18B2 84 DUP5 18B3 01 ADD 18B4 85 DUP6 18B5 55 SSTORE 18B6 60 PUSH1 0x00 18B8 94 SWAP5 18B9 85 DUP6 18BA 52 MSTORE 18BB 83 DUP4 18BC 90 SWAP1 18BD 52 MSTORE 18BE 81 DUP2 18BF 51 MLOAD 18C0 7F PUSH32 0x76735e462dae5480c552f970568dc60e35cc3c4c06eb818f77bbb357593bf7fa 18E1 92 SWAP3 18E2 91 SWAP2 18E3 81 DUP2 18E4 90 SWAP1 18E5 03 SUB 18E6 90 SWAP1 18E7 91 SWAP2 18E8 01 ADD 18E9 90 SWAP1 18EA A1 LOG1 18EB 90 SWAP1 18EC 50 POP 18ED 90 SWAP1 18EE 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @18AF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @18B5 storage[0x74] = storage[0x74] + 0x01 // @18BA memory[0x00:0x20] = 0x74 // @18BD memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = storage[0x74] // @18EA log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x76735e462dae5480c552f970568dc60e35cc3c4c06eb818f77bbb357593bf7fa]); // @18ED stack[-1] = storage[0x74] // } // Block ends with unconditional jump to stack[-1] label_18EF: // Incoming call from 0x0CCC, returns to 0x0CCD // Incoming call from 0x17CF, returns to 0x17D0 // Incoming call from 0x17CF, returns to 0x17D0 // Incoming call from 0x174C, returns to 0x174D // Incoming call from 0x187C, returns to 0x187D // Incoming call from 0x115E, returns to 0x115F // Incoming call from 0x1299, returns to 0x129A // Incoming call from 0x16CD, returns to 0x16CE // Incoming call from 0x1309, returns to 0x130A // Incoming call from 0x1795, returns to 0x1796 // Incoming call from 0x11E3, returns to 0x11E4 // Incoming call from 0x10EB, returns to 0x10EC // Incoming call from 0x1884, returns to 0x1885 // Incoming call from 0x0C17, returns to 0x0C18 // Incoming call from 0x11A2, returns to 0x11A3 // Incoming call from 0x1868, returns to 0x1869 // Incoming call from 0x108E, returns to 0x108F // Incoming call from 0x1042, returns to 0x1043 // Incoming call from 0x181C, returns to 0x181D // Incoming call from 0x11E3, returns to 0x11E4 // Incoming call from 0x1291, returns to 0x1292 // Inputs[2] // { // @18F0 msg.sender // @18F1 stack[-1] // } 18EF 5B JUMPDEST 18F0 33 CALLER 18F1 90 SWAP1 18F2 56 *JUMP // Stack delta = +0 // Outputs[1] { @18F1 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_18F3: // Incoming call from 0x0C24, returns to 0x0C25 // Inputs[1] { @18FC stack[-2] } 18F3 5B JUMPDEST 18F4 60 PUSH1 0x01 18F6 60 PUSH1 0x01 18F8 60 PUSH1 0xa0 18FA 1B SHL 18FB 03 SUB 18FC 82 DUP3 18FD 16 AND 18FE 61 PUSH2 0x1938 1901 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1938, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1902: // Incoming jump from 0x1901, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1904 memory[0x40:0x60] // @1932 memory[0x40:0x60] // @1937 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1902 60 PUSH1 0x40 1904 51 MLOAD 1905 62 PUSH3 0x461bcd 1909 60 PUSH1 0xe5 190B 1B SHL 190C 81 DUP2 190D 52 MSTORE 190E 60 PUSH1 0x04 1910 01 ADD 1911 80 DUP1 1912 80 DUP1 1913 60 PUSH1 0x20 1915 01 ADD 1916 82 DUP3 1917 81 DUP2 1918 03 SUB 1919 82 DUP3 191A 52 MSTORE 191B 60 PUSH1 0x23 191D 81 DUP2 191E 52 MSTORE 191F 60 PUSH1 0x20 1921 01 ADD 1922 80 DUP1 1923 61 PUSH2 0x2a33 1926 60 PUSH1 0x23 1928 91 SWAP2 1929 39 CODECOPY 192A 60 PUSH1 0x40 192C 01 ADD 192D 91 SWAP2 192E 50 POP 192F 50 POP 1930 60 PUSH1 0x40 1932 51 MLOAD 1933 80 DUP1 1934 91 SWAP2 1935 03 SUB 1936 90 SWAP1 1937 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @190D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @191A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @191E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @1929 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x2a33:0x2a56] // @1937 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1938: // Incoming jump from 0x1901, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[9] // { // @1942 stack[-3] // @1954 memory[0x00:0x40] // @1956 stack[-2] // @1961 memory[0x00:0x40] // @1962 stack[-1] // @1966 memory[0x40:0x60] // @196B memory[0x40:0x60] // @1995 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @1999 stack[-4] // } 1938 5B JUMPDEST 1939 60 PUSH1 0x01 193B 60 PUSH1 0x01 193D 60 PUSH1 0xa0 193F 1B SHL 1940 03 SUB 1941 80 DUP1 1942 84 DUP5 1943 16 AND 1944 60 PUSH1 0x00 1946 81 DUP2 1947 81 DUP2 1948 52 MSTORE 1949 60 PUSH1 0x3b 194B 60 PUSH1 0x20 194D 90 SWAP1 194E 81 DUP2 194F 52 MSTORE 1950 60 PUSH1 0x40 1952 80 DUP1 1953 83 DUP4 1954 20 SHA3 1955 94 SWAP5 1956 87 DUP8 1957 16 AND 1958 80 DUP1 1959 84 DUP5 195A 52 MSTORE 195B 94 SWAP5 195C 82 DUP3 195D 52 MSTORE 195E 91 SWAP2 195F 82 DUP3 1960 90 SWAP1 1961 20 SHA3 1962 85 DUP6 1963 90 SWAP1 1964 55 SSTORE 1965 81 DUP2 1966 51 MLOAD 1967 85 DUP6 1968 81 DUP2 1969 52 MSTORE 196A 91 SWAP2 196B 51 MLOAD 196C 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 198D 92 SWAP3 198E 81 DUP2 198F 90 SWAP1 1990 03 SUB 1991 90 SWAP1 1992 91 SWAP2 1993 01 ADD 1994 90 SWAP1 1995 A3 LOG3 1996 50 POP 1997 50 POP 1998 50 POP 1999 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @1948 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @194F memory[0x20:0x40] = 0x3b // @195A memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @195D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1964 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1969 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1995 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] label_199A: // Incoming call from 0x0CFA, returns to 0x0CFB // Incoming call from 0x1337, returns to 0x1338 // Incoming call from 0x2394, returns to 0x2395 // Incoming call from 0x2453, returns to 0x2454 // Inputs[6] // { // @199D storage[0x6e] // @19A0 storage[0x6f] // @19A4 memory[0x40:0x60] // @19B7 stack[-5] // @19C8 memory[0x40:0x60] // @19EA address(storage[0x6e] & (0x01 << 0xa0) - 0x01).code.length // } 199A 5B JUMPDEST 199B 60 PUSH1 0x6e 199D 54 SLOAD 199E 60 PUSH1 0x6f 19A0 54 SLOAD 19A1 60 PUSH1 0x40 19A3 80 DUP1 19A4 51 MLOAD 19A5 63 PUSH4 0x555ddc65 19AA 60 PUSH1 0xe1 19AC 1B SHL 19AD 81 DUP2 19AE 52 MSTORE 19AF 60 PUSH1 0x01 19B1 60 PUSH1 0x01 19B3 60 PUSH1 0xa0 19B5 1B SHL 19B6 03 SUB 19B7 89 DUP10 19B8 81 DUP2 19B9 16 AND 19BA 60 PUSH1 0x04 19BC 83 DUP4 19BD 01 ADD 19BE 52 MSTORE 19BF 60 PUSH1 0x24 19C1 82 DUP3 19C2 01 ADD 19C3 93 SWAP4 19C4 90 SWAP1 19C5 93 SWAP4 19C6 52 MSTORE 19C7 90 SWAP1 19C8 51 MLOAD 19C9 60 PUSH1 0x00 19CB 93 SWAP4 19CC 92 SWAP3 19CD 90 SWAP1 19CE 92 SWAP3 19CF 16 AND 19D0 91 SWAP2 19D1 63 PUSH4 0xaabbb8ca 19D6 91 SWAP2 19D7 60 PUSH1 0x44 19D9 80 DUP1 19DA 82 DUP3 19DB 01 ADD 19DC 92 SWAP3 19DD 60 PUSH1 0x20 19DF 92 SWAP3 19E0 90 SWAP1 19E1 91 SWAP2 19E2 90 SWAP1 19E3 82 DUP3 19E4 90 SWAP1 19E5 03 SUB 19E6 01 ADD 19E7 81 DUP2 19E8 86 DUP7 19E9 80 DUP1 19EA 3B EXTCODESIZE 19EB 15 ISZERO 19EC 80 DUP1 19ED 15 ISZERO 19EE 61 PUSH2 0x19f6 19F1 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @19AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x555ddc65 << 0xe1 // @19BE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @19C6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = storage[0x6f] // @19CB stack[0] = 0x00 // @19D0 stack[1] = storage[0x6e] & (0x01 << 0xa0) - 0x01 // @19D6 stack[2] = 0xaabbb8ca // @19DC stack[3] = memory[0x40:0x60] + 0x44 // @19DF stack[4] = 0x20 // @19E1 stack[5] = memory[0x40:0x60] // @19E6 stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @19E7 stack[7] = memory[0x40:0x60] // @19E8 stack[8] = storage[0x6e] & (0x01 << 0xa0) - 0x01 // @19EB stack[9] = !address(storage[0x6e] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x19f6, if !!address(storage[0x6e] & (0x01 << 0xa0) - 0x01).code.length label_19F2: // Incoming jump from 0x19F1, if not !!address(storage[0x6e] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @19F5 memory[0x00:0x00] } 19F2 60 PUSH1 0x00 19F4 80 DUP1 19F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @19F5 revert(memory[0x00:0x00]); } // Block terminates label_19F6: // Incoming jump from 0x19F1, if !!address(storage[0x6e] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @19F8 msg.gas // @19F9 stack[-6] // @19F9 memory[stack[-3]:stack[-3] + stack[-4]] // @19F9 stack[-5] // @19F9 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @19F9 stack[-4] // @19F9 stack[-2] // @19F9 stack[-3] // } 19F6 5B JUMPDEST 19F7 50 POP 19F8 5A GAS 19F9 FA STATICCALL 19FA 15 ISZERO 19FB 80 DUP1 19FC 15 ISZERO 19FD 61 PUSH2 0x1a0a 1A00 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @19F9 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @19FA stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1a0a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1A01: // Incoming jump from 0x1A00, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1A01 returndata.length // @1A05 returndata[0x00:0x00 + returndata.length] // @1A06 returndata.length // @1A09 memory[0x00:0x00 + returndata.length] // } 1A01 3D RETURNDATASIZE 1A02 60 PUSH1 0x00 1A04 80 DUP1 1A05 3E RETURNDATACOPY 1A06 3D RETURNDATASIZE 1A07 60 PUSH1 0x00 1A09 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A05 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1A09 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1A0A: // Incoming jump from 0x1A00, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1A11 memory[0x40:0x60] // @1A12 returndata.length // } 1A0A 5B JUMPDEST 1A0B 50 POP 1A0C 50 POP 1A0D 50 POP 1A0E 50 POP 1A0F 60 PUSH1 0x40 1A11 51 MLOAD 1A12 3D RETURNDATASIZE 1A13 60 PUSH1 0x20 1A15 81 DUP2 1A16 10 LT 1A17 15 ISZERO 1A18 61 PUSH2 0x1a20 1A1B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1A11 stack[-4] = memory[0x40:0x60] // @1A12 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1a20, if !(returndata.length < 0x20) label_1A1C: // Incoming jump from 0x1A1B, if not !(returndata.length < 0x20) // Inputs[1] { @1A1F memory[0x00:0x00] } 1A1C 60 PUSH1 0x00 1A1E 80 DUP1 1A1F FD *REVERT // Stack delta = +0 // Outputs[1] { @1A1F revert(memory[0x00:0x00]); } // Block terminates label_1A20: // Incoming jump from 0x1A1B, if !(returndata.length < 0x20) // Inputs[3] // { // @1A22 memory[stack[-2]:stack[-2] + 0x20] // @1A22 stack[-2] // @1A23 stack[-3] // } 1A20 5B JUMPDEST 1A21 50 POP 1A22 51 MLOAD 1A23 90 SWAP1 1A24 50 POP 1A25 60 PUSH1 0x01 1A27 60 PUSH1 0x01 1A29 60 PUSH1 0xa0 1A2B 1B SHL 1A2C 03 SUB 1A2D 81 DUP2 1A2E 16 AND 1A2F 15 ISZERO 1A30 61 PUSH2 0x1bb1 1A33 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1A23 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1bb1, if !(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01) label_1A34: // Incoming jump from 0x1A33, if not !(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @1A34 stack[-1] // @1A43 stack[-7] // @1A44 stack[-6] // @1A45 stack[-5] // @1A46 stack[-4] // @1A47 stack[-3] // @1A48 stack[-2] // @1A4B memory[0x40:0x60] // @1ABA memory[stack[-3]:stack[-3] + 0x20] // @1AC3 memory[stack[-3]:stack[-3] + 0x20] // } 1A34 80 DUP1 1A35 60 PUSH1 0x01 1A37 60 PUSH1 0x01 1A39 60 PUSH1 0xa0 1A3B 1B SHL 1A3C 03 SUB 1A3D 16 AND 1A3E 63 PUSH4 0x75ab9782 1A43 88 DUP9 1A44 88 DUP9 1A45 88 DUP9 1A46 88 DUP9 1A47 88 DUP9 1A48 88 DUP9 1A49 60 PUSH1 0x40 1A4B 51 MLOAD 1A4C 87 DUP8 1A4D 63 PUSH4 0xffffffff 1A52 16 AND 1A53 60 PUSH1 0xe0 1A55 1B SHL 1A56 81 DUP2 1A57 52 MSTORE 1A58 60 PUSH1 0x04 1A5A 01 ADD 1A5B 80 DUP1 1A5C 87 DUP8 1A5D 60 PUSH1 0x01 1A5F 60 PUSH1 0x01 1A61 60 PUSH1 0xa0 1A63 1B SHL 1A64 03 SUB 1A65 16 AND 1A66 60 PUSH1 0x01 1A68 60 PUSH1 0x01 1A6A 60 PUSH1 0xa0 1A6C 1B SHL 1A6D 03 SUB 1A6E 16 AND 1A6F 81 DUP2 1A70 52 MSTORE 1A71 60 PUSH1 0x20 1A73 01 ADD 1A74 86 DUP7 1A75 60 PUSH1 0x01 1A77 60 PUSH1 0x01 1A79 60 PUSH1 0xa0 1A7B 1B SHL 1A7C 03 SUB 1A7D 16 AND 1A7E 60 PUSH1 0x01 1A80 60 PUSH1 0x01 1A82 60 PUSH1 0xa0 1A84 1B SHL 1A85 03 SUB 1A86 16 AND 1A87 81 DUP2 1A88 52 MSTORE 1A89 60 PUSH1 0x20 1A8B 01 ADD 1A8C 85 DUP6 1A8D 60 PUSH1 0x01 1A8F 60 PUSH1 0x01 1A91 60 PUSH1 0xa0 1A93 1B SHL 1A94 03 SUB 1A95 16 AND 1A96 60 PUSH1 0x01 1A98 60 PUSH1 0x01 1A9A 60 PUSH1 0xa0 1A9C 1B SHL 1A9D 03 SUB 1A9E 16 AND 1A9F 81 DUP2 1AA0 52 MSTORE 1AA1 60 PUSH1 0x20 1AA3 01 ADD 1AA4 84 DUP5 1AA5 81 DUP2 1AA6 52 MSTORE 1AA7 60 PUSH1 0x20 1AA9 01 ADD 1AAA 80 DUP1 1AAB 60 PUSH1 0x20 1AAD 01 ADD 1AAE 80 DUP1 1AAF 60 PUSH1 0x20 1AB1 01 ADD 1AB2 83 DUP4 1AB3 81 DUP2 1AB4 03 SUB 1AB5 83 DUP4 1AB6 52 MSTORE 1AB7 85 DUP6 1AB8 81 DUP2 1AB9 81 DUP2 1ABA 51 MLOAD 1ABB 81 DUP2 1ABC 52 MSTORE 1ABD 60 PUSH1 0x20 1ABF 01 ADD 1AC0 91 SWAP2 1AC1 50 POP 1AC2 80 DUP1 1AC3 51 MLOAD 1AC4 90 SWAP1 1AC5 60 PUSH1 0x20 1AC7 01 ADD 1AC8 90 SWAP1 1AC9 80 DUP1 1ACA 83 DUP4 1ACB 83 DUP4 1ACC 60 PUSH1 0x00 1ACE 5B JUMPDEST 1ACF 83 DUP4 1AD0 81 DUP2 1AD1 10 LT 1AD2 15 ISZERO 1AD3 61 PUSH2 0x1ae6 1AD6 57 *JUMPI // Stack delta = +18 // Outputs[25] // { // @1A3D stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1A3E stack[1] = 0x75ab9782 // @1A43 stack[2] = stack[-7] // @1A44 stack[3] = stack[-6] // @1A45 stack[4] = stack[-5] // @1A46 stack[5] = stack[-4] // @1A47 stack[6] = stack[-3] // @1A48 stack[7] = stack[-2] // @1A57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x75ab9782) << 0xe0 // @1A5A stack[8] = 0x04 + memory[0x40:0x60] // @1A70 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-7] // @1A88 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-6] // @1AA0 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-5] // @1AA6 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-4] // @1AA9 stack[9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1AAD stack[10] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1AB6 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1ABC memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-3]:stack[-3] + 0x20] // @1AC0 stack[11] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1AC8 stack[13] = memory[stack[-3]:stack[-3] + 0x20] // @1AC8 stack[12] = 0x20 + stack[-3] // @1AC9 stack[14] = memory[stack[-3]:stack[-3] + 0x20] // @1ACA stack[15] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1ACB stack[16] = 0x20 + stack[-3] // @1ACC stack[17] = 0x00 // } // Block ends with conditional jump to 0x1ae6, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) label_1AD7: // Incoming jump from 0x1AD6, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1AD6, if not !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @1AD7 stack[-2] // @1AD8 stack[-1] // @1ADA memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1ADB stack[-3] // } 1AD7 81 DUP2 1AD8 81 DUP2 1AD9 01 ADD 1ADA 51 MLOAD 1ADB 83 DUP4 1ADC 82 DUP3 1ADD 01 ADD 1ADE 52 MSTORE 1ADF 60 PUSH1 0x20 1AE1 01 ADD 1AE2 61 PUSH2 0x1ace 1AE5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1ADE memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1AE1 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1ace label_1AE6: // Incoming jump from 0x1AD6, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1AD6, if !(0x00 < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @1AEB stack[-5] // @1AEB stack[-6] // @1AED stack[-7] // } 1AE6 5B JUMPDEST 1AE7 50 POP 1AE8 50 POP 1AE9 50 POP 1AEA 50 POP 1AEB 90 SWAP1 1AEC 50 POP 1AED 90 SWAP1 1AEE 81 DUP2 1AEF 01 ADD 1AF0 90 SWAP1 1AF1 60 PUSH1 0x1f 1AF3 16 AND 1AF4 80 DUP1 1AF5 15 ISZERO 1AF6 61 PUSH2 0x1b13 1AF9 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1AF0 stack[-7] = stack[-5] + stack[-7] // @1AF3 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1b13, if !(0x1f & stack[-5]) label_1AFA: // Incoming jump from 0x1AF9, if not !(0x1f & stack[-5]) // Inputs[8] // { // @1AFA stack[-1] // @1AFB stack[-2] // @1AFE memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1B15 stack[-5] // @1B18 stack[-3] // @1B1A stack[-6] // @1B1B memory[stack[-6]:stack[-6] + 0x20] // @1B1F memory[stack[-6]:stack[-6] + 0x20] // } 1AFA 80 DUP1 1AFB 82 DUP3 1AFC 03 SUB 1AFD 80 DUP1 1AFE 51 MLOAD 1AFF 60 PUSH1 0x01 1B01 83 DUP4 1B02 60 PUSH1 0x20 1B04 03 SUB 1B05 61 PUSH2 0x0100 1B08 0A EXP 1B09 03 SUB 1B0A 19 NOT 1B0B 16 AND 1B0C 81 DUP2 1B0D 52 MSTORE 1B0E 60 PUSH1 0x20 1B10 01 ADD 1B11 91 SWAP2 1B12 50 POP 1B13 5B JUMPDEST 1B14 50 POP 1B15 83 DUP4 1B16 81 DUP2 1B17 03 SUB 1B18 82 DUP3 1B19 52 MSTORE 1B1A 84 DUP5 1B1B 51 MLOAD 1B1C 81 DUP2 1B1D 52 MSTORE 1B1E 84 DUP5 1B1F 51 MLOAD 1B20 60 PUSH1 0x20 1B22 91 SWAP2 1B23 82 DUP3 1B24 01 ADD 1B25 91 SWAP2 1B26 86 DUP7 1B27 01 ADD 1B28 90 SWAP1 1B29 80 DUP1 1B2A 83 DUP4 1B2B 83 DUP4 1B2C 60 PUSH1 0x00 1B2E 5B JUMPDEST 1B2F 83 DUP4 1B30 81 DUP2 1B31 10 LT 1B32 15 ISZERO 1B33 61 PUSH2 0x1b46 1B36 57 *JUMPI // Stack delta = +5 // Outputs[10] // { // @1B0D 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] // @1B19 memory[stack[-3]:stack[-3] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - stack[-5] // @1B1D memory[0x20 + (stack[-2] - stack[-1]):0x20 + (stack[-2] - stack[-1]) + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @1B25 stack[-2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @1B28 stack[-1] = stack[-6] + 0x20 // @1B28 stack[0] = memory[stack[-6]:stack[-6] + 0x20] // @1B29 stack[1] = memory[stack[-6]:stack[-6] + 0x20] // @1B2A stack[2] = 0x20 + 0x20 + (stack[-2] - stack[-1]) // @1B2B stack[3] = stack[-6] + 0x20 // @1B2C stack[4] = 0x00 // } // Block ends with conditional jump to 0x1b46, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_1B37: // Incoming jump from 0x1B36, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1B36, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1B36, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1B37 stack[-2] // @1B38 stack[-1] // @1B3A memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1B3B stack[-3] // } 1B37 81 DUP2 1B38 81 DUP2 1B39 01 ADD 1B3A 51 MLOAD 1B3B 83 DUP4 1B3C 82 DUP3 1B3D 01 ADD 1B3E 52 MSTORE 1B3F 60 PUSH1 0x20 1B41 01 ADD 1B42 61 PUSH2 0x1b2e 1B45 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1B3E memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1B41 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1b2e label_1B46: // Incoming jump from 0x1B36, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1B36, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x1B36, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1B4B stack[-6] // @1B4B stack[-5] // @1B4D stack[-7] // } 1B46 5B JUMPDEST 1B47 50 POP 1B48 50 POP 1B49 50 POP 1B4A 50 POP 1B4B 90 SWAP1 1B4C 50 POP 1B4D 90 SWAP1 1B4E 81 DUP2 1B4F 01 ADD 1B50 90 SWAP1 1B51 60 PUSH1 0x1f 1B53 16 AND 1B54 80 DUP1 1B55 15 ISZERO 1B56 61 PUSH2 0x1b73 1B59 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1B50 stack[-7] = stack[-5] + stack[-7] // @1B53 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1b73, if !(0x1f & stack[-5]) label_1B5A: // Incoming jump from 0x1B59, if not !(0x1f & stack[-5]) // Inputs[7] // { // @1B5A stack[-1] // @1B5B stack[-2] // @1B5E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1B75 stack[-11] // @1B83 memory[0x40:0x60] // @1B8A stack[-13] // @1B8C address(stack[-13]).code.length // } 1B5A 80 DUP1 1B5B 82 DUP3 1B5C 03 SUB 1B5D 80 DUP1 1B5E 51 MLOAD 1B5F 60 PUSH1 0x01 1B61 83 DUP4 1B62 60 PUSH1 0x20 1B64 03 SUB 1B65 61 PUSH2 0x0100 1B68 0A EXP 1B69 03 SUB 1B6A 19 NOT 1B6B 16 AND 1B6C 81 DUP2 1B6D 52 MSTORE 1B6E 60 PUSH1 0x20 1B70 01 ADD 1B71 91 SWAP2 1B72 50 POP 1B73 5B JUMPDEST 1B74 50 POP 1B75 98 SWAP9 1B76 50 POP 1B77 50 POP 1B78 50 POP 1B79 50 POP 1B7A 50 POP 1B7B 50 POP 1B7C 50 POP 1B7D 50 POP 1B7E 50 POP 1B7F 60 PUSH1 0x00 1B81 60 PUSH1 0x40 1B83 51 MLOAD 1B84 80 DUP1 1B85 83 DUP4 1B86 03 SUB 1B87 81 DUP2 1B88 60 PUSH1 0x00 1B8A 87 DUP8 1B8B 80 DUP1 1B8C 3B EXTCODESIZE 1B8D 15 ISZERO 1B8E 80 DUP1 1B8F 15 ISZERO 1B90 61 PUSH2 0x1b98 1B93 57 *JUMPI // Stack delta = -3 // Outputs[9] // { // @1B6D 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] // @1B75 stack[-11] = 0x20 + (stack[-2] - stack[-1]) // @1B7F stack[-10] = 0x00 // @1B83 stack[-9] = memory[0x40:0x60] // @1B86 stack[-8] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @1B87 stack[-7] = memory[0x40:0x60] // @1B88 stack[-6] = 0x00 // @1B8A stack[-5] = stack[-13] // @1B8D stack[-4] = !address(stack[-13]).code.length // } // Block ends with conditional jump to 0x1b98, if !!address(stack[-13]).code.length label_1B94: // Incoming jump from 0x1B93, if not !!address(stack[-13]).code.length // Incoming jump from 0x1B93, if not !!address(stack[-13]).code.length // Inputs[1] { @1B97 memory[0x00:0x00] } 1B94 60 PUSH1 0x00 1B96 80 DUP1 1B97 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B97 revert(memory[0x00:0x00]); } // Block terminates label_1B98: // Incoming jump from 0x1B93, if !!address(stack[-13]).code.length // Incoming jump from 0x1B93, if !!address(stack[-13]).code.length // Inputs[9] // { // @1B9A msg.gas // @1B9B memory[stack[-4]:stack[-4] + stack[-5]] // @1B9B stack[-6] // @1B9B stack[-3] // @1B9B stack[-7] // @1B9B stack[-4] // @1B9B stack[-5] // @1B9B address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B9B stack[-2] // } 1B98 5B JUMPDEST 1B99 50 POP 1B9A 5A GAS 1B9B F1 CALL 1B9C 15 ISZERO 1B9D 80 DUP1 1B9E 15 ISZERO 1B9F 61 PUSH2 0x1bac 1BA2 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1B9B memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1B9C stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1bac, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1BA3: // Incoming jump from 0x1BA2, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1BA3 returndata.length // @1BA7 returndata[0x00:0x00 + returndata.length] // @1BA8 returndata.length // @1BAB memory[0x00:0x00 + returndata.length] // } 1BA3 3D RETURNDATASIZE 1BA4 60 PUSH1 0x00 1BA6 80 DUP1 1BA7 3E RETURNDATACOPY 1BA8 3D RETURNDATASIZE 1BA9 60 PUSH1 0x00 1BAB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1BA7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1BAB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1BAC: // Incoming jump from 0x1BA2, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) 1BAC 5B JUMPDEST 1BAD 50 POP 1BAE 50 POP 1BAF 50 POP 1BB0 50 POP // Stack delta = -4 // Block continues label_1BB1: // Incoming jump from 0x1BB0 // Incoming jump from 0x1A33, if !(memory[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @1BB9 stack[-8] } 1BB1 5B JUMPDEST 1BB2 50 POP 1BB3 50 POP 1BB4 50 POP 1BB5 50 POP 1BB6 50 POP 1BB7 50 POP 1BB8 50 POP 1BB9 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_1BBA: // Incoming jump from 0x0D26 // Incoming jump from 0x23A2 // Incoming jump from 0x1363 // Inputs[2] // { // @1BBE stack[-5] // @1BBF stack[-3] // } 1BBA 5B JUMPDEST 1BBB 61 PUSH2 0x1bc4 1BBE 85 DUP6 1BBF 84 DUP5 1BC0 61 PUSH2 0x25d8 1BC3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1BBB stack[0] = 0x1bc4 // @1BBE stack[1] = stack[-5] // @1BBF stack[2] = stack[-3] // } // Block ends with unconditional jump to 0x25d8 1BC4 5B JUMPDEST 1BC5 61 PUSH2 0x1bce 1BC8 84 DUP5 1BC9 84 DUP5 1BCA 61 PUSH2 0x25ff 1BCD 56 *JUMP 1BCE 5B JUMPDEST 1BCF 83 DUP4 1BD0 60 PUSH1 0x01 1BD2 60 PUSH1 0x01 1BD4 60 PUSH1 0xa0 1BD6 1B SHL 1BD7 03 SUB 1BD8 16 AND 1BD9 85 DUP6 1BDA 60 PUSH1 0x01 1BDC 60 PUSH1 0x01 1BDE 60 PUSH1 0xa0 1BE0 1B SHL 1BE1 03 SUB 1BE2 16 AND 1BE3 87 DUP8 1BE4 60 PUSH1 0x01 1BE6 60 PUSH1 0x01 1BE8 60 PUSH1 0xa0 1BEA 1B SHL 1BEB 03 SUB 1BEC 16 AND 1BED 7F PUSH32 0x06b541ddaa720db2b10a4d0cdac39b8d360425fc073085fac19bc82614677987 1C0E 86 DUP7 1C0F 86 DUP7 1C10 86 DUP7 1C11 60 PUSH1 0x40 1C13 51 MLOAD 1C14 80 DUP1 1C15 84 DUP5 1C16 81 DUP2 1C17 52 MSTORE 1C18 60 PUSH1 0x20 1C1A 01 ADD 1C1B 80 DUP1 1C1C 60 PUSH1 0x20 1C1E 01 ADD 1C1F 80 DUP1 1C20 60 PUSH1 0x20 1C22 01 ADD 1C23 83 DUP4 1C24 81 DUP2 1C25 03 SUB 1C26 83 DUP4 1C27 52 MSTORE 1C28 85 DUP6 1C29 81 DUP2 1C2A 81 DUP2 1C2B 51 MLOAD 1C2C 81 DUP2 1C2D 52 MSTORE 1C2E 60 PUSH1 0x20 1C30 01 ADD 1C31 91 SWAP2 1C32 50 POP 1C33 80 DUP1 1C34 51 MLOAD 1C35 90 SWAP1 1C36 60 PUSH1 0x20 1C38 01 ADD 1C39 90 SWAP1 1C3A 80 DUP1 1C3B 83 DUP4 1C3C 83 DUP4 1C3D 60 PUSH1 0x00 1C3F 5B JUMPDEST 1C40 83 DUP4 1C41 81 DUP2 1C42 10 LT 1C43 15 ISZERO 1C44 61 PUSH2 0x1c57 1C47 57 *JUMPI 1C48 81 DUP2 1C49 81 DUP2 1C4A 01 ADD 1C4B 51 MLOAD 1C4C 83 DUP4 1C4D 82 DUP3 1C4E 01 ADD 1C4F 52 MSTORE 1C50 60 PUSH1 0x20 1C52 01 ADD 1C53 61 PUSH2 0x1c3f 1C56 56 *JUMP 1C57 5B JUMPDEST 1C58 50 POP 1C59 50 POP 1C5A 50 POP 1C5B 50 POP 1C5C 90 SWAP1 1C5D 50 POP 1C5E 90 SWAP1 1C5F 81 DUP2 1C60 01 ADD 1C61 90 SWAP1 1C62 60 PUSH1 0x1f 1C64 16 AND 1C65 80 DUP1 1C66 15 ISZERO 1C67 61 PUSH2 0x1c84 1C6A 57 *JUMPI 1C6B 80 DUP1 1C6C 82 DUP3 1C6D 03 SUB 1C6E 80 DUP1 1C6F 51 MLOAD 1C70 60 PUSH1 0x01 1C72 83 DUP4 1C73 60 PUSH1 0x20 1C75 03 SUB 1C76 61 PUSH2 0x0100 1C79 0A EXP 1C7A 03 SUB 1C7B 19 NOT 1C7C 16 AND 1C7D 81 DUP2 1C7E 52 MSTORE 1C7F 60 PUSH1 0x20 1C81 01 ADD 1C82 91 SWAP2 1C83 50 POP 1C84 5B JUMPDEST 1C85 50 POP 1C86 83 DUP4 1C87 81 DUP2 1C88 03 SUB 1C89 82 DUP3 1C8A 52 MSTORE 1C8B 84 DUP5 1C8C 51 MLOAD 1C8D 81 DUP2 1C8E 52 MSTORE 1C8F 84 DUP5 1C90 51 MLOAD 1C91 60 PUSH1 0x20 1C93 91 SWAP2 1C94 82 DUP3 1C95 01 ADD 1C96 91 SWAP2 1C97 86 DUP7 1C98 01 ADD 1C99 90 SWAP1 1C9A 80 DUP1 1C9B 83 DUP4 1C9C 83 DUP4 1C9D 60 PUSH1 0x00 1C9F 5B JUMPDEST 1CA0 83 DUP4 1CA1 81 DUP2 1CA2 10 LT 1CA3 15 ISZERO 1CA4 61 PUSH2 0x1cb7 1CA7 57 *JUMPI 1CA8 81 DUP2 1CA9 81 DUP2 1CAA 01 ADD 1CAB 51 MLOAD 1CAC 83 DUP4 1CAD 82 DUP3 1CAE 01 ADD 1CAF 52 MSTORE 1CB0 60 PUSH1 0x20 1CB2 01 ADD 1CB3 61 PUSH2 0x1c9f 1CB6 56 *JUMP 1CB7 5B JUMPDEST 1CB8 50 POP 1CB9 50 POP 1CBA 50 POP 1CBB 50 POP 1CBC 90 SWAP1 1CBD 50 POP 1CBE 90 SWAP1 1CBF 81 DUP2 1CC0 01 ADD 1CC1 90 SWAP1 1CC2 60 PUSH1 0x1f 1CC4 16 AND 1CC5 80 DUP1 1CC6 15 ISZERO 1CC7 61 PUSH2 0x1ce4 1CCA 57 *JUMPI 1CCB 80 DUP1 1CCC 82 DUP3 1CCD 03 SUB 1CCE 80 DUP1 1CCF 51 MLOAD 1CD0 60 PUSH1 0x01 1CD2 83 DUP4 1CD3 60 PUSH1 0x20 1CD5 03 SUB 1CD6 61 PUSH2 0x0100 1CD9 0A EXP 1CDA 03 SUB 1CDB 19 NOT 1CDC 16 AND 1CDD 81 DUP2 1CDE 52 MSTORE 1CDF 60 PUSH1 0x20 1CE1 01 ADD 1CE2 91 SWAP2 1CE3 50 POP 1CE4 5B JUMPDEST 1CE5 50 POP 1CE6 95 SWAP6 1CE7 50 POP 1CE8 50 POP 1CE9 50 POP 1CEA 50 POP 1CEB 50 POP 1CEC 50 POP 1CED 60 PUSH1 0x40 1CEF 51 MLOAD 1CF0 80 DUP1 1CF1 91 SWAP2 1CF2 03 SUB 1CF3 90 SWAP1 1CF4 A4 LOG4 1CF5 83 DUP4 1CF6 60 PUSH1 0x01 1CF8 60 PUSH1 0x01 1CFA 60 PUSH1 0xa0 1CFC 1B SHL 1CFD 03 SUB 1CFE 16 AND 1CFF 85 DUP6 1D00 60 PUSH1 0x01 1D02 60 PUSH1 0x01 1D04 60 PUSH1 0xa0 1D06 1B SHL 1D07 03 SUB 1D08 16 AND 1D09 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1D2A 85 DUP6 1D2B 60 PUSH1 0x40 1D2D 51 MLOAD 1D2E 80 DUP1 1D2F 82 DUP3 1D30 81 DUP2 1D31 52 MSTORE 1D32 60 PUSH1 0x20 1D34 01 ADD 1D35 91 SWAP2 1D36 50 POP 1D37 50 POP 1D38 60 PUSH1 0x40 1D3A 51 MLOAD 1D3B 80 DUP1 1D3C 91 SWAP2 1D3D 03 SUB 1D3E 90 SWAP1 1D3F A3 LOG3 1D40 50 POP 1D41 50 POP 1D42 50 POP 1D43 50 POP 1D44 50 POP 1D45 50 POP 1D46 56 *JUMP label_1D47: // Incoming call from 0x26F1, returns to 0x1694 // Inputs[3] // { // @1D4A stack[-1] // @1D4B stack[-3] // @1D4C stack[-2] // } 1D47 5B JUMPDEST 1D48 60 PUSH1 0x00 1D4A 81 DUP2 1D4B 84 DUP5 1D4C 84 DUP5 1D4D 11 GT 1D4E 15 ISZERO 1D4F 61 PUSH2 0x1dd6 1D52 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D48 stack[0] = 0x00 // @1D4A stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1dd6, if !(stack[-2] > stack[-3]) label_1D53: // Incoming jump from 0x1D52, if not !(stack[-2] > stack[-3]) // Inputs[4] // { // @1D55 memory[0x40:0x60] // @1D6C stack[-1] // @1D6F memory[stack[-1]:stack[-1] + 0x20] // @1D78 memory[stack[-1]:stack[-1] + 0x20] // } 1D53 60 PUSH1 0x40 1D55 51 MLOAD 1D56 62 PUSH3 0x461bcd 1D5A 60 PUSH1 0xe5 1D5C 1B SHL 1D5D 81 DUP2 1D5E 52 MSTORE 1D5F 60 PUSH1 0x04 1D61 01 ADD 1D62 80 DUP1 1D63 80 DUP1 1D64 60 PUSH1 0x20 1D66 01 ADD 1D67 82 DUP3 1D68 81 DUP2 1D69 03 SUB 1D6A 82 DUP3 1D6B 52 MSTORE 1D6C 83 DUP4 1D6D 81 DUP2 1D6E 81 DUP2 1D6F 51 MLOAD 1D70 81 DUP2 1D71 52 MSTORE 1D72 60 PUSH1 0x20 1D74 01 ADD 1D75 91 SWAP2 1D76 50 POP 1D77 80 DUP1 1D78 51 MLOAD 1D79 90 SWAP1 1D7A 60 PUSH1 0x20 1D7C 01 ADD 1D7D 90 SWAP1 1D7E 80 DUP1 1D7F 83 DUP4 1D80 83 DUP4 1D81 60 PUSH1 0x00 1D83 5B JUMPDEST 1D84 83 DUP4 1D85 81 DUP2 1D86 10 LT 1D87 15 ISZERO 1D88 61 PUSH2 0x1d9b 1D8B 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @1D5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1D61 stack[0] = 0x04 + memory[0x40:0x60] // @1D62 stack[1] = 0x04 + memory[0x40:0x60] // @1D6B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1D71 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1D75 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1D7D stack[3] = 0x20 + stack[-1] // @1D7D stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @1D7E stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @1D7F stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1D80 stack[7] = 0x20 + stack[-1] // @1D81 stack[8] = 0x00 // } // Block ends with conditional jump to 0x1d9b, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1D8C: // Incoming jump from 0x1D8B, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1D8B, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1D8C stack[-2] // @1D8D stack[-1] // @1D8F memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D90 stack[-3] // } 1D8C 81 DUP2 1D8D 81 DUP2 1D8E 01 ADD 1D8F 51 MLOAD 1D90 83 DUP4 1D91 82 DUP3 1D92 01 ADD 1D93 52 MSTORE 1D94 60 PUSH1 0x20 1D96 01 ADD 1D97 61 PUSH2 0x1d83 1D9A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1D93 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1D96 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1d83 label_1D9B: // Incoming jump from 0x1D8B, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1D8B, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1DA0 stack[-6] // @1DA0 stack[-5] // @1DA2 stack[-7] // } 1D9B 5B JUMPDEST 1D9C 50 POP 1D9D 50 POP 1D9E 50 POP 1D9F 50 POP 1DA0 90 SWAP1 1DA1 50 POP 1DA2 90 SWAP1 1DA3 81 DUP2 1DA4 01 ADD 1DA5 90 SWAP1 1DA6 60 PUSH1 0x1f 1DA8 16 AND 1DA9 80 DUP1 1DAA 15 ISZERO 1DAB 61 PUSH2 0x1dc8 1DAE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1DA5 stack[-7] = stack[-5] + stack[-7] // @1DA8 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1dc8, if !(0x1f & stack[-5]) label_1DAF: // Incoming jump from 0x1DAE, if not !(0x1f & stack[-5]) // Inputs[6] // { // @1DAF stack[-1] // @1DB0 stack[-2] // @1DB3 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1DCA stack[-5] // @1DD0 memory[0x40:0x60] // @1DD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 1DAF 80 DUP1 1DB0 82 DUP3 1DB1 03 SUB 1DB2 80 DUP1 1DB3 51 MLOAD 1DB4 60 PUSH1 0x01 1DB6 83 DUP4 1DB7 60 PUSH1 0x20 1DB9 03 SUB 1DBA 61 PUSH2 0x0100 1DBD 0A EXP 1DBE 03 SUB 1DBF 19 NOT 1DC0 16 AND 1DC1 81 DUP2 1DC2 52 MSTORE 1DC3 60 PUSH1 0x20 1DC5 01 ADD 1DC6 91 SWAP2 1DC7 50 POP 1DC8 5B JUMPDEST 1DC9 50 POP 1DCA 92 SWAP3 1DCB 50 POP 1DCC 50 POP 1DCD 50 POP 1DCE 60 PUSH1 0x40 1DD0 51 MLOAD 1DD1 80 DUP1 1DD2 91 SWAP2 1DD3 03 SUB 1DD4 90 SWAP1 1DD5 FD *REVERT // Stack delta = -5 // Outputs[2] // { // @1DC2 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] // @1DD5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_1DD6: // Incoming jump from 0x1D52, if !(stack[-2] > stack[-3]) // Inputs[3] // { // @1DDA stack[-4] // @1DDA stack[-5] // @1DDC stack[-6] // } 1DD6 5B JUMPDEST 1DD7 50 POP 1DD8 50 POP 1DD9 50 POP 1DDA 90 SWAP1 1DDB 03 SUB 1DDC 90 SWAP1 1DDD 56 *JUMP // Stack delta = -5 // Outputs[1] { @1DDC stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] 1DDE 5B JUMPDEST 1DDF 60 PUSH1 0x6e 1DE1 54 SLOAD 1DE2 60 PUSH1 0x70 1DE4 54 SLOAD 1DE5 60 PUSH1 0x40 1DE7 80 DUP1 1DE8 51 MLOAD 1DE9 63 PUSH4 0x555ddc65 1DEE 60 PUSH1 0xe1 1DF0 1B SHL 1DF1 81 DUP2 1DF2 52 MSTORE 1DF3 60 PUSH1 0x01 1DF5 60 PUSH1 0x01 1DF7 60 PUSH1 0xa0 1DF9 1B SHL 1DFA 03 SUB 1DFB 89 DUP10 1DFC 81 DUP2 1DFD 16 AND 1DFE 60 PUSH1 0x04 1E00 83 DUP4 1E01 01 ADD 1E02 52 MSTORE 1E03 60 PUSH1 0x24 1E05 82 DUP3 1E06 01 ADD 1E07 93 SWAP4 1E08 90 SWAP1 1E09 93 SWAP4 1E0A 52 MSTORE 1E0B 90 SWAP1 1E0C 51 MLOAD 1E0D 60 PUSH1 0x00 1E0F 93 SWAP4 1E10 92 SWAP3 1E11 90 SWAP1 1E12 92 SWAP3 1E13 16 AND 1E14 91 SWAP2 1E15 63 PUSH4 0xaabbb8ca 1E1A 91 SWAP2 1E1B 60 PUSH1 0x44 1E1D 80 DUP1 1E1E 82 DUP3 1E1F 01 ADD 1E20 92 SWAP3 1E21 60 PUSH1 0x20 1E23 92 SWAP3 1E24 90 SWAP1 1E25 91 SWAP2 1E26 90 SWAP1 1E27 82 DUP3 1E28 90 SWAP1 1E29 03 SUB 1E2A 01 ADD 1E2B 81 DUP2 1E2C 86 DUP7 1E2D 80 DUP1 1E2E 3B EXTCODESIZE 1E2F 15 ISZERO 1E30 80 DUP1 1E31 15 ISZERO 1E32 61 PUSH2 0x1e3a 1E35 57 *JUMPI 1E36 60 PUSH1 0x00 1E38 80 DUP1 1E39 FD *REVERT 1E3A 5B JUMPDEST 1E3B 50 POP 1E3C 5A GAS 1E3D FA STATICCALL 1E3E 15 ISZERO 1E3F 80 DUP1 1E40 15 ISZERO 1E41 61 PUSH2 0x1e4e 1E44 57 *JUMPI 1E45 3D RETURNDATASIZE 1E46 60 PUSH1 0x00 1E48 80 DUP1 1E49 3E RETURNDATACOPY 1E4A 3D RETURNDATASIZE 1E4B 60 PUSH1 0x00 1E4D FD *REVERT 1E4E 5B JUMPDEST 1E4F 50 POP 1E50 50 POP 1E51 50 POP 1E52 50 POP 1E53 60 PUSH1 0x40 1E55 51 MLOAD 1E56 3D RETURNDATASIZE 1E57 60 PUSH1 0x20 1E59 81 DUP2 1E5A 10 LT 1E5B 15 ISZERO 1E5C 61 PUSH2 0x1e64 1E5F 57 *JUMPI 1E60 60 PUSH1 0x00 1E62 80 DUP1 1E63 FD *REVERT 1E64 5B JUMPDEST 1E65 50 POP 1E66 51 MLOAD 1E67 90 SWAP1 1E68 50 POP 1E69 60 PUSH1 0x01 1E6B 60 PUSH1 0x01 1E6D 60 PUSH1 0xa0 1E6F 1B SHL 1E70 03 SUB 1E71 81 DUP2 1E72 16 AND 1E73 15 ISZERO 1E74 61 PUSH2 0x1ff8 1E77 57 *JUMPI 1E78 80 DUP1 1E79 60 PUSH1 0x01 1E7B 60 PUSH1 0x01 1E7D 60 PUSH1 0xa0 1E7F 1B SHL 1E80 03 SUB 1E81 16 AND 1E82 62 PUSH3 0x23de29 1E86 89 DUP10 1E87 89 DUP10 1E88 89 DUP10 1E89 89 DUP10 1E8A 89 DUP10 1E8B 89 DUP10 1E8C 60 PUSH1 0x40 1E8E 51 MLOAD 1E8F 87 DUP8 1E90 63 PUSH4 0xffffffff 1E95 16 AND 1E96 60 PUSH1 0xe0 1E98 1B SHL 1E99 81 DUP2 1E9A 52 MSTORE 1E9B 60 PUSH1 0x04 1E9D 01 ADD 1E9E 80 DUP1 1E9F 87 DUP8 1EA0 60 PUSH1 0x01 1EA2 60 PUSH1 0x01 1EA4 60 PUSH1 0xa0 1EA6 1B SHL 1EA7 03 SUB 1EA8 16 AND 1EA9 60 PUSH1 0x01 1EAB 60 PUSH1 0x01 1EAD 60 PUSH1 0xa0 1EAF 1B SHL 1EB0 03 SUB 1EB1 16 AND 1EB2 81 DUP2 1EB3 52 MSTORE 1EB4 60 PUSH1 0x20 1EB6 01 ADD 1EB7 86 DUP7 1EB8 60 PUSH1 0x01 1EBA 60 PUSH1 0x01 1EBC 60 PUSH1 0xa0 1EBE 1B SHL 1EBF 03 SUB 1EC0 16 AND 1EC1 60 PUSH1 0x01 1EC3 60 PUSH1 0x01 1EC5 60 PUSH1 0xa0 1EC7 1B SHL 1EC8 03 SUB 1EC9 16 AND 1ECA 81 DUP2 1ECB 52 MSTORE 1ECC 60 PUSH1 0x20 1ECE 01 ADD 1ECF 85 DUP6 1ED0 60 PUSH1 0x01 1ED2 60 PUSH1 0x01 1ED4 60 PUSH1 0xa0 1ED6 1B SHL 1ED7 03 SUB 1ED8 16 AND 1ED9 60 PUSH1 0x01 1EDB 60 PUSH1 0x01 1EDD 60 PUSH1 0xa0 1EDF 1B SHL 1EE0 03 SUB 1EE1 16 AND 1EE2 81 DUP2 1EE3 52 MSTORE 1EE4 60 PUSH1 0x20 1EE6 01 ADD 1EE7 84 DUP5 1EE8 81 DUP2 1EE9 52 MSTORE 1EEA 60 PUSH1 0x20 1EEC 01 ADD 1EED 80 DUP1 1EEE 60 PUSH1 0x20 1EF0 01 ADD 1EF1 80 DUP1 1EF2 60 PUSH1 0x20 1EF4 01 ADD 1EF5 83 DUP4 1EF6 81 DUP2 1EF7 03 SUB 1EF8 83 DUP4 1EF9 52 MSTORE 1EFA 85 DUP6 1EFB 81 DUP2 1EFC 81 DUP2 1EFD 51 MLOAD 1EFE 81 DUP2 1EFF 52 MSTORE 1F00 60 PUSH1 0x20 1F02 01 ADD 1F03 91 SWAP2 1F04 50 POP 1F05 80 DUP1 1F06 51 MLOAD 1F07 90 SWAP1 1F08 60 PUSH1 0x20 1F0A 01 ADD 1F0B 90 SWAP1 1F0C 80 DUP1 1F0D 83 DUP4 1F0E 83 DUP4 1F0F 60 PUSH1 0x00 1F11 5B JUMPDEST 1F12 83 DUP4 1F13 81 DUP2 1F14 10 LT 1F15 15 ISZERO 1F16 61 PUSH2 0x1f29 1F19 57 *JUMPI 1F1A 81 DUP2 1F1B 81 DUP2 1F1C 01 ADD 1F1D 51 MLOAD 1F1E 83 DUP4 1F1F 82 DUP3 1F20 01 ADD 1F21 52 MSTORE 1F22 60 PUSH1 0x20 1F24 01 ADD 1F25 61 PUSH2 0x1f11 1F28 56 *JUMP 1F29 5B JUMPDEST 1F2A 50 POP 1F2B 50 POP 1F2C 50 POP 1F2D 50 POP 1F2E 90 SWAP1 1F2F 50 POP 1F30 90 SWAP1 1F31 81 DUP2 1F32 01 ADD 1F33 90 SWAP1 1F34 60 PUSH1 0x1f 1F36 16 AND 1F37 80 DUP1 1F38 15 ISZERO 1F39 61 PUSH2 0x1f56 1F3C 57 *JUMPI 1F3D 80 DUP1 1F3E 82 DUP3 1F3F 03 SUB 1F40 80 DUP1 1F41 51 MLOAD 1F42 60 PUSH1 0x01 1F44 83 DUP4 1F45 60 PUSH1 0x20 1F47 03 SUB 1F48 61 PUSH2 0x0100 1F4B 0A EXP 1F4C 03 SUB 1F4D 19 NOT 1F4E 16 AND 1F4F 81 DUP2 1F50 52 MSTORE 1F51 60 PUSH1 0x20 1F53 01 ADD 1F54 91 SWAP2 1F55 50 POP 1F56 5B JUMPDEST 1F57 50 POP 1F58 83 DUP4 1F59 81 DUP2 1F5A 03 SUB 1F5B 82 DUP3 1F5C 52 MSTORE 1F5D 84 DUP5 1F5E 51 MLOAD 1F5F 81 DUP2 1F60 52 MSTORE 1F61 84 DUP5 1F62 51 MLOAD 1F63 60 PUSH1 0x20 1F65 91 SWAP2 1F66 82 DUP3 1F67 01 ADD 1F68 91 SWAP2 1F69 86 DUP7 1F6A 01 ADD 1F6B 90 SWAP1 1F6C 80 DUP1 1F6D 83 DUP4 1F6E 83 DUP4 1F6F 60 PUSH1 0x00 1F71 5B JUMPDEST 1F72 83 DUP4 1F73 81 DUP2 1F74 10 LT 1F75 15 ISZERO 1F76 61 PUSH2 0x1f89 1F79 57 *JUMPI 1F7A 81 DUP2 1F7B 81 DUP2 1F7C 01 ADD 1F7D 51 MLOAD 1F7E 83 DUP4 1F7F 82 DUP3 1F80 01 ADD 1F81 52 MSTORE 1F82 60 PUSH1 0x20 1F84 01 ADD 1F85 61 PUSH2 0x1f71 1F88 56 *JUMP 1F89 5B JUMPDEST 1F8A 50 POP 1F8B 50 POP 1F8C 50 POP 1F8D 50 POP 1F8E 90 SWAP1 1F8F 50 POP 1F90 90 SWAP1 1F91 81 DUP2 1F92 01 ADD 1F93 90 SWAP1 1F94 60 PUSH1 0x1f 1F96 16 AND 1F97 80 DUP1 1F98 15 ISZERO 1F99 61 PUSH2 0x1fb6 1F9C 57 *JUMPI 1F9D 80 DUP1 1F9E 82 DUP3 1F9F 03 SUB 1FA0 80 DUP1 1FA1 51 MLOAD 1FA2 60 PUSH1 0x01 1FA4 83 DUP4 1FA5 60 PUSH1 0x20 1FA7 03 SUB 1FA8 61 PUSH2 0x0100 1FAB 0A EXP 1FAC 03 SUB 1FAD 19 NOT 1FAE 16 AND 1FAF 81 DUP2 1FB0 52 MSTORE 1FB1 60 PUSH1 0x20 1FB3 01 ADD 1FB4 91 SWAP2 1FB5 50 POP 1FB6 5B JUMPDEST 1FB7 50 POP 1FB8 98 SWAP9 1FB9 50 POP 1FBA 50 POP 1FBB 50 POP 1FBC 50 POP 1FBD 50 POP 1FBE 50 POP 1FBF 50 POP 1FC0 50 POP 1FC1 50 POP 1FC2 60 PUSH1 0x00 1FC4 60 PUSH1 0x40 1FC6 51 MLOAD 1FC7 80 DUP1 1FC8 83 DUP4 1FC9 03 SUB 1FCA 81 DUP2 1FCB 60 PUSH1 0x00 1FCD 87 DUP8 1FCE 80 DUP1 1FCF 3B EXTCODESIZE 1FD0 15 ISZERO 1FD1 80 DUP1 1FD2 15 ISZERO 1FD3 61 PUSH2 0x1fdb 1FD6 57 *JUMPI 1FD7 60 PUSH1 0x00 1FD9 80 DUP1 1FDA FD *REVERT 1FDB 5B JUMPDEST 1FDC 50 POP 1FDD 5A GAS 1FDE F1 CALL 1FDF 15 ISZERO 1FE0 80 DUP1 1FE1 15 ISZERO 1FE2 61 PUSH2 0x1fef 1FE5 57 *JUMPI 1FE6 3D RETURNDATASIZE 1FE7 60 PUSH1 0x00 1FE9 80 DUP1 1FEA 3E RETURNDATACOPY 1FEB 3D RETURNDATASIZE 1FEC 60 PUSH1 0x00 1FEE FD *REVERT 1FEF 5B JUMPDEST 1FF0 50 POP 1FF1 50 POP 1FF2 50 POP 1FF3 50 POP 1FF4 61 PUSH2 0x204c 1FF7 56 *JUMP 1FF8 5B JUMPDEST 1FF9 81 DUP2 1FFA 15 ISZERO 1FFB 61 PUSH2 0x204c 1FFE 57 *JUMPI 1FFF 61 PUSH2 0x2010 2002 86 DUP7 2003 60 PUSH1 0x01 2005 60 PUSH1 0x01 2007 60 PUSH1 0xa0 2009 1B SHL 200A 03 SUB 200B 16 AND 200C 61 PUSH2 0x261a 200F 56 *JUMP 2010 5B JUMPDEST 2011 15 ISZERO 2012 61 PUSH2 0x204c 2015 57 *JUMPI 2016 60 PUSH1 0x40 2018 51 MLOAD 2019 62 PUSH3 0x461bcd 201D 60 PUSH1 0xe5 201F 1B SHL 2020 81 DUP2 2021 52 MSTORE 2022 60 PUSH1 0x04 2024 01 ADD 2025 80 DUP1 2026 80 DUP1 2027 60 PUSH1 0x20 2029 01 ADD 202A 82 DUP3 202B 81 DUP2 202C 03 SUB 202D 82 DUP3 202E 52 MSTORE 202F 60 PUSH1 0x4d 2031 81 DUP2 2032 52 MSTORE 2033 60 PUSH1 0x20 2035 01 ADD 2036 80 DUP1 2037 61 PUSH2 0x2919 203A 60 PUSH1 0x4d 203C 91 SWAP2 203D 39 CODECOPY 203E 60 PUSH1 0x60 2040 01 ADD 2041 91 SWAP2 2042 50 POP 2043 50 POP 2044 60 PUSH1 0x40 2046 51 MLOAD 2047 80 DUP1 2048 91 SWAP2 2049 03 SUB 204A 90 SWAP1 204B FD *REVERT 204C 5B JUMPDEST 204D 50 POP 204E 50 POP 204F 50 POP 2050 50 POP 2051 50 POP 2052 50 POP 2053 50 POP 2054 50 POP 2055 56 *JUMP label_2056: // Incoming call from 0x0DCC, returns to 0x0DCD // Inputs[3] // { // @205F stack[-2] // @206E memory[0x00:0x40] // @2070 storage[keccak256(memory[0x00:0x40])] // } 2056 5B JUMPDEST 2057 60 PUSH1 0x01 2059 60 PUSH1 0x01 205B 60 PUSH1 0xa0 205D 1B SHL 205E 03 SUB 205F 82 DUP3 2060 16 AND 2061 60 PUSH1 0x00 2063 90 SWAP1 2064 81 DUP2 2065 52 MSTORE 2066 60 PUSH1 0x75 2068 60 PUSH1 0x20 206A 52 MSTORE 206B 60 PUSH1 0x40 206D 81 DUP2 206E 20 SHA3 206F 80 DUP1 2070 54 SLOAD 2071 15 ISZERO 2072 80 DUP1 2073 15 ISZERO 2074 90 SWAP1 2075 61 PUSH2 0x2094 2078 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @2063 stack[0] = 0x00 // @2065 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @206A memory[0x20:0x40] = 0x75 // @206E stack[1] = keccak256(memory[0x00:0x40]) // @2074 stack[2] = !!storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2094, if !storage[keccak256(memory[0x00:0x40])] label_2079: // Incoming jump from 0x2078, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @207A stack[-4] // @207B stack[-2] // @207F storage[stack[-2]] // } 2079 50 POP 207A 82 DUP3 207B 81 DUP2 207C 60 PUSH1 0x00 207E 81 DUP2 207F 54 SLOAD 2080 81 DUP2 2081 10 LT 2082 61 PUSH2 0x2087 2085 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @207A stack[-1] = stack[-4] // @207B stack[0] = stack[-2] // @207C stack[1] = 0x00 // } // Block ends with conditional jump to 0x2087, if 0x00 < storage[stack[-2]] label_2086: // Incoming jump from 0x2085, if not 0x00 < storage[stack[-2]] 2086 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2086 assert(); } // Block terminates label_2087: // Incoming jump from 0x2085, if 0x00 < storage[stack[-2]] // Inputs[5] // { // @2088 stack[-1] // @2088 stack[-2] // @2090 memory[0x00:0x20] // @2092 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2093 stack[-3] // } 2087 5B JUMPDEST 2088 90 SWAP1 2089 60 PUSH1 0x00 208B 52 MSTORE 208C 60 PUSH1 0x20 208E 60 PUSH1 0x00 2090 20 SHA3 2091 01 ADD 2092 54 SLOAD 2093 10 LT // Stack delta = -2 // Outputs[2] // { // @208B memory[0x00:0x20] = stack[-2] // @2093 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] < stack[-3] // } // Block continues label_2094: // Incoming jump from 0x2078, if !storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x2093 // Inputs[1] { @2095 stack[-1] } 2094 5B JUMPDEST 2095 15 ISZERO 2096 61 PUSH2 0x20e7 2099 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x20e7, if !stack[-1] label_209A: // Incoming jump from 0x2099, if not !stack[-1] // Inputs[4] // { // @209A stack[-1] // @209B storage[stack[-1]] // @20A1 stack[-3] // @20A5 storage[stack[-1]] // } 209A 80 DUP1 209B 54 SLOAD 209C 60 PUSH1 0x00 209E 19 NOT 209F 01 ADD 20A0 5B JUMPDEST 20A1 83 DUP4 20A2 82 DUP3 20A3 82 DUP3 20A4 81 DUP2 20A5 54 SLOAD 20A6 81 DUP2 20A7 10 LT 20A8 61 PUSH2 0x20ad 20AB 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @209F stack[0] = ~0x00 + storage[stack[-1]] // @20A1 stack[1] = stack[-3] // @20A2 stack[2] = stack[-1] // @20A3 stack[3] = ~0x00 + storage[stack[-1]] // } // Block ends with conditional jump to 0x20ad, if ~0x00 + storage[stack[-1]] < storage[stack[-1]] label_20AC: // Incoming jump from 0x20AB, if not ~0x00 + storage[stack[-1]] < storage[stack[-1]] // Incoming jump from 0x20AB, if not stack[-1] < storage[stack[-2]] 20AC FE *ASSERT // Stack delta = +0 // Outputs[1] { @20AC assert(); } // Block terminates label_20AD: // Incoming jump from 0x20AB, if ~0x00 + storage[stack[-1]] < storage[stack[-1]] // Incoming jump from 0x20AB, if stack[-1] < storage[stack[-2]] // Inputs[5] // { // @20AE stack[-1] // @20AE stack[-2] // @20B6 memory[0x00:0x20] // @20B8 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @20B9 stack[-3] // } 20AD 5B JUMPDEST 20AE 90 SWAP1 20AF 60 PUSH1 0x00 20B1 52 MSTORE 20B2 60 PUSH1 0x20 20B4 60 PUSH1 0x00 20B6 20 SHA3 20B7 01 ADD 20B8 54 SLOAD 20B9 11 GT 20BA 15 ISZERO 20BB 61 PUSH2 0x20c7 20BE 57 *JUMPI // Stack delta = -3 // Outputs[1] { @20B1 memory[0x00:0x20] = stack[-2] } // Block ends with conditional jump to 0x20c7, if !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] > stack[-3]) label_20BF: // Incoming jump from 0x20BE, if not !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] > stack[-3]) // Inputs[1] { @20C2 stack[-1] } 20BF 60 PUSH1 0x00 20C1 19 NOT 20C2 01 ADD 20C3 61 PUSH2 0x20a0 20C6 56 *JUMP // Stack delta = +0 // Outputs[1] { @20C2 stack[-1] = ~0x00 + stack[-1] } // Block ends with unconditional jump to 0x20a0 label_20C7: // Incoming jump from 0x20BE, if !(storage[keccak256(memory[0x00:0x20]) + stack[-1]] > stack[-3]) // Inputs[3] // { // @20C8 stack[-2] // @20C9 stack[-1] // @20CB storage[stack[-2]] // } 20C7 5B JUMPDEST 20C8 81 DUP2 20C9 81 DUP2 20CA 81 DUP2 20CB 54 SLOAD 20CC 81 DUP2 20CD 10 LT 20CE 61 PUSH2 0x20d3 20D1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20C8 stack[0] = stack[-2] // @20C9 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x20d3, if stack[-1] < storage[stack[-2]] label_20D2: // Incoming jump from 0x20D1, if not stack[-1] < storage[stack[-2]] 20D2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @20D2 assert(); } // Block terminates label_20D3: // Incoming jump from 0x20D1, if stack[-1] < storage[stack[-2]] // Inputs[5] // { // @20D4 stack[-2] // @20D4 stack[-1] // @20DC memory[0x00:0x20] // @20DE storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @20DF stack[-5] // } 20D3 5B JUMPDEST 20D4 90 SWAP1 20D5 60 PUSH1 0x00 20D7 52 MSTORE 20D8 60 PUSH1 0x20 20DA 60 PUSH1 0x00 20DC 20 SHA3 20DD 01 ADD 20DE 54 SLOAD 20DF 92 SWAP3 20E0 50 POP 20E1 50 POP 20E2 50 POP 20E3 61 PUSH2 0x0c2b 20E6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @20D7 memory[0x00:0x20] = stack[-2] // @20DF stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to 0x0c2b label_20E7: // Incoming jump from 0x2099, if !stack[-1] // Inputs[1] { @20EA stack[-2] } 20E7 5B JUMPDEST 20E8 60 PUSH1 0x00 20EA 91 SWAP2 20EB 50 POP 20EC 50 POP 20ED 61 PUSH2 0x0c2b 20F0 56 *JUMP // Stack delta = -1 // Outputs[1] { @20EA stack[-2] = 0x00 } // Block ends with unconditional jump to 0x0c2b label_20F1: // Incoming call from 0x13AA, returns to 0x13AB // Incoming call from 0x0E20, returns to 0x0E21 // Inputs[3] // { // @20F2 address(this) // @20F3 address(address(this)).code.length // @20F5 stack[-1] // } 20F1 5B JUMPDEST 20F2 30 ADDRESS 20F3 3B EXTCODESIZE 20F4 15 ISZERO 20F5 90 SWAP1 20F6 56 *JUMP // Stack delta = +0 // Outputs[1] { @20F5 stack[-1] = !address(address(this)).code.length } // Block ends with unconditional jump to stack[-1] 20F7 5B JUMPDEST 20F8 60 PUSH1 0x01 20FA 60 PUSH1 0x01 20FC 60 PUSH1 0xa0 20FE 1B SHL 20FF 03 SUB 2100 84 DUP5 2101 16 AND 2102 61 PUSH2 0x2152 2105 57 *JUMPI 2106 60 PUSH1 0x40 2108 80 DUP1 2109 51 MLOAD 210A 62 PUSH3 0x461bcd 210E 60 PUSH1 0xe5 2110 1B SHL 2111 81 DUP2 2112 52 MSTORE 2113 60 PUSH1 0x20 2115 60 PUSH1 0x04 2117 82 DUP3 2118 01 ADD 2119 81 DUP2 211A 90 SWAP1 211B 52 MSTORE 211C 60 PUSH1 0x24 211E 82 DUP3 211F 01 ADD 2120 52 MSTORE 2121 7F PUSH32 0x4552433737373a206d696e7420746f20746865207a65726f2061646472657373 2142 60 PUSH1 0x44 2144 82 DUP3 2145 01 ADD 2146 52 MSTORE 2147 90 SWAP1 2148 51 MLOAD 2149 90 SWAP1 214A 81 DUP2 214B 90 SWAP1 214C 03 SUB 214D 60 PUSH1 0x64 214F 01 ADD 2150 90 SWAP1 2151 FD *REVERT 2152 5B JUMPDEST 2153 60 PUSH1 0x72 2155 54 SLOAD 2156 61 PUSH2 0x2165 2159 90 SWAP1 215A 84 DUP5 215B 63 PUSH4 0xffffffff 2160 61 PUSH2 0x2656 2163 16 AND 2164 56 *JUMP 2165 5B JUMPDEST 2166 60 PUSH1 0x72 2168 55 SSTORE 2169 61 PUSH2 0x2172 216C 84 DUP5 216D 84 DUP5 216E 61 PUSH2 0x25ff 2171 56 *JUMP 2172 5B JUMPDEST 2173 61 PUSH2 0x2183 2176 85 DUP6 2177 60 PUSH1 0x00 2179 86 DUP7 217A 86 DUP7 217B 86 DUP7 217C 86 DUP7 217D 60 PUSH1 0x01 217F 61 PUSH2 0x1dde 2182 56 *JUMP 2183 5B JUMPDEST 2184 83 DUP4 2185 60 PUSH1 0x01 2187 60 PUSH1 0x01 2189 60 PUSH1 0xa0 218B 1B SHL 218C 03 SUB 218D 16 AND 218E 85 DUP6 218F 60 PUSH1 0x01 2191 60 PUSH1 0x01 2193 60 PUSH1 0xa0 2195 1B SHL 2196 03 SUB 2197 16 AND 2198 7F PUSH32 0x2fe5be0146f74c5bce36c0b80911af6c7d86ff27e89d5cfa61fc681327954e5d 21B9 85 DUP6 21BA 85 DUP6 21BB 85 DUP6 21BC 60 PUSH1 0x40 21BE 51 MLOAD 21BF 80 DUP1 21C0 84 DUP5 21C1 81 DUP2 21C2 52 MSTORE 21C3 60 PUSH1 0x20 21C5 01 ADD 21C6 80 DUP1 21C7 60 PUSH1 0x20 21C9 01 ADD 21CA 80 DUP1 21CB 60 PUSH1 0x20 21CD 01 ADD 21CE 83 DUP4 21CF 81 DUP2 21D0 03 SUB 21D1 83 DUP4 21D2 52 MSTORE 21D3 85 DUP6 21D4 81 DUP2 21D5 81 DUP2 21D6 51 MLOAD 21D7 81 DUP2 21D8 52 MSTORE 21D9 60 PUSH1 0x20 21DB 01 ADD 21DC 91 SWAP2 21DD 50 POP 21DE 80 DUP1 21DF 51 MLOAD 21E0 90 SWAP1 21E1 60 PUSH1 0x20 21E3 01 ADD 21E4 90 SWAP1 21E5 80 DUP1 21E6 83 DUP4 21E7 83 DUP4 21E8 60 PUSH1 0x00 21EA 5B JUMPDEST 21EB 83 DUP4 21EC 81 DUP2 21ED 10 LT 21EE 15 ISZERO 21EF 61 PUSH2 0x2202 21F2 57 *JUMPI 21F3 81 DUP2 21F4 81 DUP2 21F5 01 ADD 21F6 51 MLOAD 21F7 83 DUP4 21F8 82 DUP3 21F9 01 ADD 21FA 52 MSTORE 21FB 60 PUSH1 0x20 21FD 01 ADD 21FE 61 PUSH2 0x21ea 2201 56 *JUMP 2202 5B JUMPDEST 2203 50 POP 2204 50 POP 2205 50 POP 2206 50 POP 2207 90 SWAP1 2208 50 POP 2209 90 SWAP1 220A 81 DUP2 220B 01 ADD 220C 90 SWAP1 220D 60 PUSH1 0x1f 220F 16 AND 2210 80 DUP1 2211 15 ISZERO 2212 61 PUSH2 0x222f 2215 57 *JUMPI 2216 80 DUP1 2217 82 DUP3 2218 03 SUB 2219 80 DUP1 221A 51 MLOAD 221B 60 PUSH1 0x01 221D 83 DUP4 221E 60 PUSH1 0x20 2220 03 SUB 2221 61 PUSH2 0x0100 2224 0A EXP 2225 03 SUB 2226 19 NOT 2227 16 AND 2228 81 DUP2 2229 52 MSTORE 222A 60 PUSH1 0x20 222C 01 ADD 222D 91 SWAP2 222E 50 POP 222F 5B JUMPDEST 2230 50 POP 2231 83 DUP4 2232 81 DUP2 2233 03 SUB 2234 82 DUP3 2235 52 MSTORE 2236 84 DUP5 2237 51 MLOAD 2238 81 DUP2 2239 52 MSTORE 223A 84 DUP5 223B 51 MLOAD 223C 60 PUSH1 0x20 223E 91 SWAP2 223F 82 DUP3 2240 01 ADD 2241 91 SWAP2 2242 86 DUP7 2243 01 ADD 2244 90 SWAP1 2245 80 DUP1 2246 83 DUP4 2247 83 DUP4 2248 60 PUSH1 0x00 224A 5B JUMPDEST 224B 83 DUP4 224C 81 DUP2 224D 10 LT 224E 15 ISZERO 224F 61 PUSH2 0x2262 2252 57 *JUMPI 2253 81 DUP2 2254 81 DUP2 2255 01 ADD 2256 51 MLOAD 2257 83 DUP4 2258 82 DUP3 2259 01 ADD 225A 52 MSTORE 225B 60 PUSH1 0x20 225D 01 ADD 225E 61 PUSH2 0x224a 2261 56 *JUMP 2262 5B JUMPDEST 2263 50 POP 2264 50 POP 2265 50 POP 2266 50 POP 2267 90 SWAP1 2268 50 POP 2269 90 SWAP1 226A 81 DUP2 226B 01 ADD 226C 90 SWAP1 226D 60 PUSH1 0x1f 226F 16 AND 2270 80 DUP1 2271 15 ISZERO 2272 61 PUSH2 0x228f 2275 57 *JUMPI 2276 80 DUP1 2277 82 DUP3 2278 03 SUB 2279 80 DUP1 227A 51 MLOAD 227B 60 PUSH1 0x01 227D 83 DUP4 227E 60 PUSH1 0x20 2280 03 SUB 2281 61 PUSH2 0x0100 2284 0A EXP 2285 03 SUB 2286 19 NOT 2287 16 AND 2288 81 DUP2 2289 52 MSTORE 228A 60 PUSH1 0x20 228C 01 ADD 228D 91 SWAP2 228E 50 POP 228F 5B JUMPDEST 2290 50 POP 2291 95 SWAP6 2292 50 POP 2293 50 POP 2294 50 POP 2295 50 POP 2296 50 POP 2297 50 POP 2298 60 PUSH1 0x40 229A 51 MLOAD 229B 80 DUP1 229C 91 SWAP2 229D 03 SUB 229E 90 SWAP1 229F A3 LOG3 22A0 60 PUSH1 0x40 22A2 80 DUP1 22A3 51 MLOAD 22A4 84 DUP5 22A5 81 DUP2 22A6 52 MSTORE 22A7 90 SWAP1 22A8 51 MLOAD 22A9 60 PUSH1 0x01 22AB 60 PUSH1 0x01 22AD 60 PUSH1 0xa0 22AF 1B SHL 22B0 03 SUB 22B1 86 DUP7 22B2 16 AND 22B3 91 SWAP2 22B4 60 PUSH1 0x00 22B6 91 SWAP2 22B7 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 22D8 91 SWAP2 22D9 81 DUP2 22DA 90 SWAP1 22DB 03 SUB 22DC 60 PUSH1 0x20 22DE 01 ADD 22DF 90 SWAP1 22E0 A3 LOG3 22E1 50 POP 22E2 50 POP 22E3 50 POP 22E4 50 POP 22E5 50 POP 22E6 56 *JUMP label_22E7: // Incoming jump from 0x12B3 // Incoming jump from 0x109A // Inputs[1] { @22F0 stack[-6] } 22E7 5B JUMPDEST 22E8 60 PUSH1 0x01 22EA 60 PUSH1 0x01 22EC 60 PUSH1 0xa0 22EE 1B SHL 22EF 03 SUB 22F0 86 DUP7 22F1 16 AND 22F2 61 PUSH2 0x232c 22F5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x232c, if stack[-6] & (0x01 << 0xa0) - 0x01 label_22F6: // Incoming jump from 0x22F5, if not stack[-6] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @22F8 memory[0x40:0x60] // @2326 memory[0x40:0x60] // @232B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 22F6 60 PUSH1 0x40 22F8 51 MLOAD 22F9 62 PUSH3 0x461bcd 22FD 60 PUSH1 0xe5 22FF 1B SHL 2300 81 DUP2 2301 52 MSTORE 2302 60 PUSH1 0x04 2304 01 ADD 2305 80 DUP1 2306 80 DUP1 2307 60 PUSH1 0x20 2309 01 ADD 230A 82 DUP3 230B 81 DUP2 230C 03 SUB 230D 82 DUP3 230E 52 MSTORE 230F 60 PUSH1 0x22 2311 81 DUP2 2312 52 MSTORE 2313 60 PUSH1 0x20 2315 01 ADD 2316 80 DUP1 2317 61 PUSH2 0x2890 231A 60 PUSH1 0x22 231C 91 SWAP2 231D 39 CODECOPY 231E 60 PUSH1 0x40 2320 01 ADD 2321 91 SWAP2 2322 50 POP 2323 50 POP 2324 60 PUSH1 0x40 2326 51 MLOAD 2327 80 DUP1 2328 91 SWAP2 2329 03 SUB 232A 90 SWAP1 232B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2301 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @230E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2312 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @231D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x2890:0x28b2] // @232B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_232C: // Incoming jump from 0x22F5, if stack[-6] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2335 stack[-5] } 232C 5B JUMPDEST 232D 60 PUSH1 0x01 232F 60 PUSH1 0x01 2331 60 PUSH1 0xa0 2333 1B SHL 2334 03 SUB 2335 85 DUP6 2336 16 AND 2337 61 PUSH2 0x2387 233A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2387, if stack[-5] & (0x01 << 0xa0) - 0x01 label_233B: // Incoming jump from 0x233A, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @233E memory[0x40:0x60] // @237D memory[0x40:0x60] // @2386 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 233B 60 PUSH1 0x40 233D 80 DUP1 233E 51 MLOAD 233F 62 PUSH3 0x461bcd 2343 60 PUSH1 0xe5 2345 1B SHL 2346 81 DUP2 2347 52 MSTORE 2348 60 PUSH1 0x20 234A 60 PUSH1 0x04 234C 82 DUP3 234D 01 ADD 234E 81 DUP2 234F 90 SWAP1 2350 52 MSTORE 2351 60 PUSH1 0x24 2353 82 DUP3 2354 01 ADD 2355 52 MSTORE 2356 7F PUSH32 0x4552433737373a2073656e6420746f20746865207a65726f2061646472657373 2377 60 PUSH1 0x44 2379 82 DUP3 237A 01 ADD 237B 52 MSTORE 237C 90 SWAP1 237D 51 MLOAD 237E 90 SWAP1 237F 81 DUP2 2380 90 SWAP1 2381 03 SUB 2382 60 PUSH1 0x64 2384 01 ADD 2385 90 SWAP1 2386 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2347 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2350 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2355 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @237B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433737373a2073656e6420746f20746865207a65726f2061646472657373 // @2386 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2387: // Incoming jump from 0x233A, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @238B stack[-7] // @238C stack[-6] // @238D stack[-5] // @238E stack[-4] // @238F stack[-3] // @2390 stack[-2] // } 2387 5B JUMPDEST 2388 61 PUSH2 0x2395 238B 87 DUP8 238C 87 DUP8 238D 87 DUP8 238E 87 DUP8 238F 87 DUP8 2390 87 DUP8 2391 61 PUSH2 0x199a 2394 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @2388 stack[0] = 0x2395 // @238B stack[1] = stack[-7] // @238C stack[2] = stack[-6] // @238D stack[3] = stack[-5] // @238E stack[4] = stack[-4] // @238F stack[5] = stack[-3] // @2390 stack[6] = stack[-2] // } // Block ends with call to 0x199a, returns to 0x2395 label_2395: // Incoming return from call to 0x199A at 0x2394 // Inputs[6] // { // @2399 stack[-7] // @239A stack[-6] // @239B stack[-5] // @239C stack[-4] // @239D stack[-3] // @239E stack[-2] // } 2395 5B JUMPDEST 2396 61 PUSH2 0x23a3 2399 87 DUP8 239A 87 DUP8 239B 87 DUP8 239C 87 DUP8 239D 87 DUP8 239E 87 DUP8 239F 61 PUSH2 0x1bba 23A2 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @2396 stack[0] = 0x23a3 // @2399 stack[1] = stack[-7] // @239A stack[2] = stack[-6] // @239B stack[3] = stack[-5] // @239C stack[4] = stack[-4] // @239D stack[5] = stack[-3] // @239E stack[6] = stack[-2] // } // Block ends with unconditional jump to 0x1bba 23A3 5B JUMPDEST 23A4 61 PUSH2 0x1bb1 23A7 87 DUP8 23A8 87 DUP8 23A9 87 DUP8 23AA 87 DUP8 23AB 87 DUP8 23AC 87 DUP8 23AD 87 DUP8 23AE 61 PUSH2 0x1dde 23B1 56 *JUMP label_23B2: // Incoming call from 0x10A7, returns to 0x10A8 // Inputs[3] // { // @23BB stack[-1] // @23CA memory[0x00:0x40] // @23CC storage[keccak256(memory[0x00:0x40])] // } 23B2 5B JUMPDEST 23B3 60 PUSH1 0x01 23B5 60 PUSH1 0x01 23B7 60 PUSH1 0xa0 23B9 1B SHL 23BA 03 SUB 23BB 81 DUP2 23BC 16 AND 23BD 60 PUSH1 0x00 23BF 90 SWAP1 23C0 81 DUP2 23C1 52 MSTORE 23C2 60 PUSH1 0x75 23C4 60 PUSH1 0x20 23C6 52 MSTORE 23C7 60 PUSH1 0x40 23C9 81 DUP2 23CA 20 SHA3 23CB 80 DUP1 23CC 54 SLOAD 23CD 15 ISZERO 23CE 61 PUSH2 0x23f6 23D1 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @23BF stack[0] = 0x00 // @23C1 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @23C6 memory[0x20:0x40] = 0x75 // @23CA stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x23f6, if !storage[keccak256(memory[0x00:0x40])] label_23D2: // Incoming jump from 0x23D1, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @23D2 stack[-1] // @23D3 storage[stack[-1]] // } 23D2 80 DUP1 23D3 54 SLOAD 23D4 81 DUP2 23D5 90 SWAP1 23D6 60 PUSH1 0x00 23D8 19 NOT 23D9 81 DUP2 23DA 01 ADD 23DB 90 SWAP1 23DC 81 DUP2 23DD 10 LT 23DE 61 PUSH2 0x23e3 23E1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23D5 stack[0] = stack[-1] // @23DB stack[1] = storage[stack[-1]] + ~0x00 // } // Block ends with conditional jump to 0x23e3, if storage[stack[-1]] + ~0x00 < storage[stack[-1]] label_23E2: // Incoming jump from 0x23E1, if not storage[stack[-1]] + ~0x00 < storage[stack[-1]] 23E2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @23E2 assert(); } // Block terminates label_23E3: // Incoming jump from 0x23E1, if storage[stack[-1]] + ~0x00 < storage[stack[-1]] // Inputs[5] // { // @23E4 stack[-2] // @23E4 stack[-1] // @23EC memory[0x00:0x20] // @23EE storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @23EF stack[-4] // } 23E3 5B JUMPDEST 23E4 90 SWAP1 23E5 60 PUSH1 0x00 23E7 52 MSTORE 23E8 60 PUSH1 0x20 23EA 60 PUSH1 0x00 23EC 20 SHA3 23ED 01 ADD 23EE 54 SLOAD 23EF 91 SWAP2 23F0 50 POP 23F1 50 POP 23F2 61 PUSH2 0x10d5 23F5 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @23E7 memory[0x00:0x20] = stack[-2] // @23EF stack[-4] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to 0x10d5 label_23F6: // Incoming jump from 0x23D1, if !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @23F9 stack[-2] } 23F6 5B JUMPDEST 23F7 60 PUSH1 0x00 23F9 91 SWAP2 23FA 50 POP 23FB 50 POP 23FC 61 PUSH2 0x10d5 23FF 56 *JUMP // Stack delta = -1 // Outputs[1] { @23F9 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x10d5 label_2400: // Incoming jump from 0x189B // Incoming jump from 0x1871 // Inputs[1] { @2409 stack[-4] } 2400 5B JUMPDEST 2401 60 PUSH1 0x01 2403 60 PUSH1 0x01 2405 60 PUSH1 0xa0 2407 1B SHL 2408 03 SUB 2409 84 DUP5 240A 16 AND 240B 61 PUSH2 0x2445 240E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2445, if stack[-4] & (0x01 << 0xa0) - 0x01 label_240F: // Incoming jump from 0x240E, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2411 memory[0x40:0x60] // @243F memory[0x40:0x60] // @2444 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 240F 60 PUSH1 0x40 2411 51 MLOAD 2412 62 PUSH3 0x461bcd 2416 60 PUSH1 0xe5 2418 1B SHL 2419 81 DUP2 241A 52 MSTORE 241B 60 PUSH1 0x04 241D 01 ADD 241E 80 DUP1 241F 80 DUP1 2420 60 PUSH1 0x20 2422 01 ADD 2423 82 DUP3 2424 81 DUP2 2425 03 SUB 2426 82 DUP3 2427 52 MSTORE 2428 60 PUSH1 0x22 242A 81 DUP2 242B 52 MSTORE 242C 60 PUSH1 0x20 242E 01 ADD 242F 80 DUP1 2430 61 PUSH2 0x28b2 2433 60 PUSH1 0x22 2435 91 SWAP2 2436 39 CODECOPY 2437 60 PUSH1 0x40 2439 01 ADD 243A 91 SWAP2 243B 50 POP 243C 50 POP 243D 60 PUSH1 0x40 243F 51 MLOAD 2440 80 DUP1 2441 91 SWAP2 2442 03 SUB 2443 90 SWAP1 2444 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @241A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2427 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @242B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @2436 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x28b2:0x28d4] // @2444 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2445: // Incoming jump from 0x240E, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @2449 stack[-5] // @244A stack[-4] // @244D stack[-3] // @244E stack[-2] // @244F stack[-1] // } 2445 5B JUMPDEST 2446 61 PUSH2 0x2454 2449 85 DUP6 244A 85 DUP6 244B 60 PUSH1 0x00 244D 86 DUP7 244E 86 DUP7 244F 86 DUP7 2450 61 PUSH2 0x199a 2453 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @2446 stack[0] = 0x2454 // @2449 stack[1] = stack[-5] // @244A stack[2] = stack[-4] // @244B stack[3] = 0x00 // @244D stack[4] = stack[-3] // @244E stack[5] = stack[-2] // @244F stack[6] = stack[-1] // } // Block ends with call to 0x199a, returns to 0x2454 label_2454: // Incoming return from call to 0x199A at 0x2453 // Inputs[2] // { // @2457 storage[0x72] // @245C stack[-3] // } 2454 5B JUMPDEST 2455 60 PUSH1 0x72 2457 54 SLOAD 2458 61 PUSH2 0x2467 245B 90 SWAP1 245C 84 DUP5 245D 63 PUSH4 0xffffffff 2462 61 PUSH2 0x26b0 2465 16 AND 2466 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @245B stack[0] = 0x2467 // @245B stack[1] = storage[0x72] // @245C stack[2] = stack[-3] // } // Block ends with unconditional jump to 0x26b0 & 0xffffffff 2467 5B JUMPDEST 2468 60 PUSH1 0x72 246A 55 SSTORE 246B 61 PUSH2 0x2474 246E 84 DUP5 246F 84 DUP5 2470 61 PUSH2 0x25d8 2473 56 *JUMP 2474 5B JUMPDEST 2475 83 DUP4 2476 60 PUSH1 0x01 2478 60 PUSH1 0x01 247A 60 PUSH1 0xa0 247C 1B SHL 247D 03 SUB 247E 16 AND 247F 85 DUP6 2480 60 PUSH1 0x01 2482 60 PUSH1 0x01 2484 60 PUSH1 0xa0 2486 1B SHL 2487 03 SUB 2488 16 AND 2489 7F PUSH32 0xa78a9be3a7b862d26933ad85fb11d80ef66b8f972d7cbba06621d583943a4098 24AA 85 DUP6 24AB 85 DUP6 24AC 85 DUP6 24AD 60 PUSH1 0x40 24AF 51 MLOAD 24B0 80 DUP1 24B1 84 DUP5 24B2 81 DUP2 24B3 52 MSTORE 24B4 60 PUSH1 0x20 24B6 01 ADD 24B7 80 DUP1 24B8 60 PUSH1 0x20 24BA 01 ADD 24BB 80 DUP1 24BC 60 PUSH1 0x20 24BE 01 ADD 24BF 83 DUP4 24C0 81 DUP2 24C1 03 SUB 24C2 83 DUP4 24C3 52 MSTORE 24C4 85 DUP6 24C5 81 DUP2 24C6 81 DUP2 24C7 51 MLOAD 24C8 81 DUP2 24C9 52 MSTORE 24CA 60 PUSH1 0x20 24CC 01 ADD 24CD 91 SWAP2 24CE 50 POP 24CF 80 DUP1 24D0 51 MLOAD 24D1 90 SWAP1 24D2 60 PUSH1 0x20 24D4 01 ADD 24D5 90 SWAP1 24D6 80 DUP1 24D7 83 DUP4 24D8 83 DUP4 24D9 60 PUSH1 0x00 24DB 5B JUMPDEST 24DC 83 DUP4 24DD 81 DUP2 24DE 10 LT 24DF 15 ISZERO 24E0 61 PUSH2 0x24f3 24E3 57 *JUMPI 24E4 81 DUP2 24E5 81 DUP2 24E6 01 ADD 24E7 51 MLOAD 24E8 83 DUP4 24E9 82 DUP3 24EA 01 ADD 24EB 52 MSTORE 24EC 60 PUSH1 0x20 24EE 01 ADD 24EF 61 PUSH2 0x24db 24F2 56 *JUMP 24F3 5B JUMPDEST 24F4 50 POP 24F5 50 POP 24F6 50 POP 24F7 50 POP 24F8 90 SWAP1 24F9 50 POP 24FA 90 SWAP1 24FB 81 DUP2 24FC 01 ADD 24FD 90 SWAP1 24FE 60 PUSH1 0x1f 2500 16 AND 2501 80 DUP1 2502 15 ISZERO 2503 61 PUSH2 0x2520 2506 57 *JUMPI 2507 80 DUP1 2508 82 DUP3 2509 03 SUB 250A 80 DUP1 250B 51 MLOAD 250C 60 PUSH1 0x01 250E 83 DUP4 250F 60 PUSH1 0x20 2511 03 SUB 2512 61 PUSH2 0x0100 2515 0A EXP 2516 03 SUB 2517 19 NOT 2518 16 AND 2519 81 DUP2 251A 52 MSTORE 251B 60 PUSH1 0x20 251D 01 ADD 251E 91 SWAP2 251F 50 POP 2520 5B JUMPDEST 2521 50 POP 2522 83 DUP4 2523 81 DUP2 2524 03 SUB 2525 82 DUP3 2526 52 MSTORE 2527 84 DUP5 2528 51 MLOAD 2529 81 DUP2 252A 52 MSTORE 252B 84 DUP5 252C 51 MLOAD 252D 60 PUSH1 0x20 252F 91 SWAP2 2530 82 DUP3 2531 01 ADD 2532 91 SWAP2 2533 86 DUP7 2534 01 ADD 2535 90 SWAP1 2536 80 DUP1 2537 83 DUP4 2538 83 DUP4 2539 60 PUSH1 0x00 253B 5B JUMPDEST 253C 83 DUP4 253D 81 DUP2 253E 10 LT 253F 15 ISZERO 2540 61 PUSH2 0x2553 2543 57 *JUMPI 2544 81 DUP2 2545 81 DUP2 2546 01 ADD 2547 51 MLOAD 2548 83 DUP4 2549 82 DUP3 254A 01 ADD 254B 52 MSTORE 254C 60 PUSH1 0x20 254E 01 ADD 254F 61 PUSH2 0x253b 2552 56 *JUMP 2553 5B JUMPDEST 2554 50 POP 2555 50 POP 2556 50 POP 2557 50 POP 2558 90 SWAP1 2559 50 POP 255A 90 SWAP1 255B 81 DUP2 255C 01 ADD 255D 90 SWAP1 255E 60 PUSH1 0x1f 2560 16 AND 2561 80 DUP1 2562 15 ISZERO 2563 61 PUSH2 0x2580 2566 57 *JUMPI 2567 80 DUP1 2568 82 DUP3 2569 03 SUB 256A 80 DUP1 256B 51 MLOAD 256C 60 PUSH1 0x01 256E 83 DUP4 256F 60 PUSH1 0x20 2571 03 SUB 2572 61 PUSH2 0x0100 2575 0A EXP 2576 03 SUB 2577 19 NOT 2578 16 AND 2579 81 DUP2 257A 52 MSTORE 257B 60 PUSH1 0x20 257D 01 ADD 257E 91 SWAP2 257F 50 POP 2580 5B JUMPDEST 2581 50 POP 2582 95 SWAP6 2583 50 POP 2584 50 POP 2585 50 POP 2586 50 POP 2587 50 POP 2588 50 POP 2589 60 PUSH1 0x40 258B 51 MLOAD 258C 80 DUP1 258D 91 SWAP2 258E 03 SUB 258F 90 SWAP1 2590 A3 LOG3 2591 60 PUSH1 0x40 2593 80 DUP1 2594 51 MLOAD 2595 84 DUP5 2596 81 DUP2 2597 52 MSTORE 2598 90 SWAP1 2599 51 MLOAD 259A 60 PUSH1 0x00 259C 91 SWAP2 259D 60 PUSH1 0x01 259F 60 PUSH1 0x01 25A1 60 PUSH1 0xa0 25A3 1B SHL 25A4 03 SUB 25A5 87 DUP8 25A6 16 AND 25A7 91 SWAP2 25A8 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 25C9 91 SWAP2 25CA 81 DUP2 25CB 90 SWAP1 25CC 03 SUB 25CD 60 PUSH1 0x20 25CF 01 ADD 25D0 90 SWAP1 25D1 A3 LOG3 25D2 50 POP 25D3 50 POP 25D4 50 POP 25D5 50 POP 25D6 50 POP 25D7 56 *JUMP label_25D8: // Incoming jump from 0x1BC3 // Inputs[2] // { // @25DE stack[-1] // @25E2 stack[-2] // } 25D8 5B JUMPDEST 25D9 60 PUSH1 0x00 25DB 61 PUSH2 0x25f3 25DE 82 DUP3 25DF 61 PUSH2 0x25e7 25E2 85 DUP6 25E3 61 PUSH2 0x109b 25E6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @25D9 stack[0] = 0x00 // @25DB stack[1] = 0x25f3 // @25DE stack[2] = stack[-1] // @25DF stack[3] = 0x25e7 // @25E2 stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x109b 25E7 5B JUMPDEST 25E8 90 SWAP1 25E9 63 PUSH4 0xffffffff 25EE 61 PUSH2 0x26b0 25F1 16 AND 25F2 56 *JUMP 25F3 5B JUMPDEST 25F4 90 SWAP1 25F5 50 POP 25F6 61 PUSH2 0x12b4 25F9 83 DUP4 25FA 82 DUP3 25FB 61 PUSH2 0x26f2 25FE 56 *JUMP 25FF 5B JUMPDEST 2600 60 PUSH1 0x00 2602 61 PUSH2 0x25f3 2605 82 DUP3 2606 61 PUSH2 0x260e 2609 85 DUP6 260A 61 PUSH2 0x109b 260D 56 *JUMP 260E 5B JUMPDEST 260F 90 SWAP1 2610 63 PUSH4 0xffffffff 2615 61 PUSH2 0x2656 2618 16 AND 2619 56 *JUMP 261A 5B JUMPDEST 261B 60 PUSH1 0x00 261D 81 DUP2 261E 3F EXTCODEHASH 261F 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 2640 81 DUP2 2641 81 DUP2 2642 14 EQ 2643 80 DUP1 2644 15 ISZERO 2645 90 SWAP1 2646 61 PUSH2 0x264e 2649 57 *JUMPI 264A 50 POP 264B 81 DUP2 264C 15 ISZERO 264D 15 ISZERO 264E 5B JUMPDEST 264F 94 SWAP5 2650 93 SWAP4 2651 50 POP 2652 50 POP 2653 50 POP 2654 50 POP 2655 56 *JUMP 2656 5B JUMPDEST 2657 60 PUSH1 0x00 2659 82 DUP3 265A 82 DUP3 265B 01 ADD 265C 83 DUP4 265D 81 DUP2 265E 10 LT 265F 15 ISZERO 2660 61 PUSH2 0x1694 2663 57 *JUMPI 2664 60 PUSH1 0x40 2666 80 DUP1 2667 51 MLOAD 2668 62 PUSH3 0x461bcd 266C 60 PUSH1 0xe5 266E 1B SHL 266F 81 DUP2 2670 52 MSTORE 2671 60 PUSH1 0x20 2673 60 PUSH1 0x04 2675 82 DUP3 2676 01 ADD 2677 52 MSTORE 2678 60 PUSH1 0x1b 267A 60 PUSH1 0x24 267C 82 DUP3 267D 01 ADD 267E 52 MSTORE 267F 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 26A0 60 PUSH1 0x44 26A2 82 DUP3 26A3 01 ADD 26A4 52 MSTORE 26A5 90 SWAP1 26A6 51 MLOAD 26A7 90 SWAP1 26A8 81 DUP2 26A9 90 SWAP1 26AA 03 SUB 26AB 60 PUSH1 0x64 26AD 01 ADD 26AE 90 SWAP1 26AF FD *REVERT label_26B0: // Incoming jump from 0x2466 // Inputs[3] // { // @26B6 stack[-2] // @26B7 stack[-1] // @26BA memory[0x40:0x60] // } 26B0 5B JUMPDEST 26B1 60 PUSH1 0x00 26B3 61 PUSH2 0x1694 26B6 83 DUP4 26B7 83 DUP4 26B8 60 PUSH1 0x40 26BA 51 MLOAD 26BB 80 DUP1 26BC 60 PUSH1 0x40 26BE 01 ADD 26BF 60 PUSH1 0x40 26C1 52 MSTORE 26C2 80 DUP1 26C3 60 PUSH1 0x1e 26C5 81 DUP2 26C6 52 MSTORE 26C7 60 PUSH1 0x20 26C9 01 ADD 26CA 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 26EB 81 DUP2 26EC 52 MSTORE 26ED 50 POP 26EE 61 PUSH2 0x1d47 26F1 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @26B1 stack[0] = 0x00 // @26B3 stack[1] = 0x1694 // @26B6 stack[2] = stack[-2] // @26B7 stack[3] = stack[-1] // @26BA stack[4] = memory[0x40:0x60] // @26C1 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @26C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @26EC memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // } // Block ends with call to 0x1d47, returns to 0x1694 26F2 5B JUMPDEST 26F3 60 PUSH1 0x74 26F5 80 DUP1 26F6 54 SLOAD 26F7 60 PUSH1 0x00 26F9 19 NOT 26FA 81 DUP2 26FB 01 ADD 26FC 91 SWAP2 26FD 83 DUP4 26FE 91 SWAP2 26FF 83 DUP4 2700 90 SWAP1 2701 81 DUP2 2702 10 LT 2703 61 PUSH2 0x2708 2706 57 *JUMPI 2707 FE *ASSERT 2708 5B JUMPDEST 2709 60 PUSH1 0x00 270B 91 SWAP2 270C 82 DUP3 270D 52 MSTORE 270E 60 PUSH1 0x20 2710 80 DUP1 2711 83 DUP4 2712 20 SHA3 2713 60 PUSH1 0x01 2715 60 PUSH1 0x01 2717 60 PUSH1 0xa0 2719 1B SHL 271A 03 SUB 271B 88 DUP9 271C 16 AND 271D 84 DUP5 271E 52 MSTORE 271F 90 SWAP1 2720 91 SWAP2 2721 01 ADD 2722 90 SWAP1 2723 52 MSTORE 2724 60 PUSH1 0x40 2726 90 SWAP1 2727 20 SHA3 2728 55 SSTORE 2729 61 PUSH2 0x2731 272C 83 DUP4 272D 61 PUSH2 0x23b2 2730 56 *JUMP 2731 5B JUMPDEST 2732 81 DUP2 2733 14 EQ 2734 15 ISZERO 2735 80 DUP1 2736 61 PUSH2 0x273d 2739 57 *JUMPI 273A 50 POP 273B 80 DUP1 273C 15 ISZERO 273D 5B JUMPDEST 273E 15 ISZERO 273F 61 PUSH2 0x12b4 2742 57 *JUMPI 2743 60 PUSH1 0x01 2745 60 PUSH1 0x01 2747 60 PUSH1 0xa0 2749 1B SHL 274A 03 SUB 274B 83 DUP4 274C 16 AND 274D 60 PUSH1 0x00 274F 90 SWAP1 2750 81 DUP2 2751 52 MSTORE 2752 60 PUSH1 0x75 2754 60 PUSH1 0x20 2756 90 SWAP1 2757 81 DUP2 2758 52 MSTORE 2759 60 PUSH1 0x40 275B 82 DUP3 275C 20 SHA3 275D 80 DUP1 275E 54 SLOAD 275F 60 PUSH1 0x01 2761 81 DUP2 2762 01 ADD 2763 82 DUP3 2764 55 SSTORE 2765 90 SWAP1 2766 83 DUP4 2767 52 MSTORE 2768 91 SWAP2 2769 20 SHA3 276A 01 ADD 276B 81 DUP2 276C 90 SWAP1 276D 55 SSTORE 276E 50 POP 276F 50 POP 2770 50 POP 2771 56 *JUMP label_2772: // Incoming jump from 0x1431 // Incoming jump from 0x1431 // Inputs[5] // { // @2773 stack[-3] // @2775 storage[stack[-3]] // @278F memory[0x00:0x20] // @279A stack[-2] // @279B stack[-1] // } 2772 5B JUMPDEST 2773 82 DUP3 2774 80 DUP1 2775 54 SLOAD 2776 60 PUSH1 0x01 2778 81 DUP2 2779 60 PUSH1 0x01 277B 16 AND 277C 15 ISZERO 277D 61 PUSH2 0x0100 2780 02 MUL 2781 03 SUB 2782 16 AND 2783 60 PUSH1 0x02 2785 90 SWAP1 2786 04 DIV 2787 90 SWAP1 2788 60 PUSH1 0x00 278A 52 MSTORE 278B 60 PUSH1 0x20 278D 60 PUSH1 0x00 278F 20 SHA3 2790 90 SWAP1 2791 60 PUSH1 0x1f 2793 01 ADD 2794 60 PUSH1 0x20 2796 90 SWAP1 2797 04 DIV 2798 81 DUP2 2799 01 ADD 279A 92 SWAP3 279B 82 DUP3 279C 60 PUSH1 0x1f 279E 10 LT 279F 61 PUSH2 0x27b3 27A2 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @278A memory[0x00:0x20] = stack[-3] // @2790 stack[0] = keccak256(memory[0x00:0x20]) // @279A stack[1] = stack[-2] // @279A stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x27b3, if 0x1f < stack[-1] label_27A3: // Incoming jump from 0x27A2, if not 0x1f < stack[-1] // Inputs[4] // { // @27A3 stack[-1] // @27A4 memory[stack[-1]:stack[-1] + 0x20] // @27A9 stack[-3] // @27AD stack[-5] // } 27A3 80 DUP1 27A4 51 MLOAD 27A5 60 PUSH1 0xff 27A7 19 NOT 27A8 16 AND 27A9 83 DUP4 27AA 80 DUP1 27AB 01 ADD 27AC 17 OR 27AD 85 DUP6 27AE 55 SSTORE 27AF 61 PUSH2 0x27e0 27B2 56 *JUMP // Stack delta = +0 // Outputs[1] { @27AE storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x27e0 label_27B3: // Incoming jump from 0x27A2, if 0x1f < stack[-1] // Inputs[2] // { // @27B4 stack[-3] // @27BA stack[-5] // } 27B3 5B JUMPDEST 27B4 82 DUP3 27B5 80 DUP1 27B6 01 ADD 27B7 60 PUSH1 0x01 27B9 01 ADD 27BA 85 DUP6 27BB 55 SSTORE 27BC 82 DUP3 27BD 15 ISZERO 27BE 61 PUSH2 0x27e0 27C1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @27BB storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x27e0, if !stack[-3] label_27C2: // Incoming jump from 0x27C1, if not !stack[-3] // Inputs[2] // { // @27C2 stack[-1] // @27C2 stack[-3] // } 27C2 91 SWAP2 27C3 82 DUP3 27C4 01 ADD 27C5 5B JUMPDEST 27C6 82 DUP3 27C7 81 DUP2 27C8 11 GT 27C9 15 ISZERO 27CA 61 PUSH2 0x27e0 27CD 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @27C2 stack[-3] = stack[-1] // @27C4 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x27e0, if !(stack[-1] + stack[-3] > stack[-1]) label_27CE: // Incoming jump from 0x27CD, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x27CD, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @27CE stack[-3] // @27CF memory[stack[-3]:stack[-3] + 0x20] // @27D0 stack[-2] // @27D2 stack[-1] // } 27CE 82 DUP3 27CF 51 MLOAD 27D0 82 DUP3 27D1 55 SSTORE 27D2 91 SWAP2 27D3 60 PUSH1 0x20 27D5 01 ADD 27D6 91 SWAP2 27D7 90 SWAP1 27D8 60 PUSH1 0x01 27DA 01 ADD 27DB 90 SWAP1 27DC 61 PUSH2 0x27c5 27DF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @27D1 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @27D6 stack[-3] = 0x20 + stack[-3] // @27DB stack[-2] = 0x01 + stack[-2] // @27DB stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x27c5 label_27E0: // Incoming jump from 0x27CD, if !(stack[-1] > stack[-3]) // Incoming jump from 0x27C1, if !stack[-3] // Incoming jump from 0x27B2 // Incoming jump from 0x27CD, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @27E5 stack[-4] // @27E6 stack[-3] // } 27E0 5B JUMPDEST 27E1 50 POP 27E2 61 PUSH2 0x27ec 27E5 92 SWAP3 27E6 91 SWAP2 27E7 50 POP 27E8 61 PUSH2 0x2851 27EB 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @27E5 stack[-4] = 0x27ec // @27E6 stack[-3] = stack[-4] // } // Block ends with call to 0x2851, returns to 0x27EC label_27EC: // Incoming call from 0x285F, returns to 0x0B7D, if !(stack[-2] > stack[-1]) // Incoming jump from 0x285F, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2851 at 0x27EB // Inputs[2] // { // @27EE stack[-2] // @27EE stack[-3] // } 27EC 5B JUMPDEST 27ED 50 POP 27EE 90 SWAP1 27EF 56 *JUMP // Stack delta = -2 // Outputs[1] { @27EE stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] 27F0 5B JUMPDEST 27F1 82 DUP3 27F2 80 DUP1 27F3 54 SLOAD 27F4 82 DUP3 27F5 82 DUP3 27F6 55 SSTORE 27F7 90 SWAP1 27F8 60 PUSH1 0x00 27FA 52 MSTORE 27FB 60 PUSH1 0x20 27FD 60 PUSH1 0x00 27FF 20 SHA3 2800 90 SWAP1 2801 81 DUP2 2802 01 ADD 2803 92 SWAP3 2804 82 DUP3 2805 15 ISZERO 2806 61 PUSH2 0x2845 2809 57 *JUMPI 280A 91 SWAP2 280B 60 PUSH1 0x20 280D 02 MUL 280E 82 DUP3 280F 01 ADD 2810 5B JUMPDEST 2811 82 DUP3 2812 81 DUP2 2813 11 GT 2814 15 ISZERO 2815 61 PUSH2 0x2845 2818 57 *JUMPI 2819 82 DUP3 281A 51 MLOAD 281B 82 DUP3 281C 54 SLOAD 281D 60 PUSH1 0x01 281F 60 PUSH1 0x01 2821 60 PUSH1 0xa0 2823 1B SHL 2824 03 SUB 2825 19 NOT 2826 16 AND 2827 60 PUSH1 0x01 2829 60 PUSH1 0x01 282B 60 PUSH1 0xa0 282D 1B SHL 282E 03 SUB 282F 90 SWAP1 2830 91 SWAP2 2831 16 AND 2832 17 OR 2833 82 DUP3 2834 55 SSTORE 2835 60 PUSH1 0x20 2837 90 SWAP1 2838 92 SWAP3 2839 01 ADD 283A 91 SWAP2 283B 60 PUSH1 0x01 283D 90 SWAP1 283E 91 SWAP2 283F 01 ADD 2840 90 SWAP1 2841 61 PUSH2 0x2810 2844 56 *JUMP 2845 5B JUMPDEST 2846 50 POP 2847 61 PUSH2 0x27ec 284A 92 SWAP3 284B 91 SWAP2 284C 50 POP 284D 61 PUSH2 0x286b 2850 56 *JUMP label_2851: // Incoming call from 0x27EB, returns to 0x27EC // Inputs[2] // { // @2855 stack[-2] // @2856 stack[-1] // } 2851 5B JUMPDEST 2852 61 PUSH2 0x0b7d 2855 91 SWAP2 2856 90 SWAP1 2857 5B JUMPDEST 2858 80 DUP1 2859 82 DUP3 285A 11 GT 285B 15 ISZERO 285C 61 PUSH2 0x27ec 285F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2855 stack[-2] = 0x0b7d // @2856 stack[-1] = stack[-2] // @2856 stack[0] = stack[-1] // } // Block ends with conditional call to 0x27ec, returns to 0x0B7D, if !(stack[-2] > stack[-1]) label_2860: // Incoming jump from 0x285F, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x285F, if not !(stack[-2] > stack[-1]) // Inputs[1] { @2862 stack[-1] } 2860 60 PUSH1 0x00 2862 81 DUP2 2863 55 SSTORE 2864 60 PUSH1 0x01 2866 01 ADD 2867 61 PUSH2 0x2857 286A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2863 storage[stack[-1]] = 0x00 // @2866 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2857 286B 5B JUMPDEST 286C 61 PUSH2 0x0b7d 286F 91 SWAP2 2870 90 SWAP1 2871 5B JUMPDEST 2872 80 DUP1 2873 82 DUP3 2874 11 GT 2875 15 ISZERO 2876 61 PUSH2 0x27ec 2879 57 *JUMPI 287A 80 DUP1 287B 54 SLOAD 287C 60 PUSH1 0x01 287E 60 PUSH1 0x01 2880 60 PUSH1 0xa0 2882 1B SHL 2883 03 SUB 2884 19 NOT 2885 16 AND 2886 81 DUP2 2887 55 SSTORE 2888 60 PUSH1 0x01 288A 01 ADD 288B 61 PUSH2 0x2871 288E 56 *JUMP 288F FE *ASSERT 2890 45 GASLIMIT 2891 52 MSTORE 2892 43 NUMBER 2893 37 CALLDATACOPY 2894 37 CALLDATACOPY 2895 37 CALLDATACOPY 2896 3A GASPRICE 2897 20 SHA3 2898 73 PUSH20 0x656e642066726f6d20746865207a65726f206164 28AD 64 PUSH5 0x7265737345 28B3 52 MSTORE 28B4 43 NUMBER 28B5 37 CALLDATACOPY 28B6 37 CALLDATACOPY 28B7 37 CALLDATACOPY 28B8 3A GASPRICE 28B9 20 SHA3 28BA 62 PUSH3 0x75726e 28BE 20 SHA3 28BF 66 PUSH7 0x726f6d20746865 28C7 20 SHA3 28C8 7A PUSH27 0x65726f20616464726573734552433737373a20617574686f72697a 28E4 69 PUSH10 0x6e672073656c66206173 28EF 20 SHA3 28F0 6F PUSH16 0x70657261746f724552433737373a2072 2901 65 PUSH6 0x766f6b696e67 2908 20 SHA3 2909 73 PUSH20 0x656c66206173206f70657261746f724552433737 291E 37 CALLDATACOPY 291F 3A GASPRICE 2920 20 SHA3 2921 74 PUSH21 0x6f6b656e20726563697069656e7420636f6e747261 2937 63 PUSH4 0x74206861 293C 73 PUSH20 0x206e6f20696d706c656d656e74657220666f7220 2951 45 GASLIMIT 2952 52 MSTORE 2953 43 NUMBER 2954 37 CALLDATACOPY 2955 37 CALLDATACOPY 2956 37 CALLDATACOPY 2957 54 SLOAD 2958 6F PUSH16 0x6b656e73526563697069656e74436f6e 2969 74 PUSH21 0x7261637420696e7374616e63652068617320616c72 297F 65 PUSH6 0x616479206265 2986 65 PUSH6 0x6e20696e6974 298D 69 PUSH10 0x616c697a656445524337 2998 37 CALLDATACOPY 2999 37 CALLDATACOPY 299A 3A GASPRICE 299B 20 SHA3 299C 74 PUSH21 0x72616e7366657220746f20746865207a65726f2061 29B2 64 PUSH5 0x6472657373 29B8 45 GASLIMIT 29B9 52 MSTORE 29BA 43 NUMBER 29BB 37 CALLDATACOPY 29BC 37 CALLDATACOPY 29BD 37 CALLDATACOPY 29BE 3A GASPRICE 29BF 20 SHA3 29C0 63 PUSH4 0x616c6c65 29C5 72 PUSH19 0x206973206e6f7420616e206f70657261746f72 29D9 20 SHA3 29DA 66 PUSH7 0x6f7220686f6c64 29E2 65 PUSH6 0x724552433737 29E9 37 CALLDATACOPY 29EA 3A GASPRICE 29EB 20 SHA3 29EC 74 PUSH21 0x72616e7366657220616d6f756e7420657863656564 2A02 73 PUSH20 0x20616c6c6f77616e63654552433737373a207472 2A17 61 PUSH2 0x6e73 2A1A 66 PUSH7 0x65722066726f6d 2A22 20 SHA3 2A23 74 PUSH21 0x6865207a65726f2061646472657373455243373737 2A39 3A GASPRICE 2A3A 20 SHA3 2A3B 61 PUSH2 0x7070 2A3E 72 PUSH19 0x6f766520746f20746865207a65726f20616464 2A52 72 PUSH19 0x657373a265627a7a72315820d24ac3797f8336 2A66 17 OR 2A67 E0 E0 2A68 2A 2A 2A69 32 ORIGIN 2A6A E3 E3 2A6B 71 PUSH18 0xc8929ebb07698b1531471da51568ac834fc1 2A7E FA STATICCALL 2A7F 64 PUSH5 0x736f6c6343 2A85 00 *STOP 2A86 05 SDIV 2A87 0D 0D 2A88 00 *STOP 2A89 32 ORIGIN