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 0x010b 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x010b, 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 0x40c10f19 0026 11 GT 0027 61 PUSH2 0x00a2 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00a2, if 0x40c10f19 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x40c10f19 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa9059cbb 0031 11 GT 0032 61 PUSH2 0x0071 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xa9059cbb > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa9059cbb > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xa9059cbb 003C 14 EQ 003D 61 PUSH2 0x0443 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0443, if 0xa9059cbb == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xc4d66de8 0047 14 EQ 0048 61 PUSH2 0x046f 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x046f, if 0xc4d66de8 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xc4d66de8 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xc6dbdf61 0052 14 EQ 0053 61 PUSH2 0x0495 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0495, if 0xc6dbdf61 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xc6dbdf61 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xdd62ed3e 005D 14 EQ 005E 61 PUSH2 0x04b9 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b9, if 0xdd62ed3e == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xde7ea79d 0068 14 EQ 0069 61 PUSH2 0x04e7 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e7, if 0xde7ea79d == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xde7ea79d == stack[-1] 006D 61 PUSH2 0x010b 0070 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x010b label_0071: // Incoming jump from 0x0035, if 0xa9059cbb > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0x40c10f19 0078 14 EQ 0079 61 PUSH2 0x03bd 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03bd, if 0x40c10f19 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x40c10f19 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x70a08231 0083 14 EQ 0084 61 PUSH2 0x03e9 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e9, 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 0x95d89b41 008E 14 EQ 008F 61 PUSH2 0x040f 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x040f, if 0x95d89b41 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xa457c2d7 0099 14 EQ 009A 61 PUSH2 0x0417 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0417, if 0xa457c2d7 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xa457c2d7 == stack[-1] 009E 61 PUSH2 0x010b 00A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x010b label_00A2: // Incoming jump from 0x002A, if 0x40c10f19 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0x2348238c 00A9 11 GT 00AA 61 PUSH2 0x00de 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00de, if 0x2348238c > stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x2348238c > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x2348238c 00B4 14 EQ 00B5 61 PUSH2 0x0317 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0317, if 0x2348238c == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x2348238c == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x23b872dd 00BF 14 EQ 00C0 61 PUSH2 0x033d 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033d, if 0x23b872dd == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x23b872dd == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x313ce567 00CA 14 EQ 00CB 61 PUSH2 0x0373 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0373, if 0x313ce567 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x313ce567 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x39509351 00D5 14 EQ 00D6 61 PUSH2 0x0391 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0391, if 0x39509351 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x39509351 == stack[-1] 00DA 61 PUSH2 0x010b 00DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x010b label_00DE: // Incoming jump from 0x00AD, if 0x2348238c > stack[-1] // Inputs[1] { @00DF stack[-1] } 00DE 5B JUMPDEST 00DF 80 DUP1 00E0 63 PUSH4 0x06fdde03 00E5 14 EQ 00E6 61 PUSH2 0x0110 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0110, if 0x06fdde03 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x06fdde03 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x095ea7b3 00F0 14 EQ 00F1 61 PUSH2 0x018d 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x018d, if 0x095ea7b3 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @00F5 stack[-1] } 00F5 80 DUP1 00F6 63 PUSH4 0x1624f6c6 00FB 14 EQ 00FC 61 PUSH2 0x01cd 00FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cd, if 0x1624f6c6 == stack[-1] label_0100: // Incoming jump from 0x00FF, if not 0x1624f6c6 == stack[-1] // Inputs[1] { @0100 stack[-1] } 0100 80 DUP1 0101 63 PUSH4 0x18160ddd 0106 14 EQ 0107 61 PUSH2 0x02fd 010A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fd, if 0x18160ddd == stack[-1] label_010B: // Incoming jump from 0x00DD // Incoming jump from 0x0070 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x010A, if not 0x18160ddd == stack[-1] // Incoming jump from 0x00A1 // Inputs[1] { @010F memory[0x00:0x00] } 010B 5B JUMPDEST 010C 60 PUSH1 0x00 010E 80 DUP1 010F FD *REVERT // Stack delta = +0 // Outputs[1] { @010F revert(memory[0x00:0x00]); } // Block terminates label_0110: // Incoming jump from 0x00E9, if 0x06fdde03 == stack[-1] 0110 5B JUMPDEST 0111 61 PUSH2 0x0118 0114 61 PUSH2 0x0621 0117 56 *JUMP // Stack delta = +1 // Outputs[1] { @0111 stack[0] = 0x0118 } // Block ends with call to 0x0621, returns to 0x0118 label_0118: // Incoming return from call to 0x0621 at 0x0117 // Incoming return from call to 0x09DF at 0x0416 // Inputs[4] // { // @011C memory[0x40:0x60] // @0122 stack[-1] // @0123 memory[stack[-1]:stack[-1] + 0x20] // @0129 memory[stack[-1]:stack[-1] + 0x20] // } 0118 5B JUMPDEST 0119 60 PUSH1 0x40 011B 80 DUP1 011C 51 MLOAD 011D 60 PUSH1 0x20 011F 80 DUP1 0120 82 DUP3 0121 52 MSTORE 0122 83 DUP4 0123 51 MLOAD 0124 81 DUP2 0125 83 DUP4 0126 01 ADD 0127 52 MSTORE 0128 83 DUP4 0129 51 MLOAD 012A 91 SWAP2 012B 92 SWAP3 012C 83 DUP4 012D 92 SWAP3 012E 90 SWAP1 012F 83 DUP4 0130 01 ADD 0131 91 SWAP2 0132 85 DUP6 0133 01 ADD 0134 90 SWAP1 0135 80 DUP1 0136 83 DUP4 0137 83 DUP4 0138 60 PUSH1 0x00 013A 5B JUMPDEST 013B 83 DUP4 013C 81 DUP2 013D 10 LT 013E 15 ISZERO 013F 61 PUSH2 0x0152 0142 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0121 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @0127 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @012B stack[0] = memory[0x40:0x60] // @012D stack[1] = memory[0x40:0x60] // @0131 stack[2] = memory[0x40:0x60] + 0x40 // @0134 stack[3] = stack[-1] + 0x20 // @0134 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0135 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0136 stack[6] = memory[0x40:0x60] + 0x40 // @0137 stack[7] = stack[-1] + 0x20 // @0138 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0152, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0143: // Incoming jump from 0x0142, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0142, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0143 stack[-2] // @0144 stack[-1] // @0146 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0147 stack[-3] // } 0143 81 DUP2 0144 81 DUP2 0145 01 ADD 0146 51 MLOAD 0147 83 DUP4 0148 82 DUP3 0149 01 ADD 014A 52 MSTORE 014B 60 PUSH1 0x20 014D 01 ADD 014E 61 PUSH2 0x013a 0151 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @014A memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @014D stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x013a label_0152: // Incoming jump from 0x0142, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0142, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0157 stack[-6] // @0157 stack[-5] // @0159 stack[-7] // } 0152 5B JUMPDEST 0153 50 POP 0154 50 POP 0155 50 POP 0156 50 POP 0157 90 SWAP1 0158 50 POP 0159 90 SWAP1 015A 81 DUP2 015B 01 ADD 015C 90 SWAP1 015D 60 PUSH1 0x1f 015F 16 AND 0160 80 DUP1 0161 15 ISZERO 0162 61 PUSH2 0x017f 0165 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @015C stack[-7] = stack[-5] + stack[-7] // @015F stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x017f, if !(0x1f & stack[-5]) label_0166: // Incoming jump from 0x0165, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0166 stack[-1] // @0167 stack[-2] // @016A memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0181 stack[-5] // @0187 memory[0x40:0x60] // @018C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0166 80 DUP1 0167 82 DUP3 0168 03 SUB 0169 80 DUP1 016A 51 MLOAD 016B 60 PUSH1 0x01 016D 83 DUP4 016E 60 PUSH1 0x20 0170 03 SUB 0171 61 PUSH2 0x0100 0174 0A EXP 0175 03 SUB 0176 19 NOT 0177 16 AND 0178 81 DUP2 0179 52 MSTORE 017A 60 PUSH1 0x20 017C 01 ADD 017D 91 SWAP2 017E 50 POP 017F 5B JUMPDEST 0180 50 POP 0181 92 SWAP3 0182 50 POP 0183 50 POP 0184 50 POP 0185 60 PUSH1 0x40 0187 51 MLOAD 0188 80 DUP1 0189 91 SWAP2 018A 03 SUB 018B 90 SWAP1 018C F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0179 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] // @018C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_018D: // Incoming jump from 0x00F4, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0194 msg.data.length } 018D 5B JUMPDEST 018E 61 PUSH2 0x01b9 0191 60 PUSH1 0x04 0193 80 DUP1 0194 36 CALLDATASIZE 0195 03 SUB 0196 60 PUSH1 0x40 0198 81 DUP2 0199 10 LT 019A 15 ISZERO 019B 61 PUSH2 0x01a3 019E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @018E stack[0] = 0x01b9 // @0191 stack[1] = 0x04 // @0195 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x01a3, if !(msg.data.length - 0x04 < 0x40) label_019F: // Incoming jump from 0x019E, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @01A2 memory[0x00:0x00] } 019F 60 PUSH1 0x00 01A1 80 DUP1 01A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A2 revert(memory[0x00:0x00]); } // Block terminates label_01A3: // Incoming jump from 0x019E, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @01AD stack[-2] // @01AE msg.data[stack[-2]:stack[-2] + 0x20] // @01B4 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 01A3 5B JUMPDEST 01A4 50 POP 01A5 60 PUSH1 0x01 01A7 60 PUSH1 0x01 01A9 60 PUSH1 0xa0 01AB 1B SHL 01AC 03 SUB 01AD 81 DUP2 01AE 35 CALLDATALOAD 01AF 16 AND 01B0 90 SWAP1 01B1 60 PUSH1 0x20 01B3 01 ADD 01B4 35 CALLDATALOAD 01B5 61 PUSH2 0x06b8 01B8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01B0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @01B4 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x06b8 label_01B9: // Incoming return from call to 0x0353 at 0x034E // Inputs[4] // { // @01BD memory[0x40:0x60] // @01BE stack[-1] // @01C3 memory[0x40:0x60] // @01CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 01B9 5B JUMPDEST 01BA 60 PUSH1 0x40 01BC 80 DUP1 01BD 51 MLOAD 01BE 91 SWAP2 01BF 15 ISZERO 01C0 15 ISZERO 01C1 82 DUP3 01C2 52 MSTORE 01C3 51 MLOAD 01C4 90 SWAP1 01C5 81 DUP2 01C6 90 SWAP1 01C7 03 SUB 01C8 60 PUSH1 0x20 01CA 01 ADD 01CB 90 SWAP1 01CC F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01CC return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_01CD: // Incoming jump from 0x00FF, if 0x1624f6c6 == stack[-1] // Inputs[1] { @01D4 msg.data.length } 01CD 5B JUMPDEST 01CE 61 PUSH2 0x02fb 01D1 60 PUSH1 0x04 01D3 80 DUP1 01D4 36 CALLDATASIZE 01D5 03 SUB 01D6 60 PUSH1 0x60 01D8 81 DUP2 01D9 10 LT 01DA 15 ISZERO 01DB 61 PUSH2 0x01e3 01DE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01CE stack[0] = 0x02fb // @01D1 stack[1] = 0x04 // @01D5 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x01e3, if !(msg.data.length - 0x04 < 0x60) label_01DF: // Incoming jump from 0x01DE, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @01E2 memory[0x00:0x00] } 01DF 60 PUSH1 0x00 01E1 80 DUP1 01E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01E2 revert(memory[0x00:0x00]); } // Block terminates label_01E3: // Incoming jump from 0x01DE, if !(msg.data.length - 0x04 < 0x60) // Inputs[3] // { // @01E4 stack[-2] // @01E5 stack[-1] // @01EC msg.data[stack[-2]:stack[-2] + 0x20] // } 01E3 5B JUMPDEST 01E4 81 DUP2 01E5 01 ADD 01E6 90 SWAP1 01E7 60 PUSH1 0x20 01E9 81 DUP2 01EA 01 ADD 01EB 81 DUP2 01EC 35 CALLDATALOAD 01ED 60 PUSH1 0x01 01EF 60 PUSH1 0x20 01F1 1B SHL 01F2 81 DUP2 01F3 11 GT 01F4 15 ISZERO 01F5 61 PUSH2 0x01fd 01F8 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @01E6 stack[-1] = stack[-2] // @01E6 stack[-2] = stack[-2] + stack[-1] // @01EA stack[0] = stack[-2] + 0x20 // @01EC stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x01fd, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_01F9: // Incoming jump from 0x01F8, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @01FC memory[0x00:0x00] } 01F9 60 PUSH1 0x00 01FB 80 DUP1 01FC FD *REVERT // Stack delta = +0 // Outputs[1] { @01FC revert(memory[0x00:0x00]); } // Block terminates label_01FD: // Incoming jump from 0x01F8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @01FE stack[-3] // @01FF stack[-1] // @0200 stack[-4] // } 01FD 5B JUMPDEST 01FE 82 DUP3 01FF 01 ADD 0200 83 DUP4 0201 60 PUSH1 0x20 0203 82 DUP3 0204 01 ADD 0205 11 GT 0206 15 ISZERO 0207 61 PUSH2 0x020f 020A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @01FF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x020f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_020B: // Incoming jump from 0x020A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @020E memory[0x00:0x00] } 020B 60 PUSH1 0x00 020D 80 DUP1 020E FD *REVERT // Stack delta = +0 // Outputs[1] { @020E revert(memory[0x00:0x00]); } // Block terminates label_020F: // Incoming jump from 0x020A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0210 stack[-1] // @0211 msg.data[stack[-1]:stack[-1] + 0x20] // @0216 stack[-2] // @0217 stack[-4] // } 020F 5B JUMPDEST 0210 80 DUP1 0211 35 CALLDATALOAD 0212 90 SWAP1 0213 60 PUSH1 0x20 0215 01 ADD 0216 91 SWAP2 0217 84 DUP5 0218 60 PUSH1 0x01 021A 83 DUP4 021B 02 MUL 021C 84 DUP5 021D 01 ADD 021E 11 GT 021F 60 PUSH1 0x01 0221 60 PUSH1 0x20 0223 1B SHL 0224 83 DUP4 0225 11 GT 0226 17 OR 0227 15 ISZERO 0228 61 PUSH2 0x0230 022B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0212 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0216 stack[0] = stack[-2] // @0216 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0230, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_022C: // Incoming jump from 0x022B, 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] { @022F memory[0x00:0x00] } 022C 60 PUSH1 0x00 022E 80 DUP1 022F FD *REVERT // Stack delta = +0 // Outputs[1] { @022F revert(memory[0x00:0x00]); } // Block terminates label_0230: // Incoming jump from 0x022B, 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] // { // @0231 stack[-3] // @0231 stack[-1] // @0232 stack[-2] // @0243 memory[0x40:0x60] // @025A msg.data[stack[-3]:stack[-3] + stack[-2]] // @0265 stack[-5] // @0266 stack[-4] // @026E msg.data[stack[-1]:stack[-1] + 0x20] // } 0230 5B JUMPDEST 0231 91 SWAP2 0232 90 SWAP1 0233 80 DUP1 0234 80 DUP1 0235 60 PUSH1 0x1f 0237 01 ADD 0238 60 PUSH1 0x20 023A 80 DUP1 023B 91 SWAP2 023C 04 DIV 023D 02 MUL 023E 60 PUSH1 0x20 0240 01 ADD 0241 60 PUSH1 0x40 0243 51 MLOAD 0244 90 SWAP1 0245 81 DUP2 0246 01 ADD 0247 60 PUSH1 0x40 0249 52 MSTORE 024A 80 DUP1 024B 93 SWAP4 024C 92 SWAP3 024D 91 SWAP2 024E 90 SWAP1 024F 81 DUP2 0250 81 DUP2 0251 52 MSTORE 0252 60 PUSH1 0x20 0254 01 ADD 0255 83 DUP4 0256 83 DUP4 0257 80 DUP1 0258 82 DUP3 0259 84 DUP5 025A 37 CALLDATACOPY 025B 60 PUSH1 0x00 025D 92 SWAP3 025E 01 ADD 025F 91 SWAP2 0260 90 SWAP1 0261 91 SWAP2 0262 52 MSTORE 0263 50 POP 0264 92 SWAP3 0265 95 SWAP6 0266 94 SWAP5 0267 93 SWAP4 0268 60 PUSH1 0x20 026A 81 DUP2 026B 01 ADD 026C 93 SWAP4 026D 50 POP 026E 35 CALLDATALOAD 026F 91 SWAP2 0270 50 POP 0271 50 POP 0272 60 PUSH1 0x01 0274 60 PUSH1 0x20 0276 1B SHL 0277 81 DUP2 0278 11 GT 0279 15 ISZERO 027A 61 PUSH2 0x0282 027D 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0249 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0251 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @025A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0262 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0265 stack[-5] = memory[0x40:0x60] // @0266 stack[-4] = stack[-5] // @0267 stack[-3] = stack[-4] // @026C stack[-2] = stack[-1] + 0x20 // @026F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0282, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_027E: // Incoming jump from 0x027D, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0281 memory[0x00:0x00] } 027E 60 PUSH1 0x00 0280 80 DUP1 0281 FD *REVERT // Stack delta = +0 // Outputs[1] { @0281 revert(memory[0x00:0x00]); } // Block terminates label_0282: // Incoming jump from 0x027D, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0283 stack[-3] // @0284 stack[-1] // @0285 stack[-4] // } 0282 5B JUMPDEST 0283 82 DUP3 0284 01 ADD 0285 83 DUP4 0286 60 PUSH1 0x20 0288 82 DUP3 0289 01 ADD 028A 11 GT 028B 15 ISZERO 028C 61 PUSH2 0x0294 028F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0284 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0294, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0290: // Incoming jump from 0x028F, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0293 memory[0x00:0x00] } 0290 60 PUSH1 0x00 0292 80 DUP1 0293 FD *REVERT // Stack delta = +0 // Outputs[1] { @0293 revert(memory[0x00:0x00]); } // Block terminates label_0294: // Incoming jump from 0x028F, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0295 stack[-1] // @0296 msg.data[stack[-1]:stack[-1] + 0x20] // @029B stack[-2] // @029C stack[-4] // } 0294 5B JUMPDEST 0295 80 DUP1 0296 35 CALLDATALOAD 0297 90 SWAP1 0298 60 PUSH1 0x20 029A 01 ADD 029B 91 SWAP2 029C 84 DUP5 029D 60 PUSH1 0x01 029F 83 DUP4 02A0 02 MUL 02A1 84 DUP5 02A2 01 ADD 02A3 11 GT 02A4 60 PUSH1 0x01 02A6 60 PUSH1 0x20 02A8 1B SHL 02A9 83 DUP4 02AA 11 GT 02AB 17 OR 02AC 15 ISZERO 02AD 61 PUSH2 0x02b5 02B0 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0297 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @029B stack[0] = stack[-2] // @029B stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x02b5, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_02B1: // Incoming jump from 0x02B0, 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] { @02B4 memory[0x00:0x00] } 02B1 60 PUSH1 0x00 02B3 80 DUP1 02B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B4 revert(memory[0x00:0x00]); } // Block terminates label_02B5: // Incoming jump from 0x02B0, 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] // { // @02B6 stack[-1] // @02B6 stack[-3] // @02B7 stack[-2] // @02C8 memory[0x40:0x60] // @02DF msg.data[stack[-3]:stack[-3] + stack[-2]] // @02EA stack[-5] // @02EF msg.data[stack[-1]:stack[-1] + 0x20] // @02F3 stack[-4] // } 02B5 5B JUMPDEST 02B6 91 SWAP2 02B7 90 SWAP1 02B8 80 DUP1 02B9 80 DUP1 02BA 60 PUSH1 0x1f 02BC 01 ADD 02BD 60 PUSH1 0x20 02BF 80 DUP1 02C0 91 SWAP2 02C1 04 DIV 02C2 02 MUL 02C3 60 PUSH1 0x20 02C5 01 ADD 02C6 60 PUSH1 0x40 02C8 51 MLOAD 02C9 90 SWAP1 02CA 81 DUP2 02CB 01 ADD 02CC 60 PUSH1 0x40 02CE 52 MSTORE 02CF 80 DUP1 02D0 93 SWAP4 02D1 92 SWAP3 02D2 91 SWAP2 02D3 90 SWAP1 02D4 81 DUP2 02D5 81 DUP2 02D6 52 MSTORE 02D7 60 PUSH1 0x20 02D9 01 ADD 02DA 83 DUP4 02DB 83 DUP4 02DC 80 DUP1 02DD 82 DUP3 02DE 84 DUP5 02DF 37 CALLDATACOPY 02E0 60 PUSH1 0x00 02E2 92 SWAP3 02E3 01 ADD 02E4 91 SWAP2 02E5 90 SWAP1 02E6 91 SWAP2 02E7 52 MSTORE 02E8 50 POP 02E9 92 SWAP3 02EA 95 SWAP6 02EB 50 POP 02EC 50 POP 02ED 50 POP 02EE 90 SWAP1 02EF 35 CALLDATALOAD 02F0 60 PUSH1 0xff 02F2 16 AND 02F3 91 SWAP2 02F4 50 POP 02F5 61 PUSH2 0x06d6 02F8 90 SWAP1 02F9 50 POP 02FA 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @02CE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @02D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @02DF memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @02E7 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @02EA stack[-5] = memory[0x40:0x60] // @02F3 stack[-4] = 0xff & msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x06d6 label_02FB: // Incoming return from call to 0x0485 at 0x0480 // Incoming return from call to 0x032D at 0x0328 02FB 5B JUMPDEST 02FC 00 *STOP // Stack delta = +0 // Outputs[1] { @02FC stop(); } // Block terminates label_02FD: // Incoming jump from 0x010A, if 0x18160ddd == stack[-1] 02FD 5B JUMPDEST 02FE 61 PUSH2 0x0305 0301 61 PUSH2 0x07b2 0304 56 *JUMP // Stack delta = +1 // Outputs[1] { @02FE stack[0] = 0x0305 } // Block ends with call to 0x07b2, returns to 0x0305 label_0305: // Incoming return from call to 0x03FF at 0x03FA // Incoming return from call to 0x04CF at 0x04CA // Incoming return from call to 0x07B2 at 0x0304 // Inputs[4] // { // @0309 memory[0x40:0x60] // @030A stack[-1] // @030D memory[0x40:0x60] // @0316 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0305 5B JUMPDEST 0306 60 PUSH1 0x40 0308 80 DUP1 0309 51 MLOAD 030A 91 SWAP2 030B 82 DUP3 030C 52 MSTORE 030D 51 MLOAD 030E 90 SWAP1 030F 81 DUP2 0310 90 SWAP1 0311 03 SUB 0312 60 PUSH1 0x20 0314 01 ADD 0315 90 SWAP1 0316 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @030C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0316 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0317: // Incoming jump from 0x00B8, if 0x2348238c == stack[-1] // Inputs[1] { @031E msg.data.length } 0317 5B JUMPDEST 0318 61 PUSH2 0x02fb 031B 60 PUSH1 0x04 031D 80 DUP1 031E 36 CALLDATASIZE 031F 03 SUB 0320 60 PUSH1 0x20 0322 81 DUP2 0323 10 LT 0324 15 ISZERO 0325 61 PUSH2 0x032d 0328 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0318 stack[0] = 0x02fb // @031B stack[1] = 0x04 // @031F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x032d, returns to 0x02FB, if !(msg.data.length - 0x04 < 0x20) label_0329: // Incoming jump from 0x0328, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @032C memory[0x00:0x00] } 0329 60 PUSH1 0x00 032B 80 DUP1 032C FD *REVERT // Stack delta = +0 // Outputs[1] { @032C revert(memory[0x00:0x00]); } // Block terminates label_032D: // Incoming call from 0x0328, returns to 0x02FB, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @032F stack[-2] // @032F msg.data[stack[-2]:stack[-2] + 0x20] // } 032D 5B JUMPDEST 032E 50 POP 032F 35 CALLDATALOAD 0330 60 PUSH1 0x01 0332 60 PUSH1 0x01 0334 60 PUSH1 0xa0 0336 1B SHL 0337 03 SUB 0338 16 AND 0339 61 PUSH2 0x07b8 033C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0338 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x07b8 label_033D: // Incoming jump from 0x00C3, if 0x23b872dd == stack[-1] // Inputs[1] { @0344 msg.data.length } 033D 5B JUMPDEST 033E 61 PUSH2 0x01b9 0341 60 PUSH1 0x04 0343 80 DUP1 0344 36 CALLDATASIZE 0345 03 SUB 0346 60 PUSH1 0x60 0348 81 DUP2 0349 10 LT 034A 15 ISZERO 034B 61 PUSH2 0x0353 034E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @033E stack[0] = 0x01b9 // @0341 stack[1] = 0x04 // @0345 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0353, returns to 0x01B9, if !(msg.data.length - 0x04 < 0x60) label_034F: // Incoming jump from 0x034E, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0352 memory[0x00:0x00] } 034F 60 PUSH1 0x00 0351 80 DUP1 0352 FD *REVERT // Stack delta = +0 // Outputs[1] { @0352 revert(memory[0x00:0x00]); } // Block terminates label_0353: // Incoming call from 0x034E, returns to 0x01B9, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @035D stack[-2] // @035E msg.data[stack[-2]:stack[-2] + 0x20] // @0366 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @036E msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 0353 5B JUMPDEST 0354 50 POP 0355 60 PUSH1 0x01 0357 60 PUSH1 0x01 0359 60 PUSH1 0xa0 035B 1B SHL 035C 03 SUB 035D 81 DUP2 035E 35 CALLDATALOAD 035F 81 DUP2 0360 16 AND 0361 91 SWAP2 0362 60 PUSH1 0x20 0364 81 DUP2 0365 01 ADD 0366 35 CALLDATALOAD 0367 90 SWAP1 0368 91 SWAP2 0369 16 AND 036A 90 SWAP1 036B 60 PUSH1 0x40 036D 01 ADD 036E 35 CALLDATALOAD 036F 61 PUSH2 0x08b0 0372 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0361 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @036A stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @036E stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x08b0 label_0373: // Incoming jump from 0x00CE, if 0x313ce567 == stack[-1] 0373 5B JUMPDEST 0374 61 PUSH2 0x037b 0377 61 PUSH2 0x08fb 037A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0374 stack[0] = 0x037b } // Block ends with call to 0x08fb, returns to 0x037B label_037B: // Incoming return from call to 0x08FB at 0x037A // Inputs[4] // { // @037F memory[0x40:0x60] // @0383 stack[-1] // @0387 memory[0x40:0x60] // @0390 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 037B 5B JUMPDEST 037C 60 PUSH1 0x40 037E 80 DUP1 037F 51 MLOAD 0380 60 PUSH1 0xff 0382 90 SWAP1 0383 92 SWAP3 0384 16 AND 0385 82 DUP3 0386 52 MSTORE 0387 51 MLOAD 0388 90 SWAP1 0389 81 DUP2 038A 90 SWAP1 038B 03 SUB 038C 60 PUSH1 0x20 038E 01 ADD 038F 90 SWAP1 0390 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0386 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @0390 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0391: // Incoming jump from 0x00D9, if 0x39509351 == stack[-1] // Inputs[1] { @0398 msg.data.length } 0391 5B JUMPDEST 0392 61 PUSH2 0x01b9 0395 60 PUSH1 0x04 0397 80 DUP1 0398 36 CALLDATASIZE 0399 03 SUB 039A 60 PUSH1 0x40 039C 81 DUP2 039D 10 LT 039E 15 ISZERO 039F 61 PUSH2 0x03a7 03A2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0392 stack[0] = 0x01b9 // @0395 stack[1] = 0x04 // @0399 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x03a7, if !(msg.data.length - 0x04 < 0x40) label_03A3: // Incoming jump from 0x03A2, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03A6 memory[0x00:0x00] } 03A3 60 PUSH1 0x00 03A5 80 DUP1 03A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A6 revert(memory[0x00:0x00]); } // Block terminates label_03A7: // Incoming jump from 0x03A2, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @03B1 stack[-2] // @03B2 msg.data[stack[-2]:stack[-2] + 0x20] // @03B8 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 03A7 5B JUMPDEST 03A8 50 POP 03A9 60 PUSH1 0x01 03AB 60 PUSH1 0x01 03AD 60 PUSH1 0xa0 03AF 1B SHL 03B0 03 SUB 03B1 81 DUP2 03B2 35 CALLDATALOAD 03B3 16 AND 03B4 90 SWAP1 03B5 60 PUSH1 0x20 03B7 01 ADD 03B8 35 CALLDATALOAD 03B9 61 PUSH2 0x0904 03BC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03B4 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @03B8 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0904 label_03BD: // Incoming jump from 0x007C, if 0x40c10f19 == stack[-1] // Inputs[1] { @03C4 msg.data.length } 03BD 5B JUMPDEST 03BE 61 PUSH2 0x02fb 03C1 60 PUSH1 0x04 03C3 80 DUP1 03C4 36 CALLDATASIZE 03C5 03 SUB 03C6 60 PUSH1 0x40 03C8 81 DUP2 03C9 10 LT 03CA 15 ISZERO 03CB 61 PUSH2 0x03d3 03CE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03BE stack[0] = 0x02fb // @03C1 stack[1] = 0x04 // @03C5 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x03d3, if !(msg.data.length - 0x04 < 0x40) label_03CF: // Incoming jump from 0x03CE, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03D2 memory[0x00:0x00] } 03CF 60 PUSH1 0x00 03D1 80 DUP1 03D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D2 revert(memory[0x00:0x00]); } // Block terminates label_03D3: // Incoming jump from 0x03CE, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @03DD stack[-2] // @03DE msg.data[stack[-2]:stack[-2] + 0x20] // @03E4 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 03D3 5B JUMPDEST 03D4 50 POP 03D5 60 PUSH1 0x01 03D7 60 PUSH1 0x01 03D9 60 PUSH1 0xa0 03DB 1B SHL 03DC 03 SUB 03DD 81 DUP2 03DE 35 CALLDATALOAD 03DF 16 AND 03E0 90 SWAP1 03E1 60 PUSH1 0x20 03E3 01 ADD 03E4 35 CALLDATALOAD 03E5 61 PUSH2 0x095d 03E8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03E0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @03E4 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x095d label_03E9: // Incoming jump from 0x0087, if 0x70a08231 == stack[-1] // Inputs[1] { @03F0 msg.data.length } 03E9 5B JUMPDEST 03EA 61 PUSH2 0x0305 03ED 60 PUSH1 0x04 03EF 80 DUP1 03F0 36 CALLDATASIZE 03F1 03 SUB 03F2 60 PUSH1 0x20 03F4 81 DUP2 03F5 10 LT 03F6 15 ISZERO 03F7 61 PUSH2 0x03ff 03FA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03EA stack[0] = 0x0305 // @03ED stack[1] = 0x04 // @03F1 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03ff, returns to 0x0305, if !(msg.data.length - 0x04 < 0x20) label_03FB: // Incoming jump from 0x03FA, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @03FE memory[0x00:0x00] } 03FB 60 PUSH1 0x00 03FD 80 DUP1 03FE FD *REVERT // Stack delta = +0 // Outputs[1] { @03FE revert(memory[0x00:0x00]); } // Block terminates label_03FF: // Incoming call from 0x03FA, returns to 0x0305, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0401 stack[-2] // @0401 msg.data[stack[-2]:stack[-2] + 0x20] // } 03FF 5B JUMPDEST 0400 50 POP 0401 35 CALLDATALOAD 0402 60 PUSH1 0x01 0404 60 PUSH1 0x01 0406 60 PUSH1 0xa0 0408 1B SHL 0409 03 SUB 040A 16 AND 040B 61 PUSH2 0x09c4 040E 56 *JUMP // Stack delta = -1 // Outputs[1] { @040A stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x09c4 label_040F: // Incoming jump from 0x0092, if 0x95d89b41 == stack[-1] 040F 5B JUMPDEST 0410 61 PUSH2 0x0118 0413 61 PUSH2 0x09df 0416 56 *JUMP // Stack delta = +1 // Outputs[1] { @0410 stack[0] = 0x0118 } // Block ends with call to 0x09df, returns to 0x0118 label_0417: // Incoming jump from 0x009D, if 0xa457c2d7 == stack[-1] // Inputs[1] { @041E msg.data.length } 0417 5B JUMPDEST 0418 61 PUSH2 0x01b9 041B 60 PUSH1 0x04 041D 80 DUP1 041E 36 CALLDATASIZE 041F 03 SUB 0420 60 PUSH1 0x40 0422 81 DUP2 0423 10 LT 0424 15 ISZERO 0425 61 PUSH2 0x042d 0428 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0418 stack[0] = 0x01b9 // @041B stack[1] = 0x04 // @041F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x042d, if !(msg.data.length - 0x04 < 0x40) label_0429: // Incoming jump from 0x0428, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @042C memory[0x00:0x00] } 0429 60 PUSH1 0x00 042B 80 DUP1 042C FD *REVERT // Stack delta = +0 // Outputs[1] { @042C revert(memory[0x00:0x00]); } // Block terminates label_042D: // Incoming jump from 0x0428, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0437 stack[-2] // @0438 msg.data[stack[-2]:stack[-2] + 0x20] // @043E msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 042D 5B JUMPDEST 042E 50 POP 042F 60 PUSH1 0x01 0431 60 PUSH1 0x01 0433 60 PUSH1 0xa0 0435 1B SHL 0436 03 SUB 0437 81 DUP2 0438 35 CALLDATALOAD 0439 16 AND 043A 90 SWAP1 043B 60 PUSH1 0x20 043D 01 ADD 043E 35 CALLDATALOAD 043F 61 PUSH2 0x0a40 0442 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @043A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @043E stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0a40 label_0443: // Incoming jump from 0x0040, if 0xa9059cbb == stack[-1] // Inputs[1] { @044A msg.data.length } 0443 5B JUMPDEST 0444 61 PUSH2 0x01b9 0447 60 PUSH1 0x04 0449 80 DUP1 044A 36 CALLDATASIZE 044B 03 SUB 044C 60 PUSH1 0x40 044E 81 DUP2 044F 10 LT 0450 15 ISZERO 0451 61 PUSH2 0x0459 0454 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0444 stack[0] = 0x01b9 // @0447 stack[1] = 0x04 // @044B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0459, if !(msg.data.length - 0x04 < 0x40) label_0455: // Incoming jump from 0x0454, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0458 memory[0x00:0x00] } 0455 60 PUSH1 0x00 0457 80 DUP1 0458 FD *REVERT // Stack delta = +0 // Outputs[1] { @0458 revert(memory[0x00:0x00]); } // Block terminates label_0459: // Incoming jump from 0x0454, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0463 stack[-2] // @0464 msg.data[stack[-2]:stack[-2] + 0x20] // @046A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0459 5B JUMPDEST 045A 50 POP 045B 60 PUSH1 0x01 045D 60 PUSH1 0x01 045F 60 PUSH1 0xa0 0461 1B SHL 0462 03 SUB 0463 81 DUP2 0464 35 CALLDATALOAD 0465 16 AND 0466 90 SWAP1 0467 60 PUSH1 0x20 0469 01 ADD 046A 35 CALLDATALOAD 046B 61 PUSH2 0x0aae 046E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0466 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @046A stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0aae label_046F: // Incoming jump from 0x004B, if 0xc4d66de8 == stack[-1] // Inputs[1] { @0476 msg.data.length } 046F 5B JUMPDEST 0470 61 PUSH2 0x02fb 0473 60 PUSH1 0x04 0475 80 DUP1 0476 36 CALLDATASIZE 0477 03 SUB 0478 60 PUSH1 0x20 047A 81 DUP2 047B 10 LT 047C 15 ISZERO 047D 61 PUSH2 0x0485 0480 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0470 stack[0] = 0x02fb // @0473 stack[1] = 0x04 // @0477 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0485, returns to 0x02FB, if !(msg.data.length - 0x04 < 0x20) label_0481: // Incoming jump from 0x0480, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0484 memory[0x00:0x00] } 0481 60 PUSH1 0x00 0483 80 DUP1 0484 FD *REVERT // Stack delta = +0 // Outputs[1] { @0484 revert(memory[0x00:0x00]); } // Block terminates label_0485: // Incoming call from 0x0480, returns to 0x02FB, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0487 msg.data[stack[-2]:stack[-2] + 0x20] // @0487 stack[-2] // } 0485 5B JUMPDEST 0486 50 POP 0487 35 CALLDATALOAD 0488 60 PUSH1 0x01 048A 60 PUSH1 0x01 048C 60 PUSH1 0xa0 048E 1B SHL 048F 03 SUB 0490 16 AND 0491 61 PUSH2 0x0ac2 0494 56 *JUMP // Stack delta = -1 // Outputs[1] { @0490 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0ac2 label_0495: // Incoming jump from 0x0056, if 0xc6dbdf61 == stack[-1] 0495 5B JUMPDEST 0496 61 PUSH2 0x049d 0499 61 PUSH2 0x0bbb 049C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0496 stack[0] = 0x049d } // Block ends with call to 0x0bbb, returns to 0x049D label_049D: // Incoming return from call to 0x0BBB at 0x049C // Inputs[4] // { // @04A1 memory[0x40:0x60] // @04AB stack[-1] // @04AF memory[0x40:0x60] // @04B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 049D 5B JUMPDEST 049E 60 PUSH1 0x40 04A0 80 DUP1 04A1 51 MLOAD 04A2 60 PUSH1 0x01 04A4 60 PUSH1 0x01 04A6 60 PUSH1 0xa0 04A8 1B SHL 04A9 03 SUB 04AA 90 SWAP1 04AB 92 SWAP3 04AC 16 AND 04AD 82 DUP3 04AE 52 MSTORE 04AF 51 MLOAD 04B0 90 SWAP1 04B1 81 DUP2 04B2 90 SWAP1 04B3 03 SUB 04B4 60 PUSH1 0x20 04B6 01 ADD 04B7 90 SWAP1 04B8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @04B8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_04B9: // Incoming jump from 0x0061, if 0xdd62ed3e == stack[-1] // Inputs[1] { @04C0 msg.data.length } 04B9 5B JUMPDEST 04BA 61 PUSH2 0x0305 04BD 60 PUSH1 0x04 04BF 80 DUP1 04C0 36 CALLDATASIZE 04C1 03 SUB 04C2 60 PUSH1 0x40 04C4 81 DUP2 04C5 10 LT 04C6 15 ISZERO 04C7 61 PUSH2 0x04cf 04CA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04BA stack[0] = 0x0305 // @04BD stack[1] = 0x04 // @04C1 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04cf, returns to 0x0305, if !(msg.data.length - 0x04 < 0x40) label_04CB: // Incoming jump from 0x04CA, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @04CE memory[0x00:0x00] } 04CB 60 PUSH1 0x00 04CD 80 DUP1 04CE FD *REVERT // Stack delta = +0 // Outputs[1] { @04CE revert(memory[0x00:0x00]); } // Block terminates label_04CF: // Incoming call from 0x04CA, returns to 0x0305, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @04D9 stack[-2] // @04DA msg.data[stack[-2]:stack[-2] + 0x20] // @04E1 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 04CF 5B JUMPDEST 04D0 50 POP 04D1 60 PUSH1 0x01 04D3 60 PUSH1 0x01 04D5 60 PUSH1 0xa0 04D7 1B SHL 04D8 03 SUB 04D9 81 DUP2 04DA 35 CALLDATALOAD 04DB 81 DUP2 04DC 16 AND 04DD 91 SWAP2 04DE 60 PUSH1 0x20 04E0 01 ADD 04E1 35 CALLDATALOAD 04E2 16 AND 04E3 61 PUSH2 0x0bca 04E6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @04DD stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @04E2 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x0bca label_04E7: // Incoming jump from 0x006C, if 0xde7ea79d == stack[-1] // Inputs[1] { @04EE msg.data.length } 04E7 5B JUMPDEST 04E8 61 PUSH2 0x02fb 04EB 60 PUSH1 0x04 04ED 80 DUP1 04EE 36 CALLDATASIZE 04EF 03 SUB 04F0 60 PUSH1 0x80 04F2 81 DUP2 04F3 10 LT 04F4 15 ISZERO 04F5 61 PUSH2 0x04fd 04F8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04E8 stack[0] = 0x02fb // @04EB stack[1] = 0x04 // @04EF stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x04fd, if !(msg.data.length - 0x04 < 0x80) label_04F9: // Incoming jump from 0x04F8, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @04FC memory[0x00:0x00] } 04F9 60 PUSH1 0x00 04FB 80 DUP1 04FC FD *REVERT // Stack delta = +0 // Outputs[1] { @04FC revert(memory[0x00:0x00]); } // Block terminates label_04FD: // Incoming jump from 0x04F8, if !(msg.data.length - 0x04 < 0x80) // Inputs[3] // { // @04FE stack[-2] // @04FF stack[-1] // @0506 msg.data[stack[-2]:stack[-2] + 0x20] // } 04FD 5B JUMPDEST 04FE 81 DUP2 04FF 01 ADD 0500 90 SWAP1 0501 60 PUSH1 0x20 0503 81 DUP2 0504 01 ADD 0505 81 DUP2 0506 35 CALLDATALOAD 0507 60 PUSH1 0x01 0509 60 PUSH1 0x20 050B 1B SHL 050C 81 DUP2 050D 11 GT 050E 15 ISZERO 050F 61 PUSH2 0x0517 0512 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0500 stack[-1] = stack[-2] // @0500 stack[-2] = stack[-2] + stack[-1] // @0504 stack[0] = stack[-2] + 0x20 // @0506 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x0517, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) label_0513: // Incoming jump from 0x0512, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[1] { @0516 memory[0x00:0x00] } 0513 60 PUSH1 0x00 0515 80 DUP1 0516 FD *REVERT // Stack delta = +0 // Outputs[1] { @0516 revert(memory[0x00:0x00]); } // Block terminates label_0517: // Incoming jump from 0x0512, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @0518 stack[-3] // @0519 stack[-1] // @051A stack[-4] // } 0517 5B JUMPDEST 0518 82 DUP3 0519 01 ADD 051A 83 DUP4 051B 60 PUSH1 0x20 051D 82 DUP3 051E 01 ADD 051F 11 GT 0520 15 ISZERO 0521 61 PUSH2 0x0529 0524 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0519 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0529, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0525: // Incoming jump from 0x0524, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0528 memory[0x00:0x00] } 0525 60 PUSH1 0x00 0527 80 DUP1 0528 FD *REVERT // Stack delta = +0 // Outputs[1] { @0528 revert(memory[0x00:0x00]); } // Block terminates label_0529: // Incoming jump from 0x0524, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @052A stack[-1] // @052B msg.data[stack[-1]:stack[-1] + 0x20] // @0530 stack[-2] // @0531 stack[-4] // } 0529 5B JUMPDEST 052A 80 DUP1 052B 35 CALLDATALOAD 052C 90 SWAP1 052D 60 PUSH1 0x20 052F 01 ADD 0530 91 SWAP2 0531 84 DUP5 0532 60 PUSH1 0x01 0534 83 DUP4 0535 02 MUL 0536 84 DUP5 0537 01 ADD 0538 11 GT 0539 60 PUSH1 0x01 053B 60 PUSH1 0x20 053D 1B SHL 053E 83 DUP4 053F 11 GT 0540 17 OR 0541 15 ISZERO 0542 61 PUSH2 0x054a 0545 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @052C stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0530 stack[0] = stack[-2] // @0530 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x054a, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0546: // Incoming jump from 0x0545, 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] { @0549 memory[0x00:0x00] } 0546 60 PUSH1 0x00 0548 80 DUP1 0549 FD *REVERT // Stack delta = +0 // Outputs[1] { @0549 revert(memory[0x00:0x00]); } // Block terminates label_054A: // Incoming jump from 0x0545, 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] // { // @054B stack[-3] // @054B stack[-1] // @054C stack[-2] // @055D memory[0x40:0x60] // @0574 msg.data[stack[-3]:stack[-3] + stack[-2]] // @057F stack[-5] // @0580 stack[-4] // @0588 msg.data[stack[-1]:stack[-1] + 0x20] // } 054A 5B JUMPDEST 054B 91 SWAP2 054C 90 SWAP1 054D 80 DUP1 054E 80 DUP1 054F 60 PUSH1 0x1f 0551 01 ADD 0552 60 PUSH1 0x20 0554 80 DUP1 0555 91 SWAP2 0556 04 DIV 0557 02 MUL 0558 60 PUSH1 0x20 055A 01 ADD 055B 60 PUSH1 0x40 055D 51 MLOAD 055E 90 SWAP1 055F 81 DUP2 0560 01 ADD 0561 60 PUSH1 0x40 0563 52 MSTORE 0564 80 DUP1 0565 93 SWAP4 0566 92 SWAP3 0567 91 SWAP2 0568 90 SWAP1 0569 81 DUP2 056A 81 DUP2 056B 52 MSTORE 056C 60 PUSH1 0x20 056E 01 ADD 056F 83 DUP4 0570 83 DUP4 0571 80 DUP1 0572 82 DUP3 0573 84 DUP5 0574 37 CALLDATACOPY 0575 60 PUSH1 0x00 0577 92 SWAP3 0578 01 ADD 0579 91 SWAP2 057A 90 SWAP1 057B 91 SWAP2 057C 52 MSTORE 057D 50 POP 057E 92 SWAP3 057F 95 SWAP6 0580 94 SWAP5 0581 93 SWAP4 0582 60 PUSH1 0x20 0584 81 DUP2 0585 01 ADD 0586 93 SWAP4 0587 50 POP 0588 35 CALLDATALOAD 0589 91 SWAP2 058A 50 POP 058B 50 POP 058C 60 PUSH1 0x01 058E 60 PUSH1 0x20 0590 1B SHL 0591 81 DUP2 0592 11 GT 0593 15 ISZERO 0594 61 PUSH2 0x059c 0597 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0563 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @056B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0574 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @057C memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @057F stack[-5] = memory[0x40:0x60] // @0580 stack[-4] = stack[-5] // @0581 stack[-3] = stack[-4] // @0586 stack[-2] = stack[-1] + 0x20 // @0589 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x059c, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) label_0598: // Incoming jump from 0x0597, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[1] { @059B memory[0x00:0x00] } 0598 60 PUSH1 0x00 059A 80 DUP1 059B FD *REVERT // Stack delta = +0 // Outputs[1] { @059B revert(memory[0x00:0x00]); } // Block terminates label_059C: // Incoming jump from 0x0597, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) // Inputs[3] // { // @059D stack[-3] // @059E stack[-1] // @059F stack[-4] // } 059C 5B JUMPDEST 059D 82 DUP3 059E 01 ADD 059F 83 DUP4 05A0 60 PUSH1 0x20 05A2 82 DUP3 05A3 01 ADD 05A4 11 GT 05A5 15 ISZERO 05A6 61 PUSH2 0x05ae 05A9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @059E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x05ae, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_05AA: // Incoming jump from 0x05A9, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @05AD memory[0x00:0x00] } 05AA 60 PUSH1 0x00 05AC 80 DUP1 05AD FD *REVERT // Stack delta = +0 // Outputs[1] { @05AD revert(memory[0x00:0x00]); } // Block terminates label_05AE: // Incoming jump from 0x05A9, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @05AF stack[-1] // @05B0 msg.data[stack[-1]:stack[-1] + 0x20] // @05B5 stack[-2] // @05B6 stack[-4] // } 05AE 5B JUMPDEST 05AF 80 DUP1 05B0 35 CALLDATALOAD 05B1 90 SWAP1 05B2 60 PUSH1 0x20 05B4 01 ADD 05B5 91 SWAP2 05B6 84 DUP5 05B7 60 PUSH1 0x01 05B9 83 DUP4 05BA 02 MUL 05BB 84 DUP5 05BC 01 ADD 05BD 11 GT 05BE 60 PUSH1 0x01 05C0 60 PUSH1 0x20 05C2 1B SHL 05C3 83 DUP4 05C4 11 GT 05C5 17 OR 05C6 15 ISZERO 05C7 61 PUSH2 0x05cf 05CA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @05B1 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @05B5 stack[0] = stack[-2] // @05B5 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x05cf, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_05CB: // Incoming jump from 0x05CA, 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] { @05CE memory[0x00:0x00] } 05CB 60 PUSH1 0x00 05CD 80 DUP1 05CE FD *REVERT // Stack delta = +0 // Outputs[1] { @05CE revert(memory[0x00:0x00]); } // Block terminates label_05CF: // Incoming jump from 0x05CA, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x01 << 0x20) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[9] // { // @05D0 stack[-3] // @05D0 stack[-1] // @05D1 stack[-2] // @05E2 memory[0x40:0x60] // @05F9 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0604 stack[-5] // @0609 msg.data[stack[-1]:stack[-1] + 0x20] // @060D stack[-4] // @0613 msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } 05CF 5B JUMPDEST 05D0 91 SWAP2 05D1 90 SWAP1 05D2 80 DUP1 05D3 80 DUP1 05D4 60 PUSH1 0x1f 05D6 01 ADD 05D7 60 PUSH1 0x20 05D9 80 DUP1 05DA 91 SWAP2 05DB 04 DIV 05DC 02 MUL 05DD 60 PUSH1 0x20 05DF 01 ADD 05E0 60 PUSH1 0x40 05E2 51 MLOAD 05E3 90 SWAP1 05E4 81 DUP2 05E5 01 ADD 05E6 60 PUSH1 0x40 05E8 52 MSTORE 05E9 80 DUP1 05EA 93 SWAP4 05EB 92 SWAP3 05EC 91 SWAP2 05ED 90 SWAP1 05EE 81 DUP2 05EF 81 DUP2 05F0 52 MSTORE 05F1 60 PUSH1 0x20 05F3 01 ADD 05F4 83 DUP4 05F5 83 DUP4 05F6 80 DUP1 05F7 82 DUP3 05F8 84 DUP5 05F9 37 CALLDATACOPY 05FA 60 PUSH1 0x00 05FC 92 SWAP3 05FD 01 ADD 05FE 91 SWAP2 05FF 90 SWAP1 0600 91 SWAP2 0601 52 MSTORE 0602 50 POP 0603 92 SWAP3 0604 95 SWAP6 0605 50 POP 0606 50 POP 0607 50 POP 0608 81 DUP2 0609 35 CALLDATALOAD 060A 60 PUSH1 0xff 060C 16 AND 060D 92 SWAP3 060E 50 POP 060F 50 POP 0610 60 PUSH1 0x20 0612 01 ADD 0613 35 CALLDATALOAD 0614 60 PUSH1 0x01 0616 60 PUSH1 0x01 0618 60 PUSH1 0xa0 061A 1B SHL 061B 03 SUB 061C 16 AND 061D 61 PUSH2 0x0c07 0620 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @05E8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @05F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @05F9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0601 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0604 stack[-5] = memory[0x40:0x60] // @060D stack[-4] = 0xff & msg.data[stack[-1]:stack[-1] + 0x20] // @061C stack[-3] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x0c07 label_0621: // Incoming call from 0x0117, returns to 0x0118 // Inputs[2] // { // @0625 storage[0x68] // @0629 memory[0x40:0x60] // } 0621 5B JUMPDEST 0622 60 PUSH1 0x68 0624 80 DUP1 0625 54 SLOAD 0626 60 PUSH1 0x40 0628 80 DUP1 0629 51 MLOAD 062A 60 PUSH1 0x20 062C 60 PUSH1 0x1f 062E 60 PUSH1 0x02 0630 60 PUSH1 0x00 0632 19 NOT 0633 61 PUSH2 0x0100 0636 60 PUSH1 0x01 0638 88 DUP9 0639 16 AND 063A 15 ISZERO 063B 02 MUL 063C 01 ADD 063D 90 SWAP1 063E 95 SWAP6 063F 16 AND 0640 94 SWAP5 0641 90 SWAP1 0642 94 SWAP5 0643 04 DIV 0644 93 SWAP4 0645 84 DUP5 0646 01 ADD 0647 81 DUP2 0648 90 SWAP1 0649 04 DIV 064A 81 DUP2 064B 02 MUL 064C 82 DUP3 064D 01 ADD 064E 81 DUP2 064F 01 ADD 0650 90 SWAP1 0651 92 SWAP3 0652 52 MSTORE 0653 82 DUP3 0654 81 DUP2 0655 52 MSTORE 0656 60 PUSH1 0x60 0658 93 SWAP4 0659 90 SWAP1 065A 92 SWAP3 065B 90 SWAP1 065C 91 SWAP2 065D 83 DUP4 065E 01 ADD 065F 82 DUP3 0660 82 DUP3 0661 80 DUP1 0662 15 ISZERO 0663 61 PUSH2 0x06ad 0666 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0652 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x68] & !(storage[0x68] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0655 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x68] & !(storage[0x68] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0658 stack[0] = 0x60 // @065A stack[1] = memory[0x40:0x60] // @065B stack[3] = (storage[0x68] & !(storage[0x68] & 0x01) * 0x0100 + ~0x00) / 0x02 // @065C stack[2] = 0x68 // @065E stack[4] = memory[0x40:0x60] + 0x20 // @065F stack[5] = 0x68 // @0660 stack[6] = (storage[0x68] & !(storage[0x68] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x06ad, if !((storage[0x68] & !(storage[0x68] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0667: // Incoming jump from 0x0666, if not !((storage[0x68] & !(storage[0x68] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0667 stack[-1] } 0667 80 DUP1 0668 60 PUSH1 0x1f 066A 10 LT 066B 61 PUSH2 0x0682 066E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0682, if 0x1f < stack[-1] label_066F: // Incoming jump from 0x066E, if not 0x1f < stack[-1] // Inputs[4] // { // @0673 stack[-2] // @0674 storage[stack[-2]] // @0677 stack[-3] // @0679 stack[-1] // } 066F 61 PUSH2 0x0100 0672 80 DUP1 0673 83 DUP4 0674 54 SLOAD 0675 04 DIV 0676 02 MUL 0677 83 DUP4 0678 52 MSTORE 0679 91 SWAP2 067A 60 PUSH1 0x20 067C 01 ADD 067D 91 SWAP2 067E 61 PUSH2 0x06ad 0681 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0678 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @067D stack[-1] = stack[-1] // @067D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06ad label_0682: // Incoming jump from 0x0A2C, if 0x1f < stack[-1] // Incoming jump from 0x066E, if 0x1f < stack[-1] // Inputs[5] // { // @0683 stack[-3] // @0684 stack[-1] // @0686 stack[-2] // @068E memory[0x00:0x20] // @0692 storage[keccak256(memory[0x00:0x20])] // } 0682 5B JUMPDEST 0683 82 DUP3 0684 01 ADD 0685 91 SWAP2 0686 90 SWAP1 0687 60 PUSH1 0x00 0689 52 MSTORE 068A 60 PUSH1 0x20 068C 60 PUSH1 0x00 068E 20 SHA3 068F 90 SWAP1 0690 5B JUMPDEST 0691 81 DUP2 0692 54 SLOAD 0693 81 DUP2 0694 52 MSTORE 0695 90 SWAP1 0696 60 PUSH1 0x01 0698 01 ADD 0699 90 SWAP1 069A 60 PUSH1 0x20 069C 01 ADD 069D 80 DUP1 069E 83 DUP4 069F 11 GT 06A0 61 PUSH2 0x0690 06A3 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0685 stack[-3] = stack[-3] + stack[-1] // @0689 memory[0x00:0x20] = stack[-2] // @0694 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0699 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @069C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0690, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06A4: // Incoming jump from 0x06A3, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x06A3, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @06A4 stack[-3] // @06A5 stack[-1] // } 06A4 82 DUP3 06A5 90 SWAP1 06A6 03 SUB 06A7 60 PUSH1 0x1f 06A9 16 AND 06AA 82 DUP3 06AB 01 ADD 06AC 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @06AC stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @06AC stack[-1] = stack[-3] // } // Block continues label_06AD: // Incoming jump from 0x0681 // Incoming jump from 0x0A24, if !((storage[0x69] & !(storage[0x69] & 0x01) * 0x0100 + ~0x00) / 0x02) // Incoming jump from 0x0A3F // Incoming jump from 0x06AC // Incoming jump from 0x0666, if !((storage[0x68] & !(storage[0x68] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[3] // { // @06B3 stack[-7] // @06B3 stack[-6] // @06B6 stack[-8] // } 06AD 5B JUMPDEST 06AE 50 POP 06AF 50 POP 06B0 50 POP 06B1 50 POP 06B2 50 POP 06B3 90 SWAP1 06B4 50 POP 06B5 5B JUMPDEST 06B6 90 SWAP1 06B7 56 *JUMP // Stack delta = -7 // Outputs[1] { @06B6 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_06B8: // Incoming jump from 0x01B8 06B8 5B JUMPDEST 06B9 60 PUSH1 0x00 06BB 61 PUSH2 0x06cc 06BE 61 PUSH2 0x06c5 06C1 61 PUSH2 0x0cc1 06C4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06B9 stack[0] = 0x00 // @06BB stack[1] = 0x06cc // @06BE stack[2] = 0x06c5 // } // Block ends with call to 0x0cc1, returns to 0x06C5 label_06C5: // Incoming return from call to 0x0CC1 at 0x06C4 // Inputs[2] // { // @06C6 stack[-5] // @06C7 stack[-4] // } 06C5 5B JUMPDEST 06C6 84 DUP5 06C7 84 DUP5 06C8 61 PUSH2 0x0cc5 06CB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06C6 stack[0] = stack[-5] // @06C7 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x0cc5 label_06CC: // Incoming return from call to 0x0A4D at 0x0A4C // Incoming return from call to 0x0ABB at 0x0ABA // Incoming return from call to 0x06C5 at 0x06C4 // Incoming return from call to 0x0911 at 0x0910 06CC 5B JUMPDEST 06CD 50 POP 06CE 60 PUSH1 0x01 // Stack delta = +0 // Outputs[1] { @06CE stack[-1] = 0x01 } // Block continues label_06D0: // Incoming jump from 0x0C06 // Incoming jump from 0x0BF5 // Incoming jump from 0x06CE // Inputs[3] // { // @06D1 stack[-4] // @06D1 stack[-1] // @06D2 stack[-3] // } 06D0 5B JUMPDEST 06D1 92 SWAP3 06D2 91 SWAP2 06D3 50 POP 06D4 50 POP 06D5 56 *JUMP // Stack delta = -3 // Outputs[1] { @06D1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_06D6: // Incoming jump from 0x02FA // Incoming jump from 0x0C9E // Incoming jump from 0x0C9E // Inputs[1] { @06D9 storage[0x00] } 06D6 5B JUMPDEST 06D7 60 PUSH1 0x00 06D9 54 SLOAD 06DA 61 PUSH2 0x0100 06DD 90 SWAP1 06DE 04 DIV 06DF 60 PUSH1 0xff 06E1 16 AND 06E2 80 DUP1 06E3 61 PUSH2 0x06ef 06E6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06E1 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x06ef, if 0xff & storage[0x00] / 0x0100 label_06E7: // Incoming jump from 0x06E6, if not 0xff & storage[0x00] / 0x0100 06E7 50 POP 06E8 61 PUSH2 0x06ef 06EB 61 PUSH2 0x0cfb 06EE 56 *JUMP // Stack delta = +0 // Outputs[1] { @06E8 stack[-1] = 0x06ef } // Block ends with call to 0x0cfb, returns to 0x06EF label_06EF: // Incoming return from call to 0x0CFB at 0x06EE // Incoming jump from 0x06E6, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @06F0 stack[-1] } 06EF 5B JUMPDEST 06F0 80 DUP1 06F1 61 PUSH2 0x06fd 06F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06fd, if stack[-1] label_06F5: // Incoming jump from 0x06F4, if not stack[-1] // Inputs[1] { @06F8 storage[0x00] } 06F5 50 POP 06F6 60 PUSH1 0x00 06F8 54 SLOAD 06F9 60 PUSH1 0xff 06FB 16 AND 06FC 15 ISZERO 06FD 5B JUMPDEST 06FE 61 PUSH2 0x0738 0701 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0738, if !(0xff & storage[0x00]) label_0702: // Incoming jump from 0x0701, if not stack[-1] // Incoming jump from 0x0701, if not !(0xff & storage[0x00]) // Inputs[3] // { // @0704 memory[0x40:0x60] // @0732 memory[0x40:0x60] // @0737 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0702 60 PUSH1 0x40 0704 51 MLOAD 0705 62 PUSH3 0x461bcd 0709 60 PUSH1 0xe5 070B 1B SHL 070C 81 DUP2 070D 52 MSTORE 070E 60 PUSH1 0x04 0710 01 ADD 0711 80 DUP1 0712 80 DUP1 0713 60 PUSH1 0x20 0715 01 ADD 0716 82 DUP3 0717 81 DUP2 0718 03 SUB 0719 82 DUP3 071A 52 MSTORE 071B 60 PUSH1 0x2e 071D 81 DUP2 071E 52 MSTORE 071F 60 PUSH1 0x20 0721 01 ADD 0722 80 DUP1 0723 61 PUSH2 0x130d 0726 60 PUSH1 0x2e 0728 91 SWAP2 0729 39 CODECOPY 072A 60 PUSH1 0x40 072C 01 ADD 072D 91 SWAP2 072E 50 POP 072F 50 POP 0730 60 PUSH1 0x40 0732 51 MLOAD 0733 80 DUP1 0734 91 SWAP2 0735 03 SUB 0736 90 SWAP1 0737 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @070D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @071A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @071E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @0729 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x130d:0x133b] // @0737 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0738: // Incoming jump from 0x0701, if stack[-1] // Incoming jump from 0x0701, if !(0xff & storage[0x00]) // Inputs[1] { @073B storage[0x00] } 0738 5B JUMPDEST 0739 60 PUSH1 0x00 073B 54 SLOAD 073C 61 PUSH2 0x0100 073F 90 SWAP1 0740 04 DIV 0741 60 PUSH1 0xff 0743 16 AND 0744 15 ISZERO 0745 80 DUP1 0746 15 ISZERO 0747 61 PUSH2 0x0763 074A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0744 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x0763, if !!(0xff & storage[0x00] / 0x0100) label_074B: // Incoming jump from 0x074A, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[3] // { // @074E storage[0x00] // @0764 stack[-4] // @0765 memory[stack[-4]:stack[-4] + 0x20] // } 074B 60 PUSH1 0x00 074D 80 DUP1 074E 54 SLOAD 074F 60 PUSH1 0xff 0751 19 NOT 0752 61 PUSH2 0xff00 0755 19 NOT 0756 90 SWAP1 0757 91 SWAP2 0758 16 AND 0759 61 PUSH2 0x0100 075C 17 OR 075D 16 AND 075E 60 PUSH1 0x01 0760 17 OR 0761 90 SWAP1 0762 55 SSTORE 0763 5B JUMPDEST 0764 83 DUP4 0765 51 MLOAD 0766 61 PUSH2 0x0776 0769 90 SWAP1 076A 60 PUSH1 0x68 076C 90 SWAP1 076D 60 PUSH1 0x20 076F 87 DUP8 0770 01 ADD 0771 90 SWAP1 0772 61 PUSH2 0x11e1 0775 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0762 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @0769 stack[0] = 0x0776 // @076C stack[1] = 0x68 // @0771 stack[2] = stack[-4] + 0x20 // @0771 stack[3] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with unconditional jump to 0x11e1 0776 5B JUMPDEST 0777 50 POP 0778 82 DUP3 0779 51 MLOAD 077A 61 PUSH2 0x078a 077D 90 SWAP1 077E 60 PUSH1 0x69 0780 90 SWAP1 0781 60 PUSH1 0x20 0783 86 DUP7 0784 01 ADD 0785 90 SWAP1 0786 61 PUSH2 0x11e1 0789 56 *JUMP 078A 5B JUMPDEST 078B 50 POP 078C 60 PUSH1 0x6a 078E 80 DUP1 078F 54 SLOAD 0790 60 PUSH1 0xff 0792 19 NOT 0793 16 AND 0794 60 PUSH1 0xff 0796 84 DUP5 0797 16 AND 0798 17 OR 0799 90 SWAP1 079A 55 SSTORE 079B 80 DUP1 079C 15 ISZERO 079D 61 PUSH2 0x07ac 07A0 57 *JUMPI 07A1 60 PUSH1 0x00 07A3 80 DUP1 07A4 54 SLOAD 07A5 61 PUSH2 0xff00 07A8 19 NOT 07A9 16 AND 07AA 90 SWAP1 07AB 55 SSTORE 07AC 5B JUMPDEST 07AD 50 POP 07AE 50 POP 07AF 50 POP 07B0 50 POP 07B1 56 *JUMP label_07B2: // Incoming call from 0x0304, returns to 0x0305 // Inputs[2] // { // @07B5 storage[0x35] // @07B6 stack[-1] // } 07B2 5B JUMPDEST 07B3 60 PUSH1 0x35 07B5 54 SLOAD 07B6 90 SWAP1 07B7 56 *JUMP // Stack delta = +0 // Outputs[1] { @07B6 stack[-1] = storage[0x35] } // Block ends with unconditional jump to stack[-1] label_07B8: // Incoming jump from 0x033C // Inputs[1] { @07BB storage[0x9d] } 07B8 5B JUMPDEST 07B9 60 PUSH1 0x9d 07BB 54 SLOAD 07BC 60 PUSH1 0x01 07BE 60 PUSH1 0x01 07C0 60 PUSH1 0xa0 07C2 1B SHL 07C3 03 SUB 07C4 16 AND 07C5 61 PUSH2 0x07cc 07C8 61 PUSH2 0x0cc1 07CB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07C4 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x9d] // @07C5 stack[1] = 0x07cc // } // Block ends with call to 0x0cc1, returns to 0x07CC label_07CC: // Incoming return from call to 0x0CC1 at 0x07CB // Inputs[2] // { // @07D5 stack[-1] // @07D6 stack[-2] // } 07CC 5B JUMPDEST 07CD 60 PUSH1 0x01 07CF 60 PUSH1 0x01 07D1 60 PUSH1 0xa0 07D3 1B SHL 07D4 03 SUB 07D5 16 AND 07D6 14 EQ 07D7 61 PUSH2 0x0811 07DA 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0811, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_07DB: // Incoming jump from 0x07DA, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @07DD memory[0x40:0x60] // @080B memory[0x40:0x60] // @0810 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07DB 60 PUSH1 0x40 07DD 51 MLOAD 07DE 62 PUSH3 0x461bcd 07E2 60 PUSH1 0xe5 07E4 1B SHL 07E5 81 DUP2 07E6 52 MSTORE 07E7 60 PUSH1 0x04 07E9 01 ADD 07EA 80 DUP1 07EB 80 DUP1 07EC 60 PUSH1 0x20 07EE 01 ADD 07EF 82 DUP3 07F0 81 DUP2 07F1 03 SUB 07F2 82 DUP3 07F3 52 MSTORE 07F4 60 PUSH1 0x2c 07F6 81 DUP2 07F7 52 MSTORE 07F8 60 PUSH1 0x20 07FA 01 ADD 07FB 80 DUP1 07FC 61 PUSH2 0x138a 07FF 60 PUSH1 0x2c 0801 91 SWAP2 0802 39 CODECOPY 0803 60 PUSH1 0x40 0805 01 ADD 0806 91 SWAP2 0807 50 POP 0808 50 POP 0809 60 PUSH1 0x40 080B 51 MLOAD 080C 80 DUP1 080D 91 SWAP2 080E 03 SUB 080F 90 SWAP1 0810 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @07E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07F3 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @07F7 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @0802 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x138a:0x13b6] // @0810 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0811: // Incoming jump from 0x07DA, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @081A stack[-1] } 0811 5B JUMPDEST 0812 60 PUSH1 0x01 0814 60 PUSH1 0x01 0816 60 PUSH1 0xa0 0818 1B SHL 0819 03 SUB 081A 81 DUP2 081B 16 AND 081C 61 PUSH2 0x0856 081F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0856, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0820: // Incoming jump from 0x081F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0822 memory[0x40:0x60] // @0850 memory[0x40:0x60] // @0855 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0820 60 PUSH1 0x40 0822 51 MLOAD 0823 62 PUSH3 0x461bcd 0827 60 PUSH1 0xe5 0829 1B SHL 082A 81 DUP2 082B 52 MSTORE 082C 60 PUSH1 0x04 082E 01 ADD 082F 80 DUP1 0830 80 DUP1 0831 60 PUSH1 0x20 0833 01 ADD 0834 82 DUP3 0835 81 DUP2 0836 03 SUB 0837 82 DUP3 0838 52 MSTORE 0839 60 PUSH1 0x2a 083B 81 DUP2 083C 52 MSTORE 083D 60 PUSH1 0x20 083F 01 ADD 0840 80 DUP1 0841 61 PUSH2 0x133b 0844 60 PUSH1 0x2a 0846 91 SWAP2 0847 39 CODECOPY 0848 60 PUSH1 0x40 084A 01 ADD 084B 91 SWAP2 084C 50 POP 084D 50 POP 084E 60 PUSH1 0x40 0850 51 MLOAD 0851 80 DUP1 0852 91 SWAP2 0853 03 SUB 0854 90 SWAP1 0855 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @082B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0838 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @083C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2a // @0847 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2a] = code[0x133b:0x1365] // @0855 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0856: // Incoming jump from 0x081F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @085A storage[0x9d] // @086D stack[-1] // @087B memory[0x40:0x60] // @0882 memory[0x40:0x60] // @08AD memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20] // @08AF stack[-2] // } 0856 5B JUMPDEST 0857 60 PUSH1 0x9d 0859 80 DUP1 085A 54 SLOAD 085B 60 PUSH1 0x01 085D 60 PUSH1 0x01 085F 60 PUSH1 0xa0 0861 1B SHL 0862 03 SUB 0863 19 NOT 0864 16 AND 0865 60 PUSH1 0x01 0867 60 PUSH1 0x01 0869 60 PUSH1 0xa0 086B 1B SHL 086C 03 SUB 086D 83 DUP4 086E 81 DUP2 086F 16 AND 0870 91 SWAP2 0871 90 SWAP1 0872 91 SWAP2 0873 17 OR 0874 91 SWAP2 0875 82 DUP3 0876 90 SWAP1 0877 55 SSTORE 0878 60 PUSH1 0x40 087A 80 DUP1 087B 51 MLOAD 087C 92 SWAP3 087D 90 SWAP1 087E 91 SWAP2 087F 16 AND 0880 82 DUP3 0881 52 MSTORE 0882 51 MLOAD 0883 7F PUSH32 0x4101e71e974f68df5e9730cc223280b41654676bbb052cdcc735c3337e64d2d9 08A4 91 SWAP2 08A5 60 PUSH1 0x20 08A7 90 SWAP1 08A8 82 DUP3 08A9 90 SWAP1 08AA 03 SUB 08AB 01 ADD 08AC 90 SWAP1 08AD A1 LOG1 08AE 50 POP 08AF 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0877 storage[0x9d] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x9d]) // @0881 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x9d])) // @08AD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20], [0x4101e71e974f68df5e9730cc223280b41654676bbb052cdcc735c3337e64d2d9]); // } // Block ends with unconditional jump to stack[-2] label_08B0: // Incoming jump from 0x0372 08B0 5B JUMPDEST 08B1 60 PUSH1 0x00 08B3 61 PUSH2 0x08ba 08B6 61 PUSH2 0x0bbb 08B9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @08B1 stack[0] = 0x00 // @08B3 stack[1] = 0x08ba // } // Block ends with call to 0x0bbb, returns to 0x08BA label_08BA: // Incoming return from call to 0x0BBB at 0x08B9 // Inputs[2] // { // @08C3 stack[-1] // @08C4 stack[-4] // } 08BA 5B JUMPDEST 08BB 60 PUSH1 0x01 08BD 60 PUSH1 0x01 08BF 60 PUSH1 0xa0 08C1 1B SHL 08C2 03 SUB 08C3 16 AND 08C4 83 DUP4 08C5 60 PUSH1 0x01 08C7 60 PUSH1 0x01 08C9 60 PUSH1 0xa0 08CB 1B SHL 08CC 03 SUB 08CD 16 AND 08CE 14 EQ 08CF 15 ISZERO 08D0 61 PUSH2 0x08e6 08D3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08e6, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_08D4: // Incoming jump from 0x08D3, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @08D7 stack[-4] // @08D8 stack[-3] // @08D9 stack[-2] // } 08D4 61 PUSH2 0x08de 08D7 84 DUP5 08D8 84 DUP5 08D9 84 DUP5 08DA 61 PUSH2 0x0d01 08DD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08D4 stack[0] = 0x08de // @08D7 stack[1] = stack[-4] // @08D8 stack[2] = stack[-3] // @08D9 stack[3] = stack[-2] // } // Block ends with call to 0x0d01, returns to 0x08DE label_08DE: // Incoming return from call to 0x0D01 at 0x08DD 08DE 5B JUMPDEST 08DF 50 POP 08E0 60 PUSH1 0x01 08E2 61 PUSH2 0x08f4 08E5 56 *JUMP // Stack delta = +0 // Outputs[1] { @08E0 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x08f4 label_08E6: // Incoming jump from 0x08D3, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @08EA stack[-4] // @08EB stack[-3] // @08EC stack[-2] // } 08E6 5B JUMPDEST 08E7 61 PUSH2 0x08f1 08EA 84 DUP5 08EB 84 DUP5 08EC 84 DUP5 08ED 61 PUSH2 0x0e5f 08F0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08E7 stack[0] = 0x08f1 // @08EA stack[1] = stack[-4] // @08EB stack[2] = stack[-3] // @08EC stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x0e5f 08F1 5B JUMPDEST 08F2 90 SWAP1 08F3 50 POP label_08F4: // Incoming jump from 0x0EF4, if !(stack[-1] + stack[-2] < stack[-2]) // Incoming jump from 0x08E5 // Inputs[3] // { // @08F5 stack[-5] // @08F5 stack[-1] // @08F6 stack[-4] // } 08F4 5B JUMPDEST 08F5 93 SWAP4 08F6 92 SWAP3 08F7 50 POP 08F8 50 POP 08F9 50 POP 08FA 56 *JUMP // Stack delta = -4 // Outputs[1] { @08F5 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_08FB: // Incoming call from 0x037A, returns to 0x037B // Inputs[2] // { // @08FE storage[0x6a] // @0902 stack[-1] // } 08FB 5B JUMPDEST 08FC 60 PUSH1 0x6a 08FE 54 SLOAD 08FF 60 PUSH1 0xff 0901 16 AND 0902 90 SWAP1 0903 56 *JUMP // Stack delta = +0 // Outputs[1] { @0902 stack[-1] = 0xff & storage[0x6a] } // Block ends with unconditional jump to stack[-1] label_0904: // Incoming jump from 0x03BC 0904 5B JUMPDEST 0905 60 PUSH1 0x00 0907 61 PUSH2 0x06cc 090A 61 PUSH2 0x0911 090D 61 PUSH2 0x0cc1 0910 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0905 stack[0] = 0x00 // @0907 stack[1] = 0x06cc // @090A stack[2] = 0x0911 // } // Block ends with call to 0x0cc1, returns to 0x0911 label_0911: // Incoming return from call to 0x0CC1 at 0x0910 // Inputs[2] // { // @0912 stack[-5] // @0916 stack[-4] // } 0911 5B JUMPDEST 0912 84 DUP5 0913 61 PUSH2 0x0958 0916 85 DUP6 0917 60 PUSH1 0x34 0919 60 PUSH1 0x00 091B 61 PUSH2 0x0922 091E 61 PUSH2 0x0cc1 0921 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0912 stack[0] = stack[-5] // @0913 stack[1] = 0x0958 // @0916 stack[2] = stack[-4] // @0917 stack[3] = 0x34 // @0919 stack[4] = 0x00 // @091B stack[5] = 0x0922 // } // Block ends with call to 0x0cc1, returns to 0x0922 label_0922: // Incoming return from call to 0x0CC1 at 0x0921 // Inputs[8] // { // @092B stack[-1] // @092E stack[-2] // @0935 stack[-3] // @0942 memory[0x00:0x00 + 0x40 + stack[-2]] // @0944 stack[-11] // @094B memory[0x00:0x40] // @094C storage[keccak256(memory[0x00:0x40])] // @094D stack[-4] // } 0922 5B JUMPDEST 0923 60 PUSH1 0x01 0925 60 PUSH1 0x01 0927 60 PUSH1 0xa0 0929 1B SHL 092A 03 SUB 092B 90 SWAP1 092C 81 DUP2 092D 16 AND 092E 82 DUP3 092F 52 MSTORE 0930 60 PUSH1 0x20 0932 80 DUP1 0933 83 DUP4 0934 01 ADD 0935 93 SWAP4 0936 90 SWAP1 0937 93 SWAP4 0938 52 MSTORE 0939 60 PUSH1 0x40 093B 91 SWAP2 093C 82 DUP3 093D 01 ADD 093E 60 PUSH1 0x00 0940 90 SWAP1 0941 81 DUP2 0942 20 SHA3 0943 91 SWAP2 0944 8C DUP13 0945 16 AND 0946 81 DUP2 0947 52 MSTORE 0948 92 SWAP3 0949 52 MSTORE 094A 90 SWAP1 094B 20 SHA3 094C 54 SLOAD 094D 90 SWAP1 094E 63 PUSH4 0xffffffff 0953 61 PUSH2 0x0ee7 0956 16 AND 0957 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @092F memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0938 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @0947 memory[0x00:0x20] = stack[-11] & (0x01 << 0xa0) - 0x01 // @0949 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @094D stack[-4] = storage[keccak256(memory[0x00:0x40])] // @094D stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0x0ee7 & 0xffffffff label_0958: // Incoming return from call to 0x0EB6 at 0x0EB5 // Incoming return from call to 0x0A77 at 0x0A76 // Incoming return from call to 0x0922 at 0x0921 0958 5B JUMPDEST 0959 61 PUSH2 0x0cc5 095C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cc5 label_095D: // Incoming jump from 0x03E8 // Inputs[1] { @0960 storage[0x9d] } 095D 5B JUMPDEST 095E 60 PUSH1 0x9d 0960 54 SLOAD 0961 60 PUSH1 0x01 0963 60 PUSH1 0x01 0965 60 PUSH1 0xa0 0967 1B SHL 0968 03 SUB 0969 16 AND 096A 61 PUSH2 0x0971 096D 61 PUSH2 0x0cc1 0970 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0969 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x9d] // @096A stack[1] = 0x0971 // } // Block ends with call to 0x0cc1, returns to 0x0971 label_0971: // Incoming return from call to 0x0CC1 at 0x0970 // Inputs[2] // { // @097A stack[-1] // @097B stack[-2] // } 0971 5B JUMPDEST 0972 60 PUSH1 0x01 0974 60 PUSH1 0x01 0976 60 PUSH1 0xa0 0978 1B SHL 0979 03 SUB 097A 16 AND 097B 14 EQ 097C 61 PUSH2 0x09b6 097F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x09b6, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0980: // Incoming jump from 0x097F, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[3] // { // @0982 memory[0x40:0x60] // @09B0 memory[0x40:0x60] // @09B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0980 60 PUSH1 0x40 0982 51 MLOAD 0983 62 PUSH3 0x461bcd 0987 60 PUSH1 0xe5 0989 1B SHL 098A 81 DUP2 098B 52 MSTORE 098C 60 PUSH1 0x04 098E 01 ADD 098F 80 DUP1 0990 80 DUP1 0991 60 PUSH1 0x20 0993 01 ADD 0994 82 DUP3 0995 81 DUP2 0996 03 SUB 0997 82 DUP3 0998 52 MSTORE 0999 60 PUSH1 0x2c 099B 81 DUP2 099C 52 MSTORE 099D 60 PUSH1 0x20 099F 01 ADD 09A0 80 DUP1 09A1 61 PUSH2 0x138a 09A4 60 PUSH1 0x2c 09A6 91 SWAP2 09A7 39 CODECOPY 09A8 60 PUSH1 0x40 09AA 01 ADD 09AB 91 SWAP2 09AC 50 POP 09AD 50 POP 09AE 60 PUSH1 0x40 09B0 51 MLOAD 09B1 80 DUP1 09B2 91 SWAP2 09B3 03 SUB 09B4 90 SWAP1 09B5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @098B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0998 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @099C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @09A7 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x138a:0x13b6] // @09B5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09B6: // Incoming jump from 0x097F, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @09BA stack[-2] // @09BB stack[-1] // } 09B6 5B JUMPDEST 09B7 61 PUSH2 0x09c0 09BA 82 DUP3 09BB 82 DUP3 09BC 61 PUSH2 0x0f41 09BF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09B7 stack[0] = 0x09c0 // @09BA stack[1] = stack[-2] // @09BB stack[2] = stack[-1] // } // Block ends with call to 0x0f41, returns to 0x09C0 label_09C0: // Incoming return from call to 0x0F41 at 0x09BF // Incoming jump from 0x0BAC, if !stack[-1] // Incoming jump from 0x0BAC, if !stack[-1] // Inputs[1] { @09C3 stack[-3] } 09C0 5B JUMPDEST 09C1 50 POP 09C2 50 POP 09C3 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_09C4: // Incoming jump from 0x040E // Inputs[4] // { // @09CD stack[-1] // @09DB memory[0x00:0x40] // @09DC storage[keccak256(memory[0x00:0x40])] // @09DD stack[-2] // } 09C4 5B JUMPDEST 09C5 60 PUSH1 0x01 09C7 60 PUSH1 0x01 09C9 60 PUSH1 0xa0 09CB 1B SHL 09CC 03 SUB 09CD 16 AND 09CE 60 PUSH1 0x00 09D0 90 SWAP1 09D1 81 DUP2 09D2 52 MSTORE 09D3 60 PUSH1 0x33 09D5 60 PUSH1 0x20 09D7 52 MSTORE 09D8 60 PUSH1 0x40 09DA 90 SWAP1 09DB 20 SHA3 09DC 54 SLOAD 09DD 90 SWAP1 09DE 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @09D2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @09D7 memory[0x20:0x40] = 0x33 // @09DD stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_09DF: // Incoming call from 0x0416, returns to 0x0118 // Inputs[2] // { // @09E3 storage[0x69] // @09E7 memory[0x40:0x60] // } 09DF 5B JUMPDEST 09E0 60 PUSH1 0x69 09E2 80 DUP1 09E3 54 SLOAD 09E4 60 PUSH1 0x40 09E6 80 DUP1 09E7 51 MLOAD 09E8 60 PUSH1 0x20 09EA 60 PUSH1 0x1f 09EC 60 PUSH1 0x02 09EE 60 PUSH1 0x00 09F0 19 NOT 09F1 61 PUSH2 0x0100 09F4 60 PUSH1 0x01 09F6 88 DUP9 09F7 16 AND 09F8 15 ISZERO 09F9 02 MUL 09FA 01 ADD 09FB 90 SWAP1 09FC 95 SWAP6 09FD 16 AND 09FE 94 SWAP5 09FF 90 SWAP1 0A00 94 SWAP5 0A01 04 DIV 0A02 93 SWAP4 0A03 84 DUP5 0A04 01 ADD 0A05 81 DUP2 0A06 90 SWAP1 0A07 04 DIV 0A08 81 DUP2 0A09 02 MUL 0A0A 82 DUP3 0A0B 01 ADD 0A0C 81 DUP2 0A0D 01 ADD 0A0E 90 SWAP1 0A0F 92 SWAP3 0A10 52 MSTORE 0A11 82 DUP3 0A12 81 DUP2 0A13 52 MSTORE 0A14 60 PUSH1 0x60 0A16 93 SWAP4 0A17 90 SWAP1 0A18 92 SWAP3 0A19 90 SWAP1 0A1A 91 SWAP2 0A1B 83 DUP4 0A1C 01 ADD 0A1D 82 DUP3 0A1E 82 DUP3 0A1F 80 DUP1 0A20 15 ISZERO 0A21 61 PUSH2 0x06ad 0A24 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0A10 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x69] & !(storage[0x69] & 0x01) * 0x0100 + ~0x00) / 0x02 + 0x1f) / 0x20) // @0A13 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x69] & !(storage[0x69] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0A16 stack[0] = 0x60 // @0A18 stack[1] = memory[0x40:0x60] // @0A19 stack[3] = (storage[0x69] & !(storage[0x69] & 0x01) * 0x0100 + ~0x00) / 0x02 // @0A1A stack[2] = 0x69 // @0A1C stack[4] = memory[0x40:0x60] + 0x20 // @0A1D stack[5] = 0x69 // @0A1E stack[6] = (storage[0x69] & !(storage[0x69] & 0x01) * 0x0100 + ~0x00) / 0x02 // } // Block ends with conditional jump to 0x06ad, if !((storage[0x69] & !(storage[0x69] & 0x01) * 0x0100 + ~0x00) / 0x02) label_0A25: // Incoming jump from 0x0A24, if not !((storage[0x69] & !(storage[0x69] & 0x01) * 0x0100 + ~0x00) / 0x02) // Inputs[1] { @0A25 stack[-1] } 0A25 80 DUP1 0A26 60 PUSH1 0x1f 0A28 10 LT 0A29 61 PUSH2 0x0682 0A2C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0682, if 0x1f < stack[-1] label_0A2D: // Incoming jump from 0x0A2C, if not 0x1f < stack[-1] // Inputs[4] // { // @0A31 stack[-2] // @0A32 storage[stack[-2]] // @0A35 stack[-3] // @0A37 stack[-1] // } 0A2D 61 PUSH2 0x0100 0A30 80 DUP1 0A31 83 DUP4 0A32 54 SLOAD 0A33 04 DIV 0A34 02 MUL 0A35 83 DUP4 0A36 52 MSTORE 0A37 91 SWAP2 0A38 60 PUSH1 0x20 0A3A 01 ADD 0A3B 91 SWAP2 0A3C 61 PUSH2 0x06ad 0A3F 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0A36 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0A3B stack[-1] = stack[-1] // @0A3B stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06ad label_0A40: // Incoming jump from 0x0442 0A40 5B JUMPDEST 0A41 60 PUSH1 0x00 0A43 61 PUSH2 0x06cc 0A46 61 PUSH2 0x0a4d 0A49 61 PUSH2 0x0cc1 0A4C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A41 stack[0] = 0x00 // @0A43 stack[1] = 0x06cc // @0A46 stack[2] = 0x0a4d // } // Block ends with call to 0x0cc1, returns to 0x0A4D label_0A4D: // Incoming return from call to 0x0CC1 at 0x0A4C // Inputs[3] // { // @0A4E stack[-5] // @0A52 stack[-4] // @0A55 memory[0x40:0x60] // } 0A4D 5B JUMPDEST 0A4E 84 DUP5 0A4F 61 PUSH2 0x0958 0A52 85 DUP6 0A53 60 PUSH1 0x40 0A55 51 MLOAD 0A56 80 DUP1 0A57 60 PUSH1 0x60 0A59 01 ADD 0A5A 60 PUSH1 0x40 0A5C 52 MSTORE 0A5D 80 DUP1 0A5E 60 PUSH1 0x25 0A60 81 DUP2 0A61 52 MSTORE 0A62 60 PUSH1 0x20 0A64 01 ADD 0A65 61 PUSH2 0x13da 0A68 60 PUSH1 0x25 0A6A 91 SWAP2 0A6B 39 CODECOPY 0A6C 60 PUSH1 0x34 0A6E 60 PUSH1 0x00 0A70 61 PUSH2 0x0a77 0A73 61 PUSH2 0x0cc1 0A76 56 *JUMP // Stack delta = +7 // Outputs[10] // { // @0A4E stack[0] = stack[-5] // @0A4F stack[1] = 0x0958 // @0A52 stack[2] = stack[-4] // @0A55 stack[3] = memory[0x40:0x60] // @0A5C memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0A61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x25 // @0A6B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x25] = code[0x13da:0x13ff] // @0A6C stack[4] = 0x34 // @0A6E stack[5] = 0x00 // @0A70 stack[6] = 0x0a77 // } // Block ends with call to 0x0cc1, returns to 0x0A77 label_0A77: // Incoming return from call to 0x0CC1 at 0x0A76 // Inputs[9] // { // @0A80 stack[-1] // @0A83 stack[-2] // @0A8A stack[-3] // @0A97 memory[0x00:0x00 + 0x40 + stack[-2]] // @0A99 stack[-12] // @0AA0 memory[0x00:0x40] // @0AA1 storage[keccak256(memory[0x00:0x40])] // @0AA2 stack[-5] // @0AA3 stack[-4] // } 0A77 5B JUMPDEST 0A78 60 PUSH1 0x01 0A7A 60 PUSH1 0x01 0A7C 60 PUSH1 0xa0 0A7E 1B SHL 0A7F 03 SUB 0A80 90 SWAP1 0A81 81 DUP2 0A82 16 AND 0A83 82 DUP3 0A84 52 MSTORE 0A85 60 PUSH1 0x20 0A87 80 DUP1 0A88 83 DUP4 0A89 01 ADD 0A8A 93 SWAP4 0A8B 90 SWAP1 0A8C 93 SWAP4 0A8D 52 MSTORE 0A8E 60 PUSH1 0x40 0A90 91 SWAP2 0A91 82 DUP3 0A92 01 ADD 0A93 60 PUSH1 0x00 0A95 90 SWAP1 0A96 81 DUP2 0A97 20 SHA3 0A98 91 SWAP2 0A99 8D DUP14 0A9A 16 AND 0A9B 81 DUP2 0A9C 52 MSTORE 0A9D 92 SWAP3 0A9E 52 MSTORE 0A9F 90 SWAP1 0AA0 20 SHA3 0AA1 54 SLOAD 0AA2 91 SWAP2 0AA3 90 SWAP1 0AA4 63 PUSH4 0xffffffff 0AA9 61 PUSH2 0x1033 0AAC 16 AND 0AAD 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @0A84 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0A8D memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @0A9C memory[0x00:0x20] = stack[-12] & (0x01 << 0xa0) - 0x01 // @0A9E memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @0AA2 stack[-5] = storage[keccak256(memory[0x00:0x40])] // @0AA3 stack[-3] = stack[-4] // @0AA3 stack[-4] = stack[-5] // } // Block ends with unconditional jump to 0x1033 & 0xffffffff label_0AAE: // Incoming jump from 0x046E 0AAE 5B JUMPDEST 0AAF 60 PUSH1 0x00 0AB1 61 PUSH2 0x06cc 0AB4 61 PUSH2 0x0abb 0AB7 61 PUSH2 0x0cc1 0ABA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AAF stack[0] = 0x00 // @0AB1 stack[1] = 0x06cc // @0AB4 stack[2] = 0x0abb // } // Block ends with call to 0x0cc1, returns to 0x0ABB label_0ABB: // Incoming return from call to 0x0CC1 at 0x0ABA // Inputs[2] // { // @0ABC stack[-5] // @0ABD stack[-4] // } 0ABB 5B JUMPDEST 0ABC 84 DUP5 0ABD 84 DUP5 0ABE 61 PUSH2 0x0d01 0AC1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0ABC stack[0] = stack[-5] // @0ABD stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x0d01 label_0AC2: // Incoming jump from 0x0494 // Inputs[1] { @0AC5 storage[0x00] } 0AC2 5B JUMPDEST 0AC3 60 PUSH1 0x00 0AC5 54 SLOAD 0AC6 61 PUSH2 0x0100 0AC9 90 SWAP1 0ACA 04 DIV 0ACB 60 PUSH1 0xff 0ACD 16 AND 0ACE 80 DUP1 0ACF 61 PUSH2 0x0adb 0AD2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0ACD stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x0adb, if 0xff & storage[0x00] / 0x0100 label_0AD3: // Incoming jump from 0x0AD2, if not 0xff & storage[0x00] / 0x0100 0AD3 50 POP 0AD4 61 PUSH2 0x0adb 0AD7 61 PUSH2 0x0cfb 0ADA 56 *JUMP // Stack delta = +0 // Outputs[1] { @0AD4 stack[-1] = 0x0adb } // Block ends with call to 0x0cfb, returns to 0x0ADB label_0ADB: // Incoming jump from 0x0AD2, if 0xff & storage[0x00] / 0x0100 // Incoming return from call to 0x0CFB at 0x0ADA // Inputs[1] { @0ADC stack[-1] } 0ADB 5B JUMPDEST 0ADC 80 DUP1 0ADD 61 PUSH2 0x0ae9 0AE0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ae9, if stack[-1] label_0AE1: // Incoming jump from 0x0AE0, if not stack[-1] // Inputs[1] { @0AE4 storage[0x00] } 0AE1 50 POP 0AE2 60 PUSH1 0x00 0AE4 54 SLOAD 0AE5 60 PUSH1 0xff 0AE7 16 AND 0AE8 15 ISZERO 0AE9 5B JUMPDEST 0AEA 61 PUSH2 0x0b24 0AED 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b24, if !(0xff & storage[0x00]) label_0AEE: // Incoming jump from 0x0AED, if not stack[-1] // Incoming jump from 0x0AED, if not !(0xff & storage[0x00]) // Inputs[3] // { // @0AF0 memory[0x40:0x60] // @0B1E memory[0x40:0x60] // @0B23 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0AEE 60 PUSH1 0x40 0AF0 51 MLOAD 0AF1 62 PUSH3 0x461bcd 0AF5 60 PUSH1 0xe5 0AF7 1B SHL 0AF8 81 DUP2 0AF9 52 MSTORE 0AFA 60 PUSH1 0x04 0AFC 01 ADD 0AFD 80 DUP1 0AFE 80 DUP1 0AFF 60 PUSH1 0x20 0B01 01 ADD 0B02 82 DUP3 0B03 81 DUP2 0B04 03 SUB 0B05 82 DUP3 0B06 52 MSTORE 0B07 60 PUSH1 0x2e 0B09 81 DUP2 0B0A 52 MSTORE 0B0B 60 PUSH1 0x20 0B0D 01 ADD 0B0E 80 DUP1 0B0F 61 PUSH2 0x130d 0B12 60 PUSH1 0x2e 0B14 91 SWAP2 0B15 39 CODECOPY 0B16 60 PUSH1 0x40 0B18 01 ADD 0B19 91 SWAP2 0B1A 50 POP 0B1B 50 POP 0B1C 60 PUSH1 0x40 0B1E 51 MLOAD 0B1F 80 DUP1 0B20 91 SWAP2 0B21 03 SUB 0B22 90 SWAP1 0B23 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0AF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B06 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0B0A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @0B15 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x130d:0x133b] // @0B23 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B24: // Incoming jump from 0x0AED, if stack[-1] // Incoming jump from 0x0AED, if !(0xff & storage[0x00]) // Inputs[1] { @0B27 storage[0x00] } 0B24 5B JUMPDEST 0B25 60 PUSH1 0x00 0B27 54 SLOAD 0B28 61 PUSH2 0x0100 0B2B 90 SWAP1 0B2C 04 DIV 0B2D 60 PUSH1 0xff 0B2F 16 AND 0B30 15 ISZERO 0B31 80 DUP1 0B32 15 ISZERO 0B33 61 PUSH2 0x0b4f 0B36 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B30 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x0b4f, if !!(0xff & storage[0x00] / 0x0100) label_0B37: // Incoming jump from 0x0B36, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[7] // { // @0B3A storage[0x00] // @0B53 storage[0x9d] // @0B66 stack[-2] // @0B74 memory[0x40:0x60] // @0B7B memory[0x40:0x60] // @0BA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20] // @0BA7 stack[-1] // } 0B37 60 PUSH1 0x00 0B39 80 DUP1 0B3A 54 SLOAD 0B3B 60 PUSH1 0xff 0B3D 19 NOT 0B3E 61 PUSH2 0xff00 0B41 19 NOT 0B42 90 SWAP1 0B43 91 SWAP2 0B44 16 AND 0B45 61 PUSH2 0x0100 0B48 17 OR 0B49 16 AND 0B4A 60 PUSH1 0x01 0B4C 17 OR 0B4D 90 SWAP1 0B4E 55 SSTORE 0B4F 5B JUMPDEST 0B50 60 PUSH1 0x9d 0B52 80 DUP1 0B53 54 SLOAD 0B54 60 PUSH1 0x01 0B56 60 PUSH1 0x01 0B58 60 PUSH1 0xa0 0B5A 1B SHL 0B5B 03 SUB 0B5C 19 NOT 0B5D 16 AND 0B5E 60 PUSH1 0x01 0B60 60 PUSH1 0x01 0B62 60 PUSH1 0xa0 0B64 1B SHL 0B65 03 SUB 0B66 84 DUP5 0B67 81 DUP2 0B68 16 AND 0B69 91 SWAP2 0B6A 90 SWAP1 0B6B 91 SWAP2 0B6C 17 OR 0B6D 91 SWAP2 0B6E 82 DUP3 0B6F 90 SWAP1 0B70 55 SSTORE 0B71 60 PUSH1 0x40 0B73 80 DUP1 0B74 51 MLOAD 0B75 92 SWAP3 0B76 90 SWAP1 0B77 91 SWAP2 0B78 16 AND 0B79 82 DUP3 0B7A 52 MSTORE 0B7B 51 MLOAD 0B7C 7F PUSH32 0x4101e71e974f68df5e9730cc223280b41654676bbb052cdcc735c3337e64d2d9 0B9D 91 SWAP2 0B9E 60 PUSH1 0x20 0BA0 90 SWAP1 0BA1 82 DUP3 0BA2 90 SWAP1 0BA3 03 SUB 0BA4 01 ADD 0BA5 90 SWAP1 0BA6 A1 LOG1 0BA7 80 DUP1 0BA8 15 ISZERO 0BA9 61 PUSH2 0x09c0 0BAC 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0B4E storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @0B70 storage[0x9d] = ((0x01 << 0xa0) - 0x01 & stack[-2]) | (~((0x01 << 0xa0) - 0x01) & storage[0x9d]) // @0B7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (((0x01 << 0xa0) - 0x01 & stack[-2]) | (~((0x01 << 0xa0) - 0x01) & storage[0x9d])) // @0BA6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20], [0x4101e71e974f68df5e9730cc223280b41654676bbb052cdcc735c3337e64d2d9]); // } // Block ends with conditional jump to 0x09c0, if !stack[-1] label_0BAD: // Incoming jump from 0x0BAC, if not !stack[-1] // Incoming jump from 0x0BAC, if not !stack[-1] // Inputs[2] // { // @0BB0 storage[0x00] // @0BBA stack[-3] // } 0BAD 60 PUSH1 0x00 0BAF 80 DUP1 0BB0 54 SLOAD 0BB1 61 PUSH2 0xff00 0BB4 19 NOT 0BB5 16 AND 0BB6 90 SWAP1 0BB7 55 SSTORE 0BB8 50 POP 0BB9 50 POP 0BBA 56 *JUMP // Stack delta = -3 // Outputs[1] { @0BB7 storage[0x00] = ~0xff00 & storage[0x00] } // Block ends with unconditional jump to stack[-3] label_0BBB: // Incoming call from 0x08B9, returns to 0x08BA // Incoming call from 0x049C, returns to 0x049D // Incoming call from 0x0BD3, returns to 0x0BD4 // Incoming call from 0x0CCC, returns to 0x0CCD // Inputs[2] // { // @0BBE storage[0x9d] // @0BC8 stack[-1] // } 0BBB 5B JUMPDEST 0BBC 60 PUSH1 0x9d 0BBE 54 SLOAD 0BBF 60 PUSH1 0x01 0BC1 60 PUSH1 0x01 0BC3 60 PUSH1 0xa0 0BC5 1B SHL 0BC6 03 SUB 0BC7 16 AND 0BC8 90 SWAP1 0BC9 56 *JUMP // Stack delta = +0 // Outputs[1] { @0BC8 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x9d] } // Block ends with unconditional jump to stack[-1] label_0BCA: // Incoming jump from 0x04E6 0BCA 5B JUMPDEST 0BCB 60 PUSH1 0x00 0BCD 61 PUSH2 0x0bd4 0BD0 61 PUSH2 0x0bbb 0BD3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BCB stack[0] = 0x00 // @0BCD stack[1] = 0x0bd4 // } // Block ends with call to 0x0bbb, returns to 0x0BD4 label_0BD4: // Incoming return from call to 0x0BBB at 0x0BD3 // Inputs[2] // { // @0BDD stack[-1] // @0BDE stack[-3] // } 0BD4 5B JUMPDEST 0BD5 60 PUSH1 0x01 0BD7 60 PUSH1 0x01 0BD9 60 PUSH1 0xa0 0BDB 1B SHL 0BDC 03 SUB 0BDD 16 AND 0BDE 82 DUP3 0BDF 60 PUSH1 0x01 0BE1 60 PUSH1 0x01 0BE3 60 PUSH1 0xa0 0BE5 1B SHL 0BE6 03 SUB 0BE7 16 AND 0BE8 14 EQ 0BE9 15 ISZERO 0BEA 61 PUSH2 0x0bf6 0BED 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bf6, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0BEE: // Incoming jump from 0x0BED, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) 0BEE 50 POP 0BEF 60 PUSH1 0x00 0BF1 19 NOT 0BF2 61 PUSH2 0x06d0 0BF5 56 *JUMP // Stack delta = +0 // Outputs[1] { @0BF1 stack[-1] = ~0x00 } // Block ends with unconditional jump to 0x06d0 label_0BF6: // Incoming jump from 0x0BED, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @0BFA stack[-3] // @0BFB stack[-2] // } 0BF6 5B JUMPDEST 0BF7 61 PUSH2 0x0c00 0BFA 83 DUP4 0BFB 83 DUP4 0BFC 61 PUSH2 0x10ca 0BFF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BF7 stack[0] = 0x0c00 // @0BFA stack[1] = stack[-3] // @0BFB stack[2] = stack[-2] // } // Block ends with call to 0x10ca, returns to 0x0C00 label_0C00: // Incoming return from call to 0x10CA at 0x0BFF // Inputs[2] // { // @0C01 stack[-2] // @0C01 stack[-1] // } 0C00 5B JUMPDEST 0C01 90 SWAP1 0C02 50 POP 0C03 61 PUSH2 0x06d0 0C06 56 *JUMP // Stack delta = -1 // Outputs[1] { @0C01 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x06d0 label_0C07: // Incoming jump from 0x0620 // Inputs[1] { @0C0A storage[0x00] } 0C07 5B JUMPDEST 0C08 60 PUSH1 0x00 0C0A 54 SLOAD 0C0B 61 PUSH2 0x0100 0C0E 90 SWAP1 0C0F 04 DIV 0C10 60 PUSH1 0xff 0C12 16 AND 0C13 80 DUP1 0C14 61 PUSH2 0x0c20 0C17 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C12 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x0c20, if 0xff & storage[0x00] / 0x0100 label_0C18: // Incoming jump from 0x0C17, if not 0xff & storage[0x00] / 0x0100 0C18 50 POP 0C19 61 PUSH2 0x0c20 0C1C 61 PUSH2 0x0cfb 0C1F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0C19 stack[-1] = 0x0c20 } // Block ends with call to 0x0cfb, returns to 0x0C20 label_0C20: // Incoming return from call to 0x0CFB at 0x0C1F // Incoming jump from 0x0C17, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @0C21 stack[-1] } 0C20 5B JUMPDEST 0C21 80 DUP1 0C22 61 PUSH2 0x0c2e 0C25 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c2e, if stack[-1] label_0C26: // Incoming jump from 0x0C25, if not stack[-1] // Inputs[1] { @0C29 storage[0x00] } 0C26 50 POP 0C27 60 PUSH1 0x00 0C29 54 SLOAD 0C2A 60 PUSH1 0xff 0C2C 16 AND 0C2D 15 ISZERO 0C2E 5B JUMPDEST 0C2F 61 PUSH2 0x0c69 0C32 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c69, if !(0xff & storage[0x00]) label_0C33: // Incoming jump from 0x0C32, if not stack[-1] // Incoming jump from 0x0C32, if not !(0xff & storage[0x00]) // Inputs[3] // { // @0C35 memory[0x40:0x60] // @0C63 memory[0x40:0x60] // @0C68 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C33 60 PUSH1 0x40 0C35 51 MLOAD 0C36 62 PUSH3 0x461bcd 0C3A 60 PUSH1 0xe5 0C3C 1B SHL 0C3D 81 DUP2 0C3E 52 MSTORE 0C3F 60 PUSH1 0x04 0C41 01 ADD 0C42 80 DUP1 0C43 80 DUP1 0C44 60 PUSH1 0x20 0C46 01 ADD 0C47 82 DUP3 0C48 81 DUP2 0C49 03 SUB 0C4A 82 DUP3 0C4B 52 MSTORE 0C4C 60 PUSH1 0x2e 0C4E 81 DUP2 0C4F 52 MSTORE 0C50 60 PUSH1 0x20 0C52 01 ADD 0C53 80 DUP1 0C54 61 PUSH2 0x130d 0C57 60 PUSH1 0x2e 0C59 91 SWAP2 0C5A 39 CODECOPY 0C5B 60 PUSH1 0x40 0C5D 01 ADD 0C5E 91 SWAP2 0C5F 50 POP 0C60 50 POP 0C61 60 PUSH1 0x40 0C63 51 MLOAD 0C64 80 DUP1 0C65 91 SWAP2 0C66 03 SUB 0C67 90 SWAP1 0C68 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C4B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0C4F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @0C5A memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x130d:0x133b] // @0C68 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C69: // Incoming jump from 0x0C32, if stack[-1] // Incoming jump from 0x0C32, if !(0xff & storage[0x00]) // Inputs[1] { @0C6C storage[0x00] } 0C69 5B JUMPDEST 0C6A 60 PUSH1 0x00 0C6C 54 SLOAD 0C6D 61 PUSH2 0x0100 0C70 90 SWAP1 0C71 04 DIV 0C72 60 PUSH1 0xff 0C74 16 AND 0C75 15 ISZERO 0C76 80 DUP1 0C77 15 ISZERO 0C78 61 PUSH2 0x0c94 0C7B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C75 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x0c94, if !!(0xff & storage[0x00] / 0x0100) label_0C7C: // Incoming jump from 0x0C7B, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[4] // { // @0C7F storage[0x00] // @0C98 stack[-5] // @0C99 stack[-4] // @0C9A stack[-3] // } 0C7C 60 PUSH1 0x00 0C7E 80 DUP1 0C7F 54 SLOAD 0C80 60 PUSH1 0xff 0C82 19 NOT 0C83 61 PUSH2 0xff00 0C86 19 NOT 0C87 90 SWAP1 0C88 91 SWAP2 0C89 16 AND 0C8A 61 PUSH2 0x0100 0C8D 17 OR 0C8E 16 AND 0C8F 60 PUSH1 0x01 0C91 17 OR 0C92 90 SWAP1 0C93 55 SSTORE 0C94 5B JUMPDEST 0C95 61 PUSH2 0x0c9f 0C98 85 DUP6 0C99 85 DUP6 0C9A 85 DUP6 0C9B 61 PUSH2 0x06d6 0C9E 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0C93 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @0C95 stack[0] = 0x0c9f // @0C98 stack[1] = stack[-5] // @0C99 stack[2] = stack[-4] // @0C9A stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x06d6 0C9F 5B JUMPDEST 0CA0 61 PUSH2 0x0ca8 0CA3 82 DUP3 0CA4 61 PUSH2 0x0ac2 0CA7 56 *JUMP 0CA8 5B JUMPDEST 0CA9 80 DUP1 0CAA 15 ISZERO 0CAB 61 PUSH2 0x0cba 0CAE 57 *JUMPI 0CAF 60 PUSH1 0x00 0CB1 80 DUP1 0CB2 54 SLOAD 0CB3 61 PUSH2 0xff00 0CB6 19 NOT 0CB7 16 AND 0CB8 90 SWAP1 0CB9 55 SSTORE 0CBA 5B JUMPDEST 0CBB 50 POP 0CBC 50 POP 0CBD 50 POP 0CBE 50 POP 0CBF 50 POP 0CC0 56 *JUMP label_0CC1: // Incoming call from 0x0970, returns to 0x0971 // Incoming call from 0x0EB5, returns to 0x0EB6 // Incoming call from 0x0ABA, returns to 0x0ABB // Incoming call from 0x06C4, returns to 0x06C5 // Incoming call from 0x0E77, returns to 0x0E78 // Incoming call from 0x0A4C, returns to 0x0A4D // Incoming call from 0x07CB, returns to 0x07CC // Incoming call from 0x0A76, returns to 0x0A77 // Incoming call from 0x0910, returns to 0x0911 // Incoming call from 0x0921, returns to 0x0922 // Inputs[2] // { // @0CC2 msg.sender // @0CC3 stack[-1] // } 0CC1 5B JUMPDEST 0CC2 33 CALLER 0CC3 90 SWAP1 0CC4 56 *JUMP // Stack delta = +0 // Outputs[1] { @0CC3 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_0CC5: // Incoming jump from 0x06CB // Incoming jump from 0x095C 0CC5 5B JUMPDEST 0CC6 61 PUSH2 0x0ccd 0CC9 61 PUSH2 0x0bbb 0CCC 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CC6 stack[0] = 0x0ccd } // Block ends with call to 0x0bbb, returns to 0x0CCD label_0CCD: // Incoming return from call to 0x0BBB at 0x0CCC // Inputs[2] // { // @0CD6 stack[-1] // @0CD7 stack[-3] // } 0CCD 5B JUMPDEST 0CCE 60 PUSH1 0x01 0CD0 60 PUSH1 0x01 0CD2 60 PUSH1 0xa0 0CD4 1B SHL 0CD5 03 SUB 0CD6 16 AND 0CD7 82 DUP3 0CD8 60 PUSH1 0x01 0CDA 60 PUSH1 0x01 0CDC 60 PUSH1 0xa0 0CDE 1B SHL 0CDF 03 SUB 0CE0 16 AND 0CE1 14 EQ 0CE2 15 ISZERO 0CE3 61 PUSH2 0x0ceb 0CE6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0ceb, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0CE7: // Incoming jump from 0x0CE6, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) 0CE7 61 PUSH2 0x0cf6 0CEA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cf6 label_0CEB: // Incoming jump from 0x0CE6, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @0CEF stack[-3] // @0CF0 stack[-2] // @0CF1 stack[-1] // } 0CEB 5B JUMPDEST 0CEC 61 PUSH2 0x0cf6 0CEF 83 DUP4 0CF0 83 DUP4 0CF1 83 DUP4 0CF2 61 PUSH2 0x10f5 0CF5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CEC stack[0] = 0x0cf6 // @0CEF stack[1] = stack[-3] // @0CF0 stack[2] = stack[-2] // @0CF1 stack[3] = stack[-1] // } // Block ends with call to 0x10f5, returns to 0x0CF6 label_0CF6: // Incoming return from call to 0x10F5 at 0x0CF5 // Incoming jump from 0x0CEA // Inputs[1] { @0CFA stack[-4] } 0CF6 5B JUMPDEST 0CF7 50 POP 0CF8 50 POP 0CF9 50 POP 0CFA 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0CFB: // Incoming call from 0x06EE, returns to 0x06EF // Incoming call from 0x0ADA, returns to 0x0ADB // Incoming call from 0x0C1F, returns to 0x0C20 // Inputs[3] // { // @0CFC address(this) // @0CFD address(address(this)).code.length // @0CFF stack[-1] // } 0CFB 5B JUMPDEST 0CFC 30 ADDRESS 0CFD 3B EXTCODESIZE 0CFE 15 ISZERO 0CFF 90 SWAP1 0D00 56 *JUMP // Stack delta = +0 // Outputs[1] { @0CFF stack[-1] = !address(address(this)).code.length } // Block ends with unconditional jump to stack[-1] label_0D01: // Incoming call from 0x0E6B, returns to 0x0E6C // Incoming call from 0x08DD, returns to 0x08DE // Incoming jump from 0x0AC1 // Inputs[1] { @0D0A stack[-3] } 0D01 5B JUMPDEST 0D02 60 PUSH1 0x01 0D04 60 PUSH1 0x01 0D06 60 PUSH1 0xa0 0D08 1B SHL 0D09 03 SUB 0D0A 83 DUP4 0D0B 16 AND 0D0C 61 PUSH2 0x0d46 0D0F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d46, if stack[-3] & (0x01 << 0xa0) - 0x01 label_0D10: // Incoming jump from 0x0D0F, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0D12 memory[0x40:0x60] // @0D40 memory[0x40:0x60] // @0D45 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D10 60 PUSH1 0x40 0D12 51 MLOAD 0D13 62 PUSH3 0x461bcd 0D17 60 PUSH1 0xe5 0D19 1B SHL 0D1A 81 DUP2 0D1B 52 MSTORE 0D1C 60 PUSH1 0x04 0D1E 01 ADD 0D1F 80 DUP1 0D20 80 DUP1 0D21 60 PUSH1 0x20 0D23 01 ADD 0D24 82 DUP3 0D25 81 DUP2 0D26 03 SUB 0D27 82 DUP3 0D28 52 MSTORE 0D29 60 PUSH1 0x25 0D2B 81 DUP2 0D2C 52 MSTORE 0D2D 60 PUSH1 0x20 0D2F 01 ADD 0D30 80 DUP1 0D31 61 PUSH2 0x1365 0D34 60 PUSH1 0x25 0D36 91 SWAP2 0D37 39 CODECOPY 0D38 60 PUSH1 0x40 0D3A 01 ADD 0D3B 91 SWAP2 0D3C 50 POP 0D3D 50 POP 0D3E 60 PUSH1 0x40 0D40 51 MLOAD 0D41 80 DUP1 0D42 91 SWAP2 0D43 03 SUB 0D44 90 SWAP1 0D45 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0D1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D28 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0D2C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @0D37 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x1365:0x138a] // @0D45 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D46: // Incoming jump from 0x0D0F, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0D4F stack[-2] } 0D46 5B JUMPDEST 0D47 60 PUSH1 0x01 0D49 60 PUSH1 0x01 0D4B 60 PUSH1 0xa0 0D4D 1B SHL 0D4E 03 SUB 0D4F 82 DUP3 0D50 16 AND 0D51 61 PUSH2 0x0d8b 0D54 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d8b, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0D55: // Incoming jump from 0x0D54, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0D57 memory[0x40:0x60] // @0D85 memory[0x40:0x60] // @0D8A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D55 60 PUSH1 0x40 0D57 51 MLOAD 0D58 62 PUSH3 0x461bcd 0D5C 60 PUSH1 0xe5 0D5E 1B SHL 0D5F 81 DUP2 0D60 52 MSTORE 0D61 60 PUSH1 0x04 0D63 01 ADD 0D64 80 DUP1 0D65 80 DUP1 0D66 60 PUSH1 0x20 0D68 01 ADD 0D69 82 DUP3 0D6A 81 DUP2 0D6B 03 SUB 0D6C 82 DUP3 0D6D 52 MSTORE 0D6E 60 PUSH1 0x23 0D70 81 DUP2 0D71 52 MSTORE 0D72 60 PUSH1 0x20 0D74 01 ADD 0D75 80 DUP1 0D76 61 PUSH2 0x127a 0D79 60 PUSH1 0x23 0D7B 91 SWAP2 0D7C 39 CODECOPY 0D7D 60 PUSH1 0x40 0D7F 01 ADD 0D80 91 SWAP2 0D81 50 POP 0D82 50 POP 0D83 60 PUSH1 0x40 0D85 51 MLOAD 0D86 80 DUP1 0D87 91 SWAP2 0D88 03 SUB 0D89 90 SWAP1 0D8A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0D60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D6D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0D71 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @0D7C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x127a:0x129d] // @0D8A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D8B: // Incoming jump from 0x0D54, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @0D8F stack[-1] // @0D92 memory[0x40:0x60] // @0DB1 stack[-3] // @0DC0 memory[0x00:0x40] // @0DC1 storage[keccak256(memory[0x00:0x40])] // } 0D8B 5B JUMPDEST 0D8C 61 PUSH2 0x0dce 0D8F 81 DUP2 0D90 60 PUSH1 0x40 0D92 51 MLOAD 0D93 80 DUP1 0D94 60 PUSH1 0x60 0D96 01 ADD 0D97 60 PUSH1 0x40 0D99 52 MSTORE 0D9A 80 DUP1 0D9B 60 PUSH1 0x26 0D9D 81 DUP2 0D9E 52 MSTORE 0D9F 60 PUSH1 0x20 0DA1 01 ADD 0DA2 61 PUSH2 0x12bf 0DA5 60 PUSH1 0x26 0DA7 91 SWAP2 0DA8 39 CODECOPY 0DA9 60 PUSH1 0x01 0DAB 60 PUSH1 0x01 0DAD 60 PUSH1 0xa0 0DAF 1B SHL 0DB0 03 SUB 0DB1 86 DUP7 0DB2 16 AND 0DB3 60 PUSH1 0x00 0DB5 90 SWAP1 0DB6 81 DUP2 0DB7 52 MSTORE 0DB8 60 PUSH1 0x33 0DBA 60 PUSH1 0x20 0DBC 52 MSTORE 0DBD 60 PUSH1 0x40 0DBF 90 SWAP1 0DC0 20 SHA3 0DC1 54 SLOAD 0DC2 91 SWAP2 0DC3 90 SWAP1 0DC4 63 PUSH4 0xffffffff 0DC9 61 PUSH2 0x1033 0DCC 16 AND 0DCD 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @0D8C stack[0] = 0x0dce // @0D99 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0D9E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 // @0DA8 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x12bf:0x12e5] // @0DB7 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0DBC memory[0x20:0x40] = 0x33 // @0DC2 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0DC3 stack[2] = stack[-1] // @0DC3 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1033 & 0xffffffff, returns to 0x0DCE label_0DCE: // Incoming return from call to 0x1033 at 0x0DCD // Inputs[7] // { // @0DD8 stack[-4] // @0DE8 memory[0x00:0x40] // @0DE9 stack[-1] // @0DEE stack[-3] // @0DF2 memory[0x00:0x40] // @0DF3 storage[keccak256(memory[0x00:0x40])] // @0DF8 stack[-2] // } 0DCE 5B JUMPDEST 0DCF 60 PUSH1 0x01 0DD1 60 PUSH1 0x01 0DD3 60 PUSH1 0xa0 0DD5 1B SHL 0DD6 03 SUB 0DD7 80 DUP1 0DD8 85 DUP6 0DD9 16 AND 0DDA 60 PUSH1 0x00 0DDC 90 SWAP1 0DDD 81 DUP2 0DDE 52 MSTORE 0DDF 60 PUSH1 0x33 0DE1 60 PUSH1 0x20 0DE3 52 MSTORE 0DE4 60 PUSH1 0x40 0DE6 80 DUP1 0DE7 82 DUP3 0DE8 20 SHA3 0DE9 93 SWAP4 0DEA 90 SWAP1 0DEB 93 SWAP4 0DEC 55 SSTORE 0DED 90 SWAP1 0DEE 84 DUP5 0DEF 16 AND 0DF0 81 DUP2 0DF1 52 MSTORE 0DF2 20 SHA3 0DF3 54 SLOAD 0DF4 61 PUSH2 0x0e03 0DF7 90 SWAP1 0DF8 82 DUP3 0DF9 63 PUSH4 0xffffffff 0DFE 61 PUSH2 0x0ee7 0E01 16 AND 0E02 56 *JUMP // Stack delta = +2 // Outputs[7] // { // @0DDE memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @0DE3 memory[0x20:0x40] = 0x33 // @0DEC storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0DF1 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0DF7 stack[0] = storage[keccak256(memory[0x00:0x40])] // @0DF7 stack[-1] = 0x0e03 // @0DF8 stack[1] = stack[-2] // } // Block ends with call to 0x0ee7 & 0xffffffff, returns to 0x0E03 label_0E03: // Incoming return from call to 0x0EE7 at 0x0E02 // Inputs[9] // { // @0E0D stack[-3] // @0E20 memory[0x00:0x40] // @0E21 stack[-1] // @0E26 memory[0x40:0x60] // @0E27 stack[-2] // @0E2B memory[0x40:0x60] // @0E2F stack[-4] // @0E5A memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20] // @0E5E stack[-5] // } 0E03 5B JUMPDEST 0E04 60 PUSH1 0x01 0E06 60 PUSH1 0x01 0E08 60 PUSH1 0xa0 0E0A 1B SHL 0E0B 03 SUB 0E0C 80 DUP1 0E0D 84 DUP5 0E0E 16 AND 0E0F 60 PUSH1 0x00 0E11 81 DUP2 0E12 81 DUP2 0E13 52 MSTORE 0E14 60 PUSH1 0x33 0E16 60 PUSH1 0x20 0E18 90 SWAP1 0E19 81 DUP2 0E1A 52 MSTORE 0E1B 60 PUSH1 0x40 0E1D 91 SWAP2 0E1E 82 DUP3 0E1F 90 SWAP1 0E20 20 SHA3 0E21 94 SWAP5 0E22 90 SWAP1 0E23 94 SWAP5 0E24 55 SSTORE 0E25 80 DUP1 0E26 51 MLOAD 0E27 85 DUP6 0E28 81 DUP2 0E29 52 MSTORE 0E2A 90 SWAP1 0E2B 51 MLOAD 0E2C 91 SWAP2 0E2D 93 SWAP4 0E2E 92 SWAP3 0E2F 87 DUP8 0E30 16 AND 0E31 92 SWAP3 0E32 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0E53 92 SWAP3 0E54 91 SWAP2 0E55 82 DUP3 0E56 90 SWAP1 0E57 03 SUB 0E58 01 ADD 0E59 90 SWAP1 0E5A A3 LOG3 0E5B 50 POP 0E5C 50 POP 0E5D 50 POP 0E5E 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @0E13 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0E1A memory[0x20:0x40] = 0x33 // @0E24 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0E29 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0E5A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-5] label_0E5F: // Incoming jump from 0x08F0 // Inputs[3] // { // @0E65 stack[-3] // @0E66 stack[-2] // @0E67 stack[-1] // } 0E5F 5B JUMPDEST 0E60 60 PUSH1 0x00 0E62 61 PUSH2 0x0e6c 0E65 84 DUP5 0E66 84 DUP5 0E67 84 DUP5 0E68 61 PUSH2 0x0d01 0E6B 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0E60 stack[0] = 0x00 // @0E62 stack[1] = 0x0e6c // @0E65 stack[2] = stack[-3] // @0E66 stack[3] = stack[-2] // @0E67 stack[4] = stack[-1] // } // Block ends with call to 0x0d01, returns to 0x0E6C label_0E6C: // Incoming return from call to 0x0D01 at 0x0E6B // Inputs[1] { @0E70 stack[-4] } 0E6C 5B JUMPDEST 0E6D 61 PUSH2 0x0edd 0E70 84 DUP5 0E71 61 PUSH2 0x0e78 0E74 61 PUSH2 0x0cc1 0E77 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E6D stack[0] = 0x0edd // @0E70 stack[1] = stack[-4] // @0E71 stack[2] = 0x0e78 // } // Block ends with call to 0x0cc1, returns to 0x0E78 label_0E78: // Incoming return from call to 0x0CC1 at 0x0E77 // Inputs[4] // { // @0E7C stack[-5] // @0E7F memory[0x40:0x60] // @0E9E stack[-7] // @0EAD memory[0x00:0x40] // } 0E78 5B JUMPDEST 0E79 61 PUSH2 0x0958 0E7C 85 DUP6 0E7D 60 PUSH1 0x40 0E7F 51 MLOAD 0E80 80 DUP1 0E81 60 PUSH1 0x60 0E83 01 ADD 0E84 60 PUSH1 0x40 0E86 52 MSTORE 0E87 80 DUP1 0E88 60 PUSH1 0x28 0E8A 81 DUP2 0E8B 52 MSTORE 0E8C 60 PUSH1 0x20 0E8E 01 ADD 0E8F 61 PUSH2 0x12e5 0E92 60 PUSH1 0x28 0E94 91 SWAP2 0E95 39 CODECOPY 0E96 60 PUSH1 0x01 0E98 60 PUSH1 0x01 0E9A 60 PUSH1 0xa0 0E9C 1B SHL 0E9D 03 SUB 0E9E 8A DUP11 0E9F 16 AND 0EA0 60 PUSH1 0x00 0EA2 90 SWAP1 0EA3 81 DUP2 0EA4 52 MSTORE 0EA5 60 PUSH1 0x34 0EA7 60 PUSH1 0x20 0EA9 52 MSTORE 0EAA 60 PUSH1 0x40 0EAC 81 DUP2 0EAD 20 SHA3 0EAE 90 SWAP1 0EAF 61 PUSH2 0x0eb6 0EB2 61 PUSH2 0x0cc1 0EB5 56 *JUMP // Stack delta = +6 // Outputs[11] // { // @0E79 stack[0] = 0x0958 // @0E7C stack[1] = stack[-5] // @0E7F stack[2] = memory[0x40:0x60] // @0E86 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @0E8B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x28 // @0E95 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x28] = code[0x12e5:0x130d] // @0EA4 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @0EA9 memory[0x20:0x40] = 0x34 // @0EAE stack[3] = keccak256(memory[0x00:0x40]) // @0EAE stack[4] = 0x00 // @0EAF stack[5] = 0x0eb6 // } // Block ends with call to 0x0cc1, returns to 0x0EB6 label_0EB6: // Incoming return from call to 0x0CC1 at 0x0EB5 // Inputs[7] // { // @0EBF stack[-1] // @0EC0 stack[-2] // @0EC6 stack[-3] // @0ECF memory[0x00:0x00 + 0x40 + stack[-2]] // @0ED0 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] // @0ED1 stack[-5] // @0ED2 stack[-4] // } 0EB6 5B JUMPDEST 0EB7 60 PUSH1 0x01 0EB9 60 PUSH1 0x01 0EBB 60 PUSH1 0xa0 0EBD 1B SHL 0EBE 03 SUB 0EBF 16 AND 0EC0 81 DUP2 0EC1 52 MSTORE 0EC2 60 PUSH1 0x20 0EC4 81 DUP2 0EC5 01 ADD 0EC6 91 SWAP2 0EC7 90 SWAP1 0EC8 91 SWAP2 0EC9 52 MSTORE 0ECA 60 PUSH1 0x40 0ECC 01 ADD 0ECD 60 PUSH1 0x00 0ECF 20 SHA3 0ED0 54 SLOAD 0ED1 91 SWAP2 0ED2 90 SWAP1 0ED3 63 PUSH4 0xffffffff 0ED8 61 PUSH2 0x1033 0EDB 16 AND 0EDC 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0EC1 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0EC9 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @0ED1 stack[-5] = storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] // @0ED2 stack[-3] = stack[-4] // @0ED2 stack[-4] = stack[-5] // } // Block ends with unconditional jump to 0x1033 & 0xffffffff 0EDD 5B JUMPDEST 0EDE 50 POP 0EDF 60 PUSH1 0x01 0EE1 93 SWAP4 0EE2 92 SWAP3 0EE3 50 POP 0EE4 50 POP 0EE5 50 POP 0EE6 56 *JUMP label_0EE7: // Incoming call from 0x0FAE, returns to 0x0FAF // Incoming call from 0x0FDA, returns to 0x0FDB // Incoming jump from 0x0957 // Incoming call from 0x0E02, returns to 0x0E03 // Inputs[2] // { // @0EEA stack[-2] // @0EEB stack[-1] // } 0EE7 5B JUMPDEST 0EE8 60 PUSH1 0x00 0EEA 82 DUP3 0EEB 82 DUP3 0EEC 01 ADD 0EED 83 DUP4 0EEE 81 DUP2 0EEF 10 LT 0EF0 15 ISZERO 0EF1 61 PUSH2 0x08f4 0EF4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0EE8 stack[0] = 0x00 // @0EEC stack[1] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x08f4, if !(stack[-1] + stack[-2] < stack[-2]) label_0EF5: // Incoming jump from 0x0EF4, if not !(stack[-1] + stack[-2] < stack[-2]) // Inputs[3] // { // @0EF8 memory[0x40:0x60] // @0F37 memory[0x40:0x60] // @0F40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0EF5 60 PUSH1 0x40 0EF7 80 DUP1 0EF8 51 MLOAD 0EF9 62 PUSH3 0x461bcd 0EFD 60 PUSH1 0xe5 0EFF 1B SHL 0F00 81 DUP2 0F01 52 MSTORE 0F02 60 PUSH1 0x20 0F04 60 PUSH1 0x04 0F06 82 DUP3 0F07 01 ADD 0F08 52 MSTORE 0F09 60 PUSH1 0x1b 0F0B 60 PUSH1 0x24 0F0D 82 DUP3 0F0E 01 ADD 0F0F 52 MSTORE 0F10 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 0F31 60 PUSH1 0x44 0F33 82 DUP3 0F34 01 ADD 0F35 52 MSTORE 0F36 90 SWAP1 0F37 51 MLOAD 0F38 90 SWAP1 0F39 81 DUP2 0F3A 90 SWAP1 0F3B 03 SUB 0F3C 60 PUSH1 0x64 0F3E 01 ADD 0F3F 90 SWAP1 0F40 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F01 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F08 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F0F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @0F35 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @0F40 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0F41: // Incoming call from 0x09BF, returns to 0x09C0 // Inputs[1] { @0F4A stack[-2] } 0F41 5B JUMPDEST 0F42 60 PUSH1 0x01 0F44 60 PUSH1 0x01 0F46 60 PUSH1 0xa0 0F48 1B SHL 0F49 03 SUB 0F4A 82 DUP3 0F4B 16 AND 0F4C 61 PUSH2 0x0f9c 0F4F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f9c, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0F50: // Incoming jump from 0x0F4F, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0F53 memory[0x40:0x60] // @0F92 memory[0x40:0x60] // @0F9B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0F50 60 PUSH1 0x40 0F52 80 DUP1 0F53 51 MLOAD 0F54 62 PUSH3 0x461bcd 0F58 60 PUSH1 0xe5 0F5A 1B SHL 0F5B 81 DUP2 0F5C 52 MSTORE 0F5D 60 PUSH1 0x20 0F5F 60 PUSH1 0x04 0F61 82 DUP3 0F62 01 ADD 0F63 52 MSTORE 0F64 60 PUSH1 0x1f 0F66 60 PUSH1 0x24 0F68 82 DUP3 0F69 01 ADD 0F6A 52 MSTORE 0F6B 7F PUSH32 0x45524332303a206d696e7420746f20746865207a65726f206164647265737300 0F8C 60 PUSH1 0x44 0F8E 82 DUP3 0F8F 01 ADD 0F90 52 MSTORE 0F91 90 SWAP1 0F92 51 MLOAD 0F93 90 SWAP1 0F94 81 DUP2 0F95 90 SWAP1 0F96 03 SUB 0F97 60 PUSH1 0x64 0F99 01 ADD 0F9A 90 SWAP1 0F9B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F63 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F6A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0F90 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a206d696e7420746f20746865207a65726f206164647265737300 // @0F9B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0F9C: // Incoming jump from 0x0F4F, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0F9F storage[0x35] // @0FA4 stack[-1] // } 0F9C 5B JUMPDEST 0F9D 60 PUSH1 0x35 0F9F 54 SLOAD 0FA0 61 PUSH2 0x0faf 0FA3 90 SWAP1 0FA4 82 DUP3 0FA5 63 PUSH4 0xffffffff 0FAA 61 PUSH2 0x0ee7 0FAD 16 AND 0FAE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FA3 stack[0] = 0x0faf // @0FA3 stack[1] = storage[0x35] // @0FA4 stack[2] = stack[-1] // } // Block ends with call to 0x0ee7 & 0xffffffff, returns to 0x0FAF label_0FAF: // Incoming return from call to 0x0EE7 at 0x0FAE // Inputs[5] // { // @0FB2 stack[-1] // @0FBB stack[-3] // @0FCA memory[0x00:0x40] // @0FCB storage[keccak256(memory[0x00:0x40])] // @0FD0 stack[-2] // } 0FAF 5B JUMPDEST 0FB0 60 PUSH1 0x35 0FB2 55 SSTORE 0FB3 60 PUSH1 0x01 0FB5 60 PUSH1 0x01 0FB7 60 PUSH1 0xa0 0FB9 1B SHL 0FBA 03 SUB 0FBB 82 DUP3 0FBC 16 AND 0FBD 60 PUSH1 0x00 0FBF 90 SWAP1 0FC0 81 DUP2 0FC1 52 MSTORE 0FC2 60 PUSH1 0x33 0FC4 60 PUSH1 0x20 0FC6 52 MSTORE 0FC7 60 PUSH1 0x40 0FC9 90 SWAP1 0FCA 20 SHA3 0FCB 54 SLOAD 0FCC 61 PUSH2 0x0fdb 0FCF 90 SWAP1 0FD0 82 DUP3 0FD1 63 PUSH4 0xffffffff 0FD6 61 PUSH2 0x0ee7 0FD9 16 AND 0FDA 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0FB2 storage[0x35] = stack[-1] // @0FC1 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0FC6 memory[0x20:0x40] = 0x33 // @0FCF stack[0] = storage[keccak256(memory[0x00:0x40])] // @0FCF stack[-1] = 0x0fdb // @0FD0 stack[1] = stack[-2] // } // Block ends with call to 0x0ee7 & 0xffffffff, returns to 0x0FDB label_0FDB: // Incoming return from call to 0x0EE7 at 0x0FDA // Inputs[8] // { // @0FE4 stack[-3] // @0FF6 memory[0x00:0x40] // @0FF7 stack[-1] // @0FFC memory[0x40:0x60] // @0FFD stack[-2] // @1001 memory[0x40:0x60] // @102F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @1032 stack[-4] // } 0FDB 5B JUMPDEST 0FDC 60 PUSH1 0x01 0FDE 60 PUSH1 0x01 0FE0 60 PUSH1 0xa0 0FE2 1B SHL 0FE3 03 SUB 0FE4 83 DUP4 0FE5 16 AND 0FE6 60 PUSH1 0x00 0FE8 81 DUP2 0FE9 81 DUP2 0FEA 52 MSTORE 0FEB 60 PUSH1 0x33 0FED 60 PUSH1 0x20 0FEF 90 SWAP1 0FF0 81 DUP2 0FF1 52 MSTORE 0FF2 60 PUSH1 0x40 0FF4 80 DUP1 0FF5 83 DUP4 0FF6 20 SHA3 0FF7 94 SWAP5 0FF8 90 SWAP1 0FF9 94 SWAP5 0FFA 55 SSTORE 0FFB 83 DUP4 0FFC 51 MLOAD 0FFD 85 DUP6 0FFE 81 DUP2 0FFF 52 MSTORE 1000 93 SWAP4 1001 51 MLOAD 1002 92 SWAP3 1003 93 SWAP4 1004 91 SWAP2 1005 92 SWAP3 1006 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1027 92 SWAP3 1028 81 DUP2 1029 90 SWAP1 102A 03 SUB 102B 90 SWAP1 102C 91 SWAP2 102D 01 ADD 102E 90 SWAP1 102F A3 LOG3 1030 50 POP 1031 50 POP 1032 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0FEA memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0FF1 memory[0x20:0x40] = 0x33 // @0FFA storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0FFF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @102F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] label_1033: // Incoming jump from 0x0EDC // Incoming jump from 0x0AAD // Incoming call from 0x0DCD, returns to 0x0DCE // Inputs[3] // { // @1036 stack[-1] // @1037 stack[-3] // @1038 stack[-2] // } 1033 5B JUMPDEST 1034 60 PUSH1 0x00 1036 81 DUP2 1037 84 DUP5 1038 84 DUP5 1039 11 GT 103A 15 ISZERO 103B 61 PUSH2 0x10c2 103E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1034 stack[0] = 0x00 // @1036 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x10c2, if !(stack[-2] > stack[-3]) label_103F: // Incoming jump from 0x103E, if not !(stack[-2] > stack[-3]) // Inputs[4] // { // @1041 memory[0x40:0x60] // @1058 stack[-1] // @105B memory[stack[-1]:stack[-1] + 0x20] // @1064 memory[stack[-1]:stack[-1] + 0x20] // } 103F 60 PUSH1 0x40 1041 51 MLOAD 1042 62 PUSH3 0x461bcd 1046 60 PUSH1 0xe5 1048 1B SHL 1049 81 DUP2 104A 52 MSTORE 104B 60 PUSH1 0x04 104D 01 ADD 104E 80 DUP1 104F 80 DUP1 1050 60 PUSH1 0x20 1052 01 ADD 1053 82 DUP3 1054 81 DUP2 1055 03 SUB 1056 82 DUP3 1057 52 MSTORE 1058 83 DUP4 1059 81 DUP2 105A 81 DUP2 105B 51 MLOAD 105C 81 DUP2 105D 52 MSTORE 105E 60 PUSH1 0x20 1060 01 ADD 1061 91 SWAP2 1062 50 POP 1063 80 DUP1 1064 51 MLOAD 1065 90 SWAP1 1066 60 PUSH1 0x20 1068 01 ADD 1069 90 SWAP1 106A 80 DUP1 106B 83 DUP4 106C 83 DUP4 106D 60 PUSH1 0x00 106F 5B JUMPDEST 1070 83 DUP4 1071 81 DUP2 1072 10 LT 1073 15 ISZERO 1074 61 PUSH2 0x1087 1077 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @104A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @104D stack[0] = 0x04 + memory[0x40:0x60] // @104E stack[1] = 0x04 + memory[0x40:0x60] // @1057 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @105D memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1061 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1069 stack[3] = 0x20 + stack[-1] // @1069 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @106A stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @106B stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @106C stack[7] = 0x20 + stack[-1] // @106D stack[8] = 0x00 // } // Block ends with conditional jump to 0x1087, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1078: // Incoming jump from 0x1077, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1077, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1078 stack[-2] // @1079 stack[-1] // @107B memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @107C stack[-3] // } 1078 81 DUP2 1079 81 DUP2 107A 01 ADD 107B 51 MLOAD 107C 83 DUP4 107D 82 DUP3 107E 01 ADD 107F 52 MSTORE 1080 60 PUSH1 0x20 1082 01 ADD 1083 61 PUSH2 0x106f 1086 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @107F memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1082 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x106f label_1087: // Incoming jump from 0x1077, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1077, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @108C stack[-6] // @108C stack[-5] // @108E stack[-7] // } 1087 5B JUMPDEST 1088 50 POP 1089 50 POP 108A 50 POP 108B 50 POP 108C 90 SWAP1 108D 50 POP 108E 90 SWAP1 108F 81 DUP2 1090 01 ADD 1091 90 SWAP1 1092 60 PUSH1 0x1f 1094 16 AND 1095 80 DUP1 1096 15 ISZERO 1097 61 PUSH2 0x10b4 109A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1091 stack[-7] = stack[-5] + stack[-7] // @1094 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x10b4, if !(0x1f & stack[-5]) label_109B: // Incoming jump from 0x109A, if not !(0x1f & stack[-5]) // Inputs[6] // { // @109B stack[-1] // @109C stack[-2] // @109F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @10B6 stack[-5] // @10BC memory[0x40:0x60] // @10C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 109B 80 DUP1 109C 82 DUP3 109D 03 SUB 109E 80 DUP1 109F 51 MLOAD 10A0 60 PUSH1 0x01 10A2 83 DUP4 10A3 60 PUSH1 0x20 10A5 03 SUB 10A6 61 PUSH2 0x0100 10A9 0A EXP 10AA 03 SUB 10AB 19 NOT 10AC 16 AND 10AD 81 DUP2 10AE 52 MSTORE 10AF 60 PUSH1 0x20 10B1 01 ADD 10B2 91 SWAP2 10B3 50 POP 10B4 5B JUMPDEST 10B5 50 POP 10B6 92 SWAP3 10B7 50 POP 10B8 50 POP 10B9 50 POP 10BA 60 PUSH1 0x40 10BC 51 MLOAD 10BD 80 DUP1 10BE 91 SWAP2 10BF 03 SUB 10C0 90 SWAP1 10C1 FD *REVERT // Stack delta = -5 // Outputs[2] // { // @10AE 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] // @10C1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_10C2: // Incoming jump from 0x103E, if !(stack[-2] > stack[-3]) // Inputs[3] // { // @10C6 stack[-5] // @10C6 stack[-4] // @10C8 stack[-6] // } 10C2 5B JUMPDEST 10C3 50 POP 10C4 50 POP 10C5 50 POP 10C6 90 SWAP1 10C7 03 SUB 10C8 90 SWAP1 10C9 56 *JUMP // Stack delta = -5 // Outputs[1] { @10C8 stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_10CA: // Incoming call from 0x0BFF, returns to 0x0C00 // Inputs[6] // { // @10D3 stack[-2] // @10E6 memory[0x00:0x40] // @10E7 stack[-1] // @10F1 memory[0x00:0x40] // @10F2 storage[keccak256(memory[0x00:0x40])] // @10F3 stack[-3] // } 10CA 5B JUMPDEST 10CB 60 PUSH1 0x01 10CD 60 PUSH1 0x01 10CF 60 PUSH1 0xa0 10D1 1B SHL 10D2 03 SUB 10D3 91 SWAP2 10D4 82 DUP3 10D5 16 AND 10D6 60 PUSH1 0x00 10D8 90 SWAP1 10D9 81 DUP2 10DA 52 MSTORE 10DB 60 PUSH1 0x34 10DD 60 PUSH1 0x20 10DF 90 SWAP1 10E0 81 DUP2 10E1 52 MSTORE 10E2 60 PUSH1 0x40 10E4 80 DUP1 10E5 83 DUP4 10E6 20 SHA3 10E7 93 SWAP4 10E8 90 SWAP1 10E9 94 SWAP5 10EA 16 AND 10EB 82 DUP3 10EC 52 MSTORE 10ED 91 SWAP2 10EE 90 SWAP1 10EF 91 SWAP2 10F0 52 MSTORE 10F1 20 SHA3 10F2 54 SLOAD 10F3 90 SWAP1 10F4 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @10DA memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @10E1 memory[0x20:0x40] = 0x34 // @10EC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @10F0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @10F3 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_10F5: // Incoming call from 0x0CF5, returns to 0x0CF6 // Inputs[1] { @10FE stack[-3] } 10F5 5B JUMPDEST 10F6 60 PUSH1 0x01 10F8 60 PUSH1 0x01 10FA 60 PUSH1 0xa0 10FC 1B SHL 10FD 03 SUB 10FE 83 DUP4 10FF 16 AND 1100 61 PUSH2 0x113a 1103 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x113a, if stack[-3] & (0x01 << 0xa0) - 0x01 label_1104: // Incoming jump from 0x1103, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1106 memory[0x40:0x60] // @1134 memory[0x40:0x60] // @1139 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1104 60 PUSH1 0x40 1106 51 MLOAD 1107 62 PUSH3 0x461bcd 110B 60 PUSH1 0xe5 110D 1B SHL 110E 81 DUP2 110F 52 MSTORE 1110 60 PUSH1 0x04 1112 01 ADD 1113 80 DUP1 1114 80 DUP1 1115 60 PUSH1 0x20 1117 01 ADD 1118 82 DUP3 1119 81 DUP2 111A 03 SUB 111B 82 DUP3 111C 52 MSTORE 111D 60 PUSH1 0x24 111F 81 DUP2 1120 52 MSTORE 1121 60 PUSH1 0x20 1123 01 ADD 1124 80 DUP1 1125 61 PUSH2 0x13b6 1128 60 PUSH1 0x24 112A 91 SWAP2 112B 39 CODECOPY 112C 60 PUSH1 0x40 112E 01 ADD 112F 91 SWAP2 1130 50 POP 1131 50 POP 1132 60 PUSH1 0x40 1134 51 MLOAD 1135 80 DUP1 1136 91 SWAP2 1137 03 SUB 1138 90 SWAP1 1139 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @110F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @111C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1120 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @112B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x13b6:0x13da] // @1139 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_113A: // Incoming jump from 0x1103, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1143 stack[-2] } 113A 5B JUMPDEST 113B 60 PUSH1 0x01 113D 60 PUSH1 0x01 113F 60 PUSH1 0xa0 1141 1B SHL 1142 03 SUB 1143 82 DUP3 1144 16 AND 1145 61 PUSH2 0x117f 1148 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x117f, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1149: // Incoming jump from 0x1148, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @114B memory[0x40:0x60] // @1179 memory[0x40:0x60] // @117E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1149 60 PUSH1 0x40 114B 51 MLOAD 114C 62 PUSH3 0x461bcd 1150 60 PUSH1 0xe5 1152 1B SHL 1153 81 DUP2 1154 52 MSTORE 1155 60 PUSH1 0x04 1157 01 ADD 1158 80 DUP1 1159 80 DUP1 115A 60 PUSH1 0x20 115C 01 ADD 115D 82 DUP3 115E 81 DUP2 115F 03 SUB 1160 82 DUP3 1161 52 MSTORE 1162 60 PUSH1 0x22 1164 81 DUP2 1165 52 MSTORE 1166 60 PUSH1 0x20 1168 01 ADD 1169 80 DUP1 116A 61 PUSH2 0x129d 116D 60 PUSH1 0x22 116F 91 SWAP2 1170 39 CODECOPY 1171 60 PUSH1 0x40 1173 01 ADD 1174 91 SWAP2 1175 50 POP 1176 50 POP 1177 60 PUSH1 0x40 1179 51 MLOAD 117A 80 DUP1 117B 91 SWAP2 117C 03 SUB 117D 90 SWAP1 117E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1154 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1161 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1165 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @1170 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x129d:0x12bf] // @117E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_117F: // Incoming jump from 0x1148, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[9] // { // @1189 stack[-3] // @119B memory[0x00:0x40] // @119D stack[-2] // @11A8 memory[0x00:0x40] // @11A9 stack[-1] // @11AD memory[0x40:0x60] // @11B2 memory[0x40:0x60] // @11DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @11E0 stack[-4] // } 117F 5B JUMPDEST 1180 60 PUSH1 0x01 1182 60 PUSH1 0x01 1184 60 PUSH1 0xa0 1186 1B SHL 1187 03 SUB 1188 80 DUP1 1189 84 DUP5 118A 16 AND 118B 60 PUSH1 0x00 118D 81 DUP2 118E 81 DUP2 118F 52 MSTORE 1190 60 PUSH1 0x34 1192 60 PUSH1 0x20 1194 90 SWAP1 1195 81 DUP2 1196 52 MSTORE 1197 60 PUSH1 0x40 1199 80 DUP1 119A 83 DUP4 119B 20 SHA3 119C 94 SWAP5 119D 87 DUP8 119E 16 AND 119F 80 DUP1 11A0 84 DUP5 11A1 52 MSTORE 11A2 94 SWAP5 11A3 82 DUP3 11A4 52 MSTORE 11A5 91 SWAP2 11A6 82 DUP3 11A7 90 SWAP1 11A8 20 SHA3 11A9 85 DUP6 11AA 90 SWAP1 11AB 55 SSTORE 11AC 81 DUP2 11AD 51 MLOAD 11AE 85 DUP6 11AF 81 DUP2 11B0 52 MSTORE 11B1 91 SWAP2 11B2 51 MLOAD 11B3 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 11D4 92 SWAP3 11D5 81 DUP2 11D6 90 SWAP1 11D7 03 SUB 11D8 90 SWAP1 11D9 91 SWAP2 11DA 01 ADD 11DB 90 SWAP1 11DC A3 LOG3 11DD 50 POP 11DE 50 POP 11DF 50 POP 11E0 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @118F memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1196 memory[0x20:0x40] = 0x34 // @11A1 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @11A4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @11AB storage[keccak256(memory[0x00:0x40])] = stack[-1] // @11B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @11DC 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_11E1: // Incoming jump from 0x0775 // Incoming jump from 0x0775 // Inputs[5] // { // @11E2 stack[-3] // @11E4 storage[stack[-3]] // @11FE memory[0x00:0x20] // @1209 stack[-2] // @120A stack[-1] // } 11E1 5B JUMPDEST 11E2 82 DUP3 11E3 80 DUP1 11E4 54 SLOAD 11E5 60 PUSH1 0x01 11E7 81 DUP2 11E8 60 PUSH1 0x01 11EA 16 AND 11EB 15 ISZERO 11EC 61 PUSH2 0x0100 11EF 02 MUL 11F0 03 SUB 11F1 16 AND 11F2 60 PUSH1 0x02 11F4 90 SWAP1 11F5 04 DIV 11F6 90 SWAP1 11F7 60 PUSH1 0x00 11F9 52 MSTORE 11FA 60 PUSH1 0x20 11FC 60 PUSH1 0x00 11FE 20 SHA3 11FF 90 SWAP1 1200 60 PUSH1 0x1f 1202 01 ADD 1203 60 PUSH1 0x20 1205 90 SWAP1 1206 04 DIV 1207 81 DUP2 1208 01 ADD 1209 92 SWAP3 120A 82 DUP3 120B 60 PUSH1 0x1f 120D 10 LT 120E 61 PUSH2 0x1222 1211 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @11F9 memory[0x00:0x20] = stack[-3] // @11FF stack[0] = keccak256(memory[0x00:0x20]) // @1209 stack[1] = stack[-2] // @1209 stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x1222, if 0x1f < stack[-1] label_1212: // Incoming jump from 0x1211, if not 0x1f < stack[-1] // Inputs[4] // { // @1212 stack[-1] // @1213 memory[stack[-1]:stack[-1] + 0x20] // @1218 stack[-3] // @121C stack[-5] // } 1212 80 DUP1 1213 51 MLOAD 1214 60 PUSH1 0xff 1216 19 NOT 1217 16 AND 1218 83 DUP4 1219 80 DUP1 121A 01 ADD 121B 17 OR 121C 85 DUP6 121D 55 SSTORE 121E 61 PUSH2 0x124f 1221 56 *JUMP // Stack delta = +0 // Outputs[1] { @121D storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x124f label_1222: // Incoming jump from 0x1211, if 0x1f < stack[-1] // Inputs[2] // { // @1223 stack[-3] // @1229 stack[-5] // } 1222 5B JUMPDEST 1223 82 DUP3 1224 80 DUP1 1225 01 ADD 1226 60 PUSH1 0x01 1228 01 ADD 1229 85 DUP6 122A 55 SSTORE 122B 82 DUP3 122C 15 ISZERO 122D 61 PUSH2 0x124f 1230 57 *JUMPI // Stack delta = +0 // Outputs[1] { @122A storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x124f, if !stack[-3] label_1231: // Incoming jump from 0x1230, if not !stack[-3] // Inputs[2] // { // @1231 stack[-3] // @1231 stack[-1] // } 1231 91 SWAP2 1232 82 DUP3 1233 01 ADD 1234 5B JUMPDEST 1235 82 DUP3 1236 81 DUP2 1237 11 GT 1238 15 ISZERO 1239 61 PUSH2 0x124f 123C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1231 stack[-3] = stack[-1] // @1233 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x124f, if !(stack[-1] + stack[-3] > stack[-1]) label_123D: // Incoming jump from 0x123C, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x123C, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @123D stack[-3] // @123E memory[stack[-3]:stack[-3] + 0x20] // @123F stack[-2] // @1241 stack[-1] // } 123D 82 DUP3 123E 51 MLOAD 123F 82 DUP3 1240 55 SSTORE 1241 91 SWAP2 1242 60 PUSH1 0x20 1244 01 ADD 1245 91 SWAP2 1246 90 SWAP1 1247 60 PUSH1 0x01 1249 01 ADD 124A 90 SWAP1 124B 61 PUSH2 0x1234 124E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1240 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1245 stack[-3] = 0x20 + stack[-3] // @124A stack[-2] = 0x01 + stack[-2] // @124A stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1234 label_124F: // Incoming jump from 0x123C, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x123C, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1230, if !stack[-3] // Incoming jump from 0x1221 // Inputs[2] // { // @1254 stack[-4] // @1255 stack[-3] // } 124F 5B JUMPDEST 1250 50 POP 1251 61 PUSH2 0x125b 1254 92 SWAP3 1255 91 SWAP2 1256 50 POP 1257 61 PUSH2 0x125f 125A 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1254 stack[-4] = 0x125b // @1255 stack[-3] = stack[-4] // } // Block ends with call to 0x125f, returns to 0x125B label_125B: // Incoming jump from 0x126D, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x125F at 0x125A // Incoming call from 0x126D, returns to 0x06B5, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @125D stack[-2] // @125D stack[-3] // } 125B 5B JUMPDEST 125C 50 POP 125D 90 SWAP1 125E 56 *JUMP // Stack delta = -2 // Outputs[1] { @125D stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_125F: // Incoming call from 0x125A, returns to 0x125B // Inputs[2] // { // @1263 stack[-2] // @1264 stack[-1] // } 125F 5B JUMPDEST 1260 61 PUSH2 0x06b5 1263 91 SWAP2 1264 90 SWAP1 1265 5B JUMPDEST 1266 80 DUP1 1267 82 DUP3 1268 11 GT 1269 15 ISZERO 126A 61 PUSH2 0x125b 126D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1263 stack[-2] = 0x06b5 // @1264 stack[-1] = stack[-2] // @1264 stack[0] = stack[-1] // } // Block ends with conditional call to 0x125b, returns to 0x06B5, if !(stack[-2] > stack[-1]) label_126E: // Incoming jump from 0x126D, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x126D, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1270 stack[-1] } 126E 60 PUSH1 0x00 1270 81 DUP2 1271 55 SSTORE 1272 60 PUSH1 0x01 1274 01 ADD 1275 61 PUSH2 0x1265 1278 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1271 storage[stack[-1]] = 0x00 // @1274 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1265 1279 FE *ASSERT 127A 45 GASLIMIT 127B 52 MSTORE 127C 43 NUMBER 127D 32 ORIGIN 127E 30 ADDRESS 127F 3A GASPRICE 1280 20 SHA3 1281 74 PUSH21 0x72616e7366657220746f20746865207a65726f2061 1297 64 PUSH5 0x6472657373 129D 45 GASLIMIT 129E 52 MSTORE 129F 43 NUMBER 12A0 32 ORIGIN 12A1 30 ADDRESS 12A2 3A GASPRICE 12A3 20 SHA3 12A4 61 PUSH2 0x7070 12A7 72 PUSH19 0x6f766520746f20746865207a65726f20616464 12BB 72 PUSH19 0x65737345524332303a207472616e7366657220 12CF 61 PUSH2 0x6d6f 12D2 75 PUSH22 0x6e7420657863656564732062616c616e636545524332 12E9 30 ADDRESS 12EA 3A GASPRICE 12EB 20 SHA3 12EC 74 PUSH21 0x72616e7366657220616d6f756e7420657863656564 1302 73 PUSH20 0x20616c6c6f77616e6365436f6e74726163742069 1317 6E PUSH15 0x7374616e63652068617320616c7265 1327 61 PUSH2 0x6479 132A 20 SHA3 132B 62 PUSH3 0x65656e 132F 20 SHA3 1330 69 PUSH10 0x6e697469616c697a6564 133B 53 MSTORE8 133C 65 PUSH6 0x636f6e646172 1343 79 PUSH26 0x3a206e6577207072696d61727920697320746865207a65726f20 135E 61 PUSH2 0x6464 1361 72 PUSH19 0x65737345524332303a207472616e7366657220 1375 66 PUSH7 0x726f6d20746865 137D 20 SHA3 137E 7A PUSH27 0x65726f20616464726573735365636f6e646172793a2063616c6c65 139A 72 PUSH19 0x206973206e6f7420746865207072696d617279 13AE 20 SHA3 13AF 61 PUSH2 0x6363 13B2 6F PUSH16 0x756e7445524332303a20617070726f76 13C3 65 PUSH6 0x2066726f6d20 13CA 74 PUSH21 0x6865207a65726f206164647265737345524332303a 13E0 20 SHA3 13E1 64 PUSH5 0x6563726561 13E7 73 PUSH20 0x656420616c6c6f77616e63652062656c6f77207a 13FC 65 PUSH6 0x726fa265627a 1403 7A PUSH27 0x723158202ad8b7b2b787edc2f4f28dd9f5f5a763dbd4f0727493ee 141F 6D PUSH14 0x536bfaf54acab6c564736f6c6343 142E 00 *STOP 142F 05 SDIV 1430 0D 0D 1431 00 *STOP 1432 32 ORIGIN