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 0x0133 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0133, 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 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 003B 90 SWAP1 003C 04 DIV 003D 80 DUP1 003E 63 PUSH4 0x70a08231 0043 11 GT 0044 61 PUSH2 0x00bf 0047 57 *JUMPI // Stack delta = +1 // Outputs[1] { @003C stack[0] = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x00bf, if 0x70a08231 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 label_0048: // Incoming jump from 0x0047, if not 0x70a08231 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @0048 stack[-1] } 0048 80 DUP1 0049 63 PUSH4 0x98650275 004E 11 GT 004F 61 PUSH2 0x008e 0052 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008e, if 0x98650275 > stack[-1] label_0053: // Incoming jump from 0x0052, if not 0x98650275 > stack[-1] // Inputs[1] { @0053 stack[-1] } 0053 80 DUP1 0054 63 PUSH4 0x98650275 0059 14 EQ 005A 61 PUSH2 0x056e 005D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056e, if 0x98650275 == stack[-1] label_005E: // Incoming jump from 0x005D, if not 0x98650275 == stack[-1] // Inputs[1] { @005E stack[-1] } 005E 80 DUP1 005F 63 PUSH4 0xa457c2d7 0064 14 EQ 0065 61 PUSH2 0x0578 0068 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0578, if 0xa457c2d7 == stack[-1] label_0069: // Incoming jump from 0x0068, if not 0xa457c2d7 == stack[-1] // Inputs[1] { @0069 stack[-1] } 0069 80 DUP1 006A 63 PUSH4 0xa9059cbb 006F 14 EQ 0070 61 PUSH2 0x05de 0073 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05de, if 0xa9059cbb == stack[-1] label_0074: // Incoming jump from 0x0073, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0074 stack[-1] } 0074 80 DUP1 0075 63 PUSH4 0xaa271e1a 007A 14 EQ 007B 61 PUSH2 0x0644 007E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0644, if 0xaa271e1a == stack[-1] label_007F: // Incoming jump from 0x007E, if not 0xaa271e1a == stack[-1] // Inputs[1] { @007F stack[-1] } 007F 80 DUP1 0080 63 PUSH4 0xdd62ed3e 0085 14 EQ 0086 61 PUSH2 0x06a0 0089 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a0, if 0xdd62ed3e == stack[-1] label_008A: // Incoming jump from 0x0089, if not 0xdd62ed3e == stack[-1] 008A 61 PUSH2 0x0133 008D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0133 label_008E: // Incoming jump from 0x0052, if 0x98650275 > stack[-1] // Inputs[1] { @008F stack[-1] } 008E 5B JUMPDEST 008F 80 DUP1 0090 63 PUSH4 0x70a08231 0095 14 EQ 0096 61 PUSH2 0x0401 0099 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0401, if 0x70a08231 == stack[-1] label_009A: // Incoming jump from 0x0099, if not 0x70a08231 == stack[-1] // Inputs[1] { @009A stack[-1] } 009A 80 DUP1 009B 63 PUSH4 0x79cc6790 00A0 14 EQ 00A1 61 PUSH2 0x0459 00A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0459, if 0x79cc6790 == stack[-1] label_00A5: // Incoming jump from 0x00A4, if not 0x79cc6790 == stack[-1] // Inputs[1] { @00A5 stack[-1] } 00A5 80 DUP1 00A6 63 PUSH4 0x95d89b41 00AB 14 EQ 00AC 61 PUSH2 0x04a7 00AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a7, if 0x95d89b41 == stack[-1] label_00B0: // Incoming jump from 0x00AF, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00B0 stack[-1] } 00B0 80 DUP1 00B1 63 PUSH4 0x983b2d56 00B6 14 EQ 00B7 61 PUSH2 0x052a 00BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052a, if 0x983b2d56 == stack[-1] label_00BB: // Incoming jump from 0x00BA, if not 0x983b2d56 == stack[-1] 00BB 61 PUSH2 0x0133 00BE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0133 label_00BF: // Incoming jump from 0x0047, if 0x70a08231 > msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 // Inputs[1] { @00C0 stack[-1] } 00BF 5B JUMPDEST 00C0 80 DUP1 00C1 63 PUSH4 0x313ce567 00C6 11 GT 00C7 61 PUSH2 0x0106 00CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0106, if 0x313ce567 > stack[-1] label_00CB: // Incoming jump from 0x00CA, if not 0x313ce567 > stack[-1] // Inputs[1] { @00CB stack[-1] } 00CB 80 DUP1 00CC 63 PUSH4 0x313ce567 00D1 14 EQ 00D2 61 PUSH2 0x02c5 00D5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c5, if 0x313ce567 == stack[-1] label_00D6: // Incoming jump from 0x00D5, if not 0x313ce567 == stack[-1] // Inputs[1] { @00D6 stack[-1] } 00D6 80 DUP1 00D7 63 PUSH4 0x355274ea 00DC 14 EQ 00DD 61 PUSH2 0x02e9 00E0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e9, if 0x355274ea == stack[-1] label_00E1: // Incoming jump from 0x00E0, if not 0x355274ea == stack[-1] // Inputs[1] { @00E1 stack[-1] } 00E1 80 DUP1 00E2 63 PUSH4 0x39509351 00E7 14 EQ 00E8 61 PUSH2 0x0307 00EB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0307, if 0x39509351 == stack[-1] label_00EC: // Incoming jump from 0x00EB, if not 0x39509351 == stack[-1] // Inputs[1] { @00EC stack[-1] } 00EC 80 DUP1 00ED 63 PUSH4 0x40c10f19 00F2 14 EQ 00F3 61 PUSH2 0x036d 00F6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036d, if 0x40c10f19 == stack[-1] label_00F7: // Incoming jump from 0x00F6, if not 0x40c10f19 == stack[-1] // Inputs[1] { @00F7 stack[-1] } 00F7 80 DUP1 00F8 63 PUSH4 0x42966c68 00FD 14 EQ 00FE 61 PUSH2 0x03d3 0101 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d3, if 0x42966c68 == stack[-1] label_0102: // Incoming jump from 0x0101, if not 0x42966c68 == stack[-1] 0102 61 PUSH2 0x0133 0105 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0133 label_0106: // Incoming jump from 0x00CA, if 0x313ce567 > stack[-1] // Inputs[1] { @0107 stack[-1] } 0106 5B JUMPDEST 0107 80 DUP1 0108 63 PUSH4 0x06fdde03 010D 14 EQ 010E 61 PUSH2 0x0138 0111 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0138, if 0x06fdde03 == stack[-1] label_0112: // Incoming jump from 0x0111, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0112 stack[-1] } 0112 80 DUP1 0113 63 PUSH4 0x095ea7b3 0118 14 EQ 0119 61 PUSH2 0x01bb 011C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01bb, if 0x095ea7b3 == stack[-1] label_011D: // Incoming jump from 0x011C, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @011D stack[-1] } 011D 80 DUP1 011E 63 PUSH4 0x18160ddd 0123 14 EQ 0124 61 PUSH2 0x0221 0127 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0221, if 0x18160ddd == stack[-1] label_0128: // Incoming jump from 0x0127, if not 0x18160ddd == stack[-1] // Inputs[1] { @0128 stack[-1] } 0128 80 DUP1 0129 63 PUSH4 0x23b872dd 012E 14 EQ 012F 61 PUSH2 0x023f 0132 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023f, if 0x23b872dd == stack[-1] label_0133: // Incoming jump from 0x008D // Incoming jump from 0x0105 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00BE // Incoming jump from 0x0132, if not 0x23b872dd == stack[-1] // Inputs[1] { @0137 memory[0x00:0x00] } 0133 5B JUMPDEST 0134 60 PUSH1 0x00 0136 80 DUP1 0137 FD *REVERT // Stack delta = +0 // Outputs[1] { @0137 revert(memory[0x00:0x00]); } // Block terminates label_0138: // Incoming jump from 0x0111, if 0x06fdde03 == stack[-1] 0138 5B JUMPDEST 0139 61 PUSH2 0x0140 013C 61 PUSH2 0x0718 013F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0139 stack[0] = 0x0140 } // Block ends with call to 0x0718, returns to 0x0140 label_0140: // Incoming return from call to 0x0718 at 0x013F // Inputs[4] // { // @0143 memory[0x40:0x60] // @014E stack[-1] // @0151 memory[stack[-1]:stack[-1] + 0x20] // @015A memory[stack[-1]:stack[-1] + 0x20] // } 0140 5B JUMPDEST 0141 60 PUSH1 0x40 0143 51 MLOAD 0144 80 DUP1 0145 80 DUP1 0146 60 PUSH1 0x20 0148 01 ADD 0149 82 DUP3 014A 81 DUP2 014B 03 SUB 014C 82 DUP3 014D 52 MSTORE 014E 83 DUP4 014F 81 DUP2 0150 81 DUP2 0151 51 MLOAD 0152 81 DUP2 0153 52 MSTORE 0154 60 PUSH1 0x20 0156 01 ADD 0157 91 SWAP2 0158 50 POP 0159 80 DUP1 015A 51 MLOAD 015B 90 SWAP1 015C 60 PUSH1 0x20 015E 01 ADD 015F 90 SWAP1 0160 80 DUP1 0161 83 DUP4 0162 83 DUP4 0163 60 PUSH1 0x00 0165 5B JUMPDEST 0166 83 DUP4 0167 81 DUP2 0168 10 LT 0169 15 ISZERO 016A 61 PUSH2 0x0180 016D 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0143 stack[0] = memory[0x40:0x60] // @0144 stack[1] = memory[0x40:0x60] // @014D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0153 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0157 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @015F stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @015F stack[3] = 0x20 + stack[-1] // @0160 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0161 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0162 stack[7] = 0x20 + stack[-1] // @0163 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0180, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_016E: // Incoming jump from 0x016D, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x016D, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @016E stack[-1] // @016F stack[-2] // @0171 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0173 stack[-3] // } 016E 80 DUP1 016F 82 DUP3 0170 01 ADD 0171 51 MLOAD 0172 81 DUP2 0173 84 DUP5 0174 01 ADD 0175 52 MSTORE 0176 60 PUSH1 0x20 0178 81 DUP2 0179 01 ADD 017A 90 SWAP1 017B 50 POP 017C 61 PUSH2 0x0165 017F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0175 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @017A stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0165 label_0180: // Incoming jump from 0x016D, if !(stack[-1] < stack[-4]) // Incoming jump from 0x016D, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0185 stack[-6] // @0185 stack[-5] // @0187 stack[-7] // } 0180 5B JUMPDEST 0181 50 POP 0182 50 POP 0183 50 POP 0184 50 POP 0185 90 SWAP1 0186 50 POP 0187 90 SWAP1 0188 81 DUP2 0189 01 ADD 018A 90 SWAP1 018B 60 PUSH1 0x1f 018D 16 AND 018E 80 DUP1 018F 15 ISZERO 0190 61 PUSH2 0x01ad 0193 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @018A stack[-7] = stack[-5] + stack[-7] // @018D stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x01ad, if !(0x1f & stack[-5]) label_0194: // Incoming jump from 0x0193, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0194 stack[-1] // @0195 stack[-2] // @0198 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @01AF stack[-5] // @01B5 memory[0x40:0x60] // @01BA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0194 80 DUP1 0195 82 DUP3 0196 03 SUB 0197 80 DUP1 0198 51 MLOAD 0199 60 PUSH1 0x01 019B 83 DUP4 019C 60 PUSH1 0x20 019E 03 SUB 019F 61 PUSH2 0x0100 01A2 0A EXP 01A3 03 SUB 01A4 19 NOT 01A5 16 AND 01A6 81 DUP2 01A7 52 MSTORE 01A8 60 PUSH1 0x20 01AA 01 ADD 01AB 91 SWAP2 01AC 50 POP 01AD 5B JUMPDEST 01AE 50 POP 01AF 92 SWAP3 01B0 50 POP 01B1 50 POP 01B2 50 POP 01B3 60 PUSH1 0x40 01B5 51 MLOAD 01B6 80 DUP1 01B7 91 SWAP2 01B8 03 SUB 01B9 90 SWAP1 01BA F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @01A7 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] // @01BA return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_01BB: // Incoming jump from 0x011C, if 0x095ea7b3 == stack[-1] // Inputs[1] { @01C2 msg.data.length } 01BB 5B JUMPDEST 01BC 61 PUSH2 0x0207 01BF 60 PUSH1 0x04 01C1 80 DUP1 01C2 36 CALLDATASIZE 01C3 03 SUB 01C4 60 PUSH1 0x40 01C6 81 DUP2 01C7 10 LT 01C8 15 ISZERO 01C9 61 PUSH2 0x01d1 01CC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01BC stack[0] = 0x0207 // @01BF stack[1] = 0x04 // @01C3 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01d1, returns to 0x0207, if !(msg.data.length - 0x04 < 0x40) label_01CD: // Incoming jump from 0x01CC, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @01D0 memory[0x00:0x00] } 01CD 60 PUSH1 0x00 01CF 80 DUP1 01D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D0 revert(memory[0x00:0x00]); } // Block terminates label_01D1: // Incoming call from 0x01CC, returns to 0x0207, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @01D2 stack[-2] // @01D3 stack[-1] // @01D7 msg.data[stack[-2]:stack[-2] + 0x20] // @01F7 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 01D1 5B JUMPDEST 01D2 81 DUP2 01D3 01 ADD 01D4 90 SWAP1 01D5 80 DUP1 01D6 80 DUP1 01D7 35 CALLDATALOAD 01D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01ED 16 AND 01EE 90 SWAP1 01EF 60 PUSH1 0x20 01F1 01 ADD 01F2 90 SWAP1 01F3 92 SWAP3 01F4 91 SWAP2 01F5 90 SWAP1 01F6 80 DUP1 01F7 35 CALLDATALOAD 01F8 90 SWAP1 01F9 60 PUSH1 0x20 01FB 01 ADD 01FC 90 SWAP1 01FD 92 SWAP3 01FE 91 SWAP2 01FF 90 SWAP1 0200 50 POP 0201 50 POP 0202 50 POP 0203 61 PUSH2 0x07ba 0206 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01F3 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @01FD stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x07ba label_0207: // Incoming return from call to 0x01D1 at 0x01CC // Inputs[4] // { // @020A memory[0x40:0x60] // @020C stack[-1] // @021B memory[0x40:0x60] // @0220 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0207 5B JUMPDEST 0208 60 PUSH1 0x40 020A 51 MLOAD 020B 80 DUP1 020C 82 DUP3 020D 15 ISZERO 020E 15 ISZERO 020F 15 ISZERO 0210 15 ISZERO 0211 81 DUP2 0212 52 MSTORE 0213 60 PUSH1 0x20 0215 01 ADD 0216 91 SWAP2 0217 50 POP 0218 50 POP 0219 60 PUSH1 0x40 021B 51 MLOAD 021C 80 DUP1 021D 91 SWAP2 021E 03 SUB 021F 90 SWAP1 0220 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0212 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0220 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0221: // Incoming jump from 0x0127, if 0x18160ddd == stack[-1] 0221 5B JUMPDEST 0222 61 PUSH2 0x0229 0225 61 PUSH2 0x07d8 0228 56 *JUMP // Stack delta = +1 // Outputs[1] { @0222 stack[0] = 0x0229 } // Block ends with call to 0x07d8, returns to 0x0229 label_0229: // Incoming return from call to 0x07D8 at 0x0228 // Inputs[4] // { // @022C memory[0x40:0x60] // @022E stack[-1] // @0239 memory[0x40:0x60] // @023E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0229 5B JUMPDEST 022A 60 PUSH1 0x40 022C 51 MLOAD 022D 80 DUP1 022E 82 DUP3 022F 81 DUP2 0230 52 MSTORE 0231 60 PUSH1 0x20 0233 01 ADD 0234 91 SWAP2 0235 50 POP 0236 50 POP 0237 60 PUSH1 0x40 0239 51 MLOAD 023A 80 DUP1 023B 91 SWAP2 023C 03 SUB 023D 90 SWAP1 023E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0230 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @023E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_023F: // Incoming jump from 0x0132, if 0x23b872dd == stack[-1] // Inputs[1] { @0246 msg.data.length } 023F 5B JUMPDEST 0240 61 PUSH2 0x02ab 0243 60 PUSH1 0x04 0245 80 DUP1 0246 36 CALLDATASIZE 0247 03 SUB 0248 60 PUSH1 0x60 024A 81 DUP2 024B 10 LT 024C 15 ISZERO 024D 61 PUSH2 0x0255 0250 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0240 stack[0] = 0x02ab // @0243 stack[1] = 0x04 // @0247 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0255, returns to 0x02AB, if !(msg.data.length - 0x04 < 0x60) label_0251: // Incoming jump from 0x0250, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0254 memory[0x00:0x00] } 0251 60 PUSH1 0x00 0253 80 DUP1 0254 FD *REVERT // Stack delta = +0 // Outputs[1] { @0254 revert(memory[0x00:0x00]); } // Block terminates label_0255: // Incoming call from 0x0250, returns to 0x02AB, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0256 stack[-2] // @0257 stack[-1] // @025B msg.data[stack[-2]:stack[-2] + 0x20] // @027B msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @029B msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0255 5B JUMPDEST 0256 81 DUP2 0257 01 ADD 0258 90 SWAP1 0259 80 DUP1 025A 80 DUP1 025B 35 CALLDATALOAD 025C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0271 16 AND 0272 90 SWAP1 0273 60 PUSH1 0x20 0275 01 ADD 0276 90 SWAP1 0277 92 SWAP3 0278 91 SWAP2 0279 90 SWAP1 027A 80 DUP1 027B 35 CALLDATALOAD 027C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0291 16 AND 0292 90 SWAP1 0293 60 PUSH1 0x20 0295 01 ADD 0296 90 SWAP1 0297 92 SWAP3 0298 91 SWAP2 0299 90 SWAP1 029A 80 DUP1 029B 35 CALLDATALOAD 029C 90 SWAP1 029D 60 PUSH1 0x20 029F 01 ADD 02A0 90 SWAP1 02A1 92 SWAP3 02A2 91 SWAP2 02A3 90 SWAP1 02A4 50 POP 02A5 50 POP 02A6 50 POP 02A7 61 PUSH2 0x07e2 02AA 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0277 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0297 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @02A1 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x07e2 label_02AB: // Incoming return from call to 0x0255 at 0x0250 // Inputs[4] // { // @02AE memory[0x40:0x60] // @02B0 stack[-1] // @02BF memory[0x40:0x60] // @02C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02AB 5B JUMPDEST 02AC 60 PUSH1 0x40 02AE 51 MLOAD 02AF 80 DUP1 02B0 82 DUP3 02B1 15 ISZERO 02B2 15 ISZERO 02B3 15 ISZERO 02B4 15 ISZERO 02B5 81 DUP2 02B6 52 MSTORE 02B7 60 PUSH1 0x20 02B9 01 ADD 02BA 91 SWAP2 02BB 50 POP 02BC 50 POP 02BD 60 PUSH1 0x40 02BF 51 MLOAD 02C0 80 DUP1 02C1 91 SWAP2 02C2 03 SUB 02C3 90 SWAP1 02C4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @02C4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02C5: // Incoming jump from 0x00D5, if 0x313ce567 == stack[-1] 02C5 5B JUMPDEST 02C6 61 PUSH2 0x02cd 02C9 61 PUSH2 0x08bc 02CC 56 *JUMP // Stack delta = +1 // Outputs[1] { @02C6 stack[0] = 0x02cd } // Block ends with call to 0x08bc, returns to 0x02CD label_02CD: // Incoming return from call to 0x08BC at 0x02CC // Inputs[4] // { // @02D0 memory[0x40:0x60] // @02D2 stack[-1] // @02E3 memory[0x40:0x60] // @02E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02CD 5B JUMPDEST 02CE 60 PUSH1 0x40 02D0 51 MLOAD 02D1 80 DUP1 02D2 82 DUP3 02D3 60 PUSH1 0xff 02D5 16 AND 02D6 60 PUSH1 0xff 02D8 16 AND 02D9 81 DUP2 02DA 52 MSTORE 02DB 60 PUSH1 0x20 02DD 01 ADD 02DE 91 SWAP2 02DF 50 POP 02E0 50 POP 02E1 60 PUSH1 0x40 02E3 51 MLOAD 02E4 80 DUP1 02E5 91 SWAP2 02E6 03 SUB 02E7 90 SWAP1 02E8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xff & 0xff & stack[-1] // @02E8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02E9: // Incoming jump from 0x00E0, if 0x355274ea == stack[-1] 02E9 5B JUMPDEST 02EA 61 PUSH2 0x02f1 02ED 61 PUSH2 0x08d3 02F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @02EA stack[0] = 0x02f1 } // Block ends with call to 0x08d3, returns to 0x02F1 label_02F1: // Incoming return from call to 0x08D3 at 0x02F0 // Inputs[4] // { // @02F4 memory[0x40:0x60] // @02F6 stack[-1] // @0301 memory[0x40:0x60] // @0306 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02F1 5B JUMPDEST 02F2 60 PUSH1 0x40 02F4 51 MLOAD 02F5 80 DUP1 02F6 82 DUP3 02F7 81 DUP2 02F8 52 MSTORE 02F9 60 PUSH1 0x20 02FB 01 ADD 02FC 91 SWAP2 02FD 50 POP 02FE 50 POP 02FF 60 PUSH1 0x40 0301 51 MLOAD 0302 80 DUP1 0303 91 SWAP2 0304 03 SUB 0305 90 SWAP1 0306 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0306 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0307: // Incoming jump from 0x00EB, if 0x39509351 == stack[-1] // Inputs[1] { @030E msg.data.length } 0307 5B JUMPDEST 0308 61 PUSH2 0x0353 030B 60 PUSH1 0x04 030D 80 DUP1 030E 36 CALLDATASIZE 030F 03 SUB 0310 60 PUSH1 0x40 0312 81 DUP2 0313 10 LT 0314 15 ISZERO 0315 61 PUSH2 0x031d 0318 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0308 stack[0] = 0x0353 // @030B stack[1] = 0x04 // @030F stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x031d, returns to 0x0353, if !(msg.data.length - 0x04 < 0x40) label_0319: // Incoming jump from 0x0318, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @031C memory[0x00:0x00] } 0319 60 PUSH1 0x00 031B 80 DUP1 031C FD *REVERT // Stack delta = +0 // Outputs[1] { @031C revert(memory[0x00:0x00]); } // Block terminates label_031D: // Incoming call from 0x0318, returns to 0x0353, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @031E stack[-2] // @031F stack[-1] // @0323 msg.data[stack[-2]:stack[-2] + 0x20] // @0343 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 031D 5B JUMPDEST 031E 81 DUP2 031F 01 ADD 0320 90 SWAP1 0321 80 DUP1 0322 80 DUP1 0323 35 CALLDATALOAD 0324 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0339 16 AND 033A 90 SWAP1 033B 60 PUSH1 0x20 033D 01 ADD 033E 90 SWAP1 033F 92 SWAP3 0340 91 SWAP2 0341 90 SWAP1 0342 80 DUP1 0343 35 CALLDATALOAD 0344 90 SWAP1 0345 60 PUSH1 0x20 0347 01 ADD 0348 90 SWAP1 0349 92 SWAP3 034A 91 SWAP2 034B 90 SWAP1 034C 50 POP 034D 50 POP 034E 50 POP 034F 61 PUSH2 0x08dd 0352 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @033F stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0349 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x08dd label_0353: // Incoming return from call to 0x031D at 0x0318 // Inputs[4] // { // @0356 memory[0x40:0x60] // @0358 stack[-1] // @0367 memory[0x40:0x60] // @036C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0353 5B JUMPDEST 0354 60 PUSH1 0x40 0356 51 MLOAD 0357 80 DUP1 0358 82 DUP3 0359 15 ISZERO 035A 15 ISZERO 035B 15 ISZERO 035C 15 ISZERO 035D 81 DUP2 035E 52 MSTORE 035F 60 PUSH1 0x20 0361 01 ADD 0362 91 SWAP2 0363 50 POP 0364 50 POP 0365 60 PUSH1 0x40 0367 51 MLOAD 0368 80 DUP1 0369 91 SWAP2 036A 03 SUB 036B 90 SWAP1 036C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @035E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @036C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_036D: // Incoming jump from 0x00F6, if 0x40c10f19 == stack[-1] // Inputs[1] { @0374 msg.data.length } 036D 5B JUMPDEST 036E 61 PUSH2 0x03b9 0371 60 PUSH1 0x04 0373 80 DUP1 0374 36 CALLDATASIZE 0375 03 SUB 0376 60 PUSH1 0x40 0378 81 DUP2 0379 10 LT 037A 15 ISZERO 037B 61 PUSH2 0x0383 037E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @036E stack[0] = 0x03b9 // @0371 stack[1] = 0x04 // @0375 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0383, returns to 0x03B9, if !(msg.data.length - 0x04 < 0x40) label_037F: // Incoming jump from 0x037E, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0382 memory[0x00:0x00] } 037F 60 PUSH1 0x00 0381 80 DUP1 0382 FD *REVERT // Stack delta = +0 // Outputs[1] { @0382 revert(memory[0x00:0x00]); } // Block terminates label_0383: // Incoming call from 0x037E, returns to 0x03B9, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0384 stack[-2] // @0385 stack[-1] // @0389 msg.data[stack[-2]:stack[-2] + 0x20] // @03A9 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0383 5B JUMPDEST 0384 81 DUP2 0385 01 ADD 0386 90 SWAP1 0387 80 DUP1 0388 80 DUP1 0389 35 CALLDATALOAD 038A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 039F 16 AND 03A0 90 SWAP1 03A1 60 PUSH1 0x20 03A3 01 ADD 03A4 90 SWAP1 03A5 92 SWAP3 03A6 91 SWAP2 03A7 90 SWAP1 03A8 80 DUP1 03A9 35 CALLDATALOAD 03AA 90 SWAP1 03AB 60 PUSH1 0x20 03AD 01 ADD 03AE 90 SWAP1 03AF 92 SWAP3 03B0 91 SWAP2 03B1 90 SWAP1 03B2 50 POP 03B3 50 POP 03B4 50 POP 03B5 61 PUSH2 0x0990 03B8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03A5 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @03AF stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0990 label_03B9: // Incoming return from call to 0x0383 at 0x037E // Inputs[4] // { // @03BC memory[0x40:0x60] // @03BE stack[-1] // @03CD memory[0x40:0x60] // @03D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03B9 5B JUMPDEST 03BA 60 PUSH1 0x40 03BC 51 MLOAD 03BD 80 DUP1 03BE 82 DUP3 03BF 15 ISZERO 03C0 15 ISZERO 03C1 15 ISZERO 03C2 15 ISZERO 03C3 81 DUP2 03C4 52 MSTORE 03C5 60 PUSH1 0x20 03C7 01 ADD 03C8 91 SWAP2 03C9 50 POP 03CA 50 POP 03CB 60 PUSH1 0x40 03CD 51 MLOAD 03CE 80 DUP1 03CF 91 SWAP2 03D0 03 SUB 03D1 90 SWAP1 03D2 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @03D2 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03D3: // Incoming jump from 0x0101, if 0x42966c68 == stack[-1] // Inputs[1] { @03DA msg.data.length } 03D3 5B JUMPDEST 03D4 61 PUSH2 0x03ff 03D7 60 PUSH1 0x04 03D9 80 DUP1 03DA 36 CALLDATASIZE 03DB 03 SUB 03DC 60 PUSH1 0x20 03DE 81 DUP2 03DF 10 LT 03E0 15 ISZERO 03E1 61 PUSH2 0x03e9 03E4 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03D4 stack[0] = 0x03ff // @03D7 stack[1] = 0x04 // @03DB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03e9, returns to 0x03FF, if !(msg.data.length - 0x04 < 0x20) label_03E5: // Incoming jump from 0x03E4, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @03E8 memory[0x00:0x00] } 03E5 60 PUSH1 0x00 03E7 80 DUP1 03E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E8 revert(memory[0x00:0x00]); } // Block terminates label_03E9: // Incoming call from 0x03E4, returns to 0x03FF, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @03EA stack[-2] // @03EB stack[-1] // @03EF msg.data[stack[-2]:stack[-2] + 0x20] // } 03E9 5B JUMPDEST 03EA 81 DUP2 03EB 01 ADD 03EC 90 SWAP1 03ED 80 DUP1 03EE 80 DUP1 03EF 35 CALLDATALOAD 03F0 90 SWAP1 03F1 60 PUSH1 0x20 03F3 01 ADD 03F4 90 SWAP1 03F5 92 SWAP3 03F6 91 SWAP2 03F7 90 SWAP1 03F8 50 POP 03F9 50 POP 03FA 50 POP 03FB 61 PUSH2 0x0a0d 03FE 56 *JUMP // Stack delta = -1 // Outputs[1] { @03F5 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0a0d label_03FF: // Incoming return from call to 0x03E9 at 0x03E4 03FF 5B JUMPDEST 0400 00 *STOP // Stack delta = +0 // Outputs[1] { @0400 stop(); } // Block terminates label_0401: // Incoming jump from 0x0099, if 0x70a08231 == stack[-1] // Inputs[1] { @0408 msg.data.length } 0401 5B JUMPDEST 0402 61 PUSH2 0x0443 0405 60 PUSH1 0x04 0407 80 DUP1 0408 36 CALLDATASIZE 0409 03 SUB 040A 60 PUSH1 0x20 040C 81 DUP2 040D 10 LT 040E 15 ISZERO 040F 61 PUSH2 0x0417 0412 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0402 stack[0] = 0x0443 // @0405 stack[1] = 0x04 // @0409 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0417, returns to 0x0443, if !(msg.data.length - 0x04 < 0x20) label_0413: // Incoming jump from 0x0412, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0416 memory[0x00:0x00] } 0413 60 PUSH1 0x00 0415 80 DUP1 0416 FD *REVERT // Stack delta = +0 // Outputs[1] { @0416 revert(memory[0x00:0x00]); } // Block terminates label_0417: // Incoming call from 0x0412, returns to 0x0443, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0418 stack[-2] // @0419 stack[-1] // @041D msg.data[stack[-2]:stack[-2] + 0x20] // } 0417 5B JUMPDEST 0418 81 DUP2 0419 01 ADD 041A 90 SWAP1 041B 80 DUP1 041C 80 DUP1 041D 35 CALLDATALOAD 041E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0433 16 AND 0434 90 SWAP1 0435 60 PUSH1 0x20 0437 01 ADD 0438 90 SWAP1 0439 92 SWAP3 043A 91 SWAP2 043B 90 SWAP1 043C 50 POP 043D 50 POP 043E 50 POP 043F 61 PUSH2 0x0a21 0442 56 *JUMP // Stack delta = -1 // Outputs[1] { @0439 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0a21 label_0443: // Incoming return from call to 0x0417 at 0x0412 // Inputs[4] // { // @0446 memory[0x40:0x60] // @0448 stack[-1] // @0453 memory[0x40:0x60] // @0458 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0443 5B JUMPDEST 0444 60 PUSH1 0x40 0446 51 MLOAD 0447 80 DUP1 0448 82 DUP3 0449 81 DUP2 044A 52 MSTORE 044B 60 PUSH1 0x20 044D 01 ADD 044E 91 SWAP2 044F 50 POP 0450 50 POP 0451 60 PUSH1 0x40 0453 51 MLOAD 0454 80 DUP1 0455 91 SWAP2 0456 03 SUB 0457 90 SWAP1 0458 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @044A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0458 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0459: // Incoming jump from 0x00A4, if 0x79cc6790 == stack[-1] // Inputs[1] { @0460 msg.data.length } 0459 5B JUMPDEST 045A 61 PUSH2 0x04a5 045D 60 PUSH1 0x04 045F 80 DUP1 0460 36 CALLDATASIZE 0461 03 SUB 0462 60 PUSH1 0x40 0464 81 DUP2 0465 10 LT 0466 15 ISZERO 0467 61 PUSH2 0x046f 046A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @045A stack[0] = 0x04a5 // @045D stack[1] = 0x04 // @0461 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x046f, returns to 0x04A5, if !(msg.data.length - 0x04 < 0x40) label_046B: // Incoming jump from 0x046A, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @046E memory[0x00:0x00] } 046B 60 PUSH1 0x00 046D 80 DUP1 046E FD *REVERT // Stack delta = +0 // Outputs[1] { @046E revert(memory[0x00:0x00]); } // Block terminates label_046F: // Incoming call from 0x046A, returns to 0x04A5, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0470 stack[-2] // @0471 stack[-1] // @0475 msg.data[stack[-2]:stack[-2] + 0x20] // @0495 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 046F 5B JUMPDEST 0470 81 DUP2 0471 01 ADD 0472 90 SWAP1 0473 80 DUP1 0474 80 DUP1 0475 35 CALLDATALOAD 0476 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 048B 16 AND 048C 90 SWAP1 048D 60 PUSH1 0x20 048F 01 ADD 0490 90 SWAP1 0491 92 SWAP3 0492 91 SWAP2 0493 90 SWAP1 0494 80 DUP1 0495 35 CALLDATALOAD 0496 90 SWAP1 0497 60 PUSH1 0x20 0499 01 ADD 049A 90 SWAP1 049B 92 SWAP3 049C 91 SWAP2 049D 90 SWAP1 049E 50 POP 049F 50 POP 04A0 50 POP 04A1 61 PUSH2 0x0a69 04A4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0491 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @049B stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0a69 label_04A5: // Incoming return from call to 0x046F at 0x046A 04A5 5B JUMPDEST 04A6 00 *STOP // Stack delta = +0 // Outputs[1] { @04A6 stop(); } // Block terminates label_04A7: // Incoming jump from 0x00AF, if 0x95d89b41 == stack[-1] 04A7 5B JUMPDEST 04A8 61 PUSH2 0x04af 04AB 61 PUSH2 0x0a77 04AE 56 *JUMP // Stack delta = +1 // Outputs[1] { @04A8 stack[0] = 0x04af } // Block ends with call to 0x0a77, returns to 0x04AF label_04AF: // Incoming return from call to 0x0A77 at 0x04AE // Inputs[4] // { // @04B2 memory[0x40:0x60] // @04BD stack[-1] // @04C0 memory[stack[-1]:stack[-1] + 0x20] // @04C9 memory[stack[-1]:stack[-1] + 0x20] // } 04AF 5B JUMPDEST 04B0 60 PUSH1 0x40 04B2 51 MLOAD 04B3 80 DUP1 04B4 80 DUP1 04B5 60 PUSH1 0x20 04B7 01 ADD 04B8 82 DUP3 04B9 81 DUP2 04BA 03 SUB 04BB 82 DUP3 04BC 52 MSTORE 04BD 83 DUP4 04BE 81 DUP2 04BF 81 DUP2 04C0 51 MLOAD 04C1 81 DUP2 04C2 52 MSTORE 04C3 60 PUSH1 0x20 04C5 01 ADD 04C6 91 SWAP2 04C7 50 POP 04C8 80 DUP1 04C9 51 MLOAD 04CA 90 SWAP1 04CB 60 PUSH1 0x20 04CD 01 ADD 04CE 90 SWAP1 04CF 80 DUP1 04D0 83 DUP4 04D1 83 DUP4 04D2 60 PUSH1 0x00 04D4 5B JUMPDEST 04D5 83 DUP4 04D6 81 DUP2 04D7 10 LT 04D8 15 ISZERO 04D9 61 PUSH2 0x04ef 04DC 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @04B2 stack[0] = memory[0x40:0x60] // @04B3 stack[1] = memory[0x40:0x60] // @04BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @04C2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @04C6 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @04CE stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @04CE stack[3] = 0x20 + stack[-1] // @04CF stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @04D0 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @04D1 stack[7] = 0x20 + stack[-1] // @04D2 stack[8] = 0x00 // } // Block ends with conditional jump to 0x04ef, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_04DD: // Incoming jump from 0x04DC, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x04DC, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @04DD stack[-1] // @04DE stack[-2] // @04E0 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @04E2 stack[-3] // } 04DD 80 DUP1 04DE 82 DUP3 04DF 01 ADD 04E0 51 MLOAD 04E1 81 DUP2 04E2 84 DUP5 04E3 01 ADD 04E4 52 MSTORE 04E5 60 PUSH1 0x20 04E7 81 DUP2 04E8 01 ADD 04E9 90 SWAP1 04EA 50 POP 04EB 61 PUSH2 0x04d4 04EE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @04E4 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @04E9 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x04d4 label_04EF: // Incoming jump from 0x04DC, if !(stack[-1] < stack[-4]) // Incoming jump from 0x04DC, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @04F4 stack[-6] // @04F4 stack[-5] // @04F6 stack[-7] // } 04EF 5B JUMPDEST 04F0 50 POP 04F1 50 POP 04F2 50 POP 04F3 50 POP 04F4 90 SWAP1 04F5 50 POP 04F6 90 SWAP1 04F7 81 DUP2 04F8 01 ADD 04F9 90 SWAP1 04FA 60 PUSH1 0x1f 04FC 16 AND 04FD 80 DUP1 04FE 15 ISZERO 04FF 61 PUSH2 0x051c 0502 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @04F9 stack[-7] = stack[-5] + stack[-7] // @04FC stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x051c, if !(0x1f & stack[-5]) label_0503: // Incoming jump from 0x0502, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0503 stack[-1] // @0504 stack[-2] // @0507 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @051E stack[-5] // @0524 memory[0x40:0x60] // @0529 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0503 80 DUP1 0504 82 DUP3 0505 03 SUB 0506 80 DUP1 0507 51 MLOAD 0508 60 PUSH1 0x01 050A 83 DUP4 050B 60 PUSH1 0x20 050D 03 SUB 050E 61 PUSH2 0x0100 0511 0A EXP 0512 03 SUB 0513 19 NOT 0514 16 AND 0515 81 DUP2 0516 52 MSTORE 0517 60 PUSH1 0x20 0519 01 ADD 051A 91 SWAP2 051B 50 POP 051C 5B JUMPDEST 051D 50 POP 051E 92 SWAP3 051F 50 POP 0520 50 POP 0521 50 POP 0522 60 PUSH1 0x40 0524 51 MLOAD 0525 80 DUP1 0526 91 SWAP2 0527 03 SUB 0528 90 SWAP1 0529 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0516 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] // @0529 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_052A: // Incoming jump from 0x00BA, if 0x983b2d56 == stack[-1] // Inputs[1] { @0531 msg.data.length } 052A 5B JUMPDEST 052B 61 PUSH2 0x056c 052E 60 PUSH1 0x04 0530 80 DUP1 0531 36 CALLDATASIZE 0532 03 SUB 0533 60 PUSH1 0x20 0535 81 DUP2 0536 10 LT 0537 15 ISZERO 0538 61 PUSH2 0x0540 053B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @052B stack[0] = 0x056c // @052E stack[1] = 0x04 // @0532 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0540, returns to 0x056C, if !(msg.data.length - 0x04 < 0x20) label_053C: // Incoming jump from 0x053B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @053F memory[0x00:0x00] } 053C 60 PUSH1 0x00 053E 80 DUP1 053F FD *REVERT // Stack delta = +0 // Outputs[1] { @053F revert(memory[0x00:0x00]); } // Block terminates label_0540: // Incoming call from 0x053B, returns to 0x056C, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0541 stack[-2] // @0542 stack[-1] // @0546 msg.data[stack[-2]:stack[-2] + 0x20] // } 0540 5B JUMPDEST 0541 81 DUP2 0542 01 ADD 0543 90 SWAP1 0544 80 DUP1 0545 80 DUP1 0546 35 CALLDATALOAD 0547 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 055C 16 AND 055D 90 SWAP1 055E 60 PUSH1 0x20 0560 01 ADD 0561 90 SWAP1 0562 92 SWAP3 0563 91 SWAP2 0564 90 SWAP1 0565 50 POP 0566 50 POP 0567 50 POP 0568 61 PUSH2 0x0b19 056B 56 *JUMP // Stack delta = -1 // Outputs[1] { @0562 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0b19 label_056C: // Incoming return from call to 0x0540 at 0x053B 056C 5B JUMPDEST 056D 00 *STOP // Stack delta = +0 // Outputs[1] { @056D stop(); } // Block terminates label_056E: // Incoming jump from 0x005D, if 0x98650275 == stack[-1] 056E 5B JUMPDEST 056F 61 PUSH2 0x0576 0572 61 PUSH2 0x0b8c 0575 56 *JUMP // Stack delta = +1 // Outputs[1] { @056F stack[0] = 0x0576 } // Block ends with call to 0x0b8c, returns to 0x0576 label_0576: // Incoming return from call to 0x0B8C at 0x0575 0576 5B JUMPDEST 0577 00 *STOP // Stack delta = +0 // Outputs[1] { @0577 stop(); } // Block terminates label_0578: // Incoming jump from 0x0068, if 0xa457c2d7 == stack[-1] // Inputs[1] { @057F msg.data.length } 0578 5B JUMPDEST 0579 61 PUSH2 0x05c4 057C 60 PUSH1 0x04 057E 80 DUP1 057F 36 CALLDATASIZE 0580 03 SUB 0581 60 PUSH1 0x40 0583 81 DUP2 0584 10 LT 0585 15 ISZERO 0586 61 PUSH2 0x058e 0589 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0579 stack[0] = 0x05c4 // @057C stack[1] = 0x04 // @0580 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x058e, returns to 0x05C4, if !(msg.data.length - 0x04 < 0x40) label_058A: // Incoming jump from 0x0589, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @058D memory[0x00:0x00] } 058A 60 PUSH1 0x00 058C 80 DUP1 058D FD *REVERT // Stack delta = +0 // Outputs[1] { @058D revert(memory[0x00:0x00]); } // Block terminates label_058E: // Incoming call from 0x0589, returns to 0x05C4, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @058F stack[-2] // @0590 stack[-1] // @0594 msg.data[stack[-2]:stack[-2] + 0x20] // @05B4 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 058E 5B JUMPDEST 058F 81 DUP2 0590 01 ADD 0591 90 SWAP1 0592 80 DUP1 0593 80 DUP1 0594 35 CALLDATALOAD 0595 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05AA 16 AND 05AB 90 SWAP1 05AC 60 PUSH1 0x20 05AE 01 ADD 05AF 90 SWAP1 05B0 92 SWAP3 05B1 91 SWAP2 05B2 90 SWAP1 05B3 80 DUP1 05B4 35 CALLDATALOAD 05B5 90 SWAP1 05B6 60 PUSH1 0x20 05B8 01 ADD 05B9 90 SWAP1 05BA 92 SWAP3 05BB 91 SWAP2 05BC 90 SWAP1 05BD 50 POP 05BE 50 POP 05BF 50 POP 05C0 61 PUSH2 0x0b9e 05C3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @05B0 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @05BA stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0b9e label_05C4: // Incoming return from call to 0x058E at 0x0589 // Inputs[4] // { // @05C7 memory[0x40:0x60] // @05C9 stack[-1] // @05D8 memory[0x40:0x60] // @05DD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05C4 5B JUMPDEST 05C5 60 PUSH1 0x40 05C7 51 MLOAD 05C8 80 DUP1 05C9 82 DUP3 05CA 15 ISZERO 05CB 15 ISZERO 05CC 15 ISZERO 05CD 15 ISZERO 05CE 81 DUP2 05CF 52 MSTORE 05D0 60 PUSH1 0x20 05D2 01 ADD 05D3 91 SWAP2 05D4 50 POP 05D5 50 POP 05D6 60 PUSH1 0x40 05D8 51 MLOAD 05D9 80 DUP1 05DA 91 SWAP2 05DB 03 SUB 05DC 90 SWAP1 05DD F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @05DD return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05DE: // Incoming jump from 0x0073, if 0xa9059cbb == stack[-1] // Inputs[1] { @05E5 msg.data.length } 05DE 5B JUMPDEST 05DF 61 PUSH2 0x062a 05E2 60 PUSH1 0x04 05E4 80 DUP1 05E5 36 CALLDATASIZE 05E6 03 SUB 05E7 60 PUSH1 0x40 05E9 81 DUP2 05EA 10 LT 05EB 15 ISZERO 05EC 61 PUSH2 0x05f4 05EF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @05DF stack[0] = 0x062a // @05E2 stack[1] = 0x04 // @05E6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05f4, returns to 0x062A, if !(msg.data.length - 0x04 < 0x40) label_05F0: // Incoming jump from 0x05EF, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @05F3 memory[0x00:0x00] } 05F0 60 PUSH1 0x00 05F2 80 DUP1 05F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F3 revert(memory[0x00:0x00]); } // Block terminates label_05F4: // Incoming call from 0x05EF, returns to 0x062A, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @05F5 stack[-2] // @05F6 stack[-1] // @05FA msg.data[stack[-2]:stack[-2] + 0x20] // @061A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 05F4 5B JUMPDEST 05F5 81 DUP2 05F6 01 ADD 05F7 90 SWAP1 05F8 80 DUP1 05F9 80 DUP1 05FA 35 CALLDATALOAD 05FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0610 16 AND 0611 90 SWAP1 0612 60 PUSH1 0x20 0614 01 ADD 0615 90 SWAP1 0616 92 SWAP3 0617 91 SWAP2 0618 90 SWAP1 0619 80 DUP1 061A 35 CALLDATALOAD 061B 90 SWAP1 061C 60 PUSH1 0x20 061E 01 ADD 061F 90 SWAP1 0620 92 SWAP3 0621 91 SWAP2 0622 90 SWAP1 0623 50 POP 0624 50 POP 0625 50 POP 0626 61 PUSH2 0x0c6c 0629 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0616 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0620 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0c6c label_062A: // Incoming return from call to 0x05F4 at 0x05EF // Inputs[4] // { // @062D memory[0x40:0x60] // @062F stack[-1] // @063E memory[0x40:0x60] // @0643 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 062A 5B JUMPDEST 062B 60 PUSH1 0x40 062D 51 MLOAD 062E 80 DUP1 062F 82 DUP3 0630 15 ISZERO 0631 15 ISZERO 0632 15 ISZERO 0633 15 ISZERO 0634 81 DUP2 0635 52 MSTORE 0636 60 PUSH1 0x20 0638 01 ADD 0639 91 SWAP2 063A 50 POP 063B 50 POP 063C 60 PUSH1 0x40 063E 51 MLOAD 063F 80 DUP1 0640 91 SWAP2 0641 03 SUB 0642 90 SWAP1 0643 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0635 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0643 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0644: // Incoming jump from 0x007E, if 0xaa271e1a == stack[-1] // Inputs[1] { @064B msg.data.length } 0644 5B JUMPDEST 0645 61 PUSH2 0x0686 0648 60 PUSH1 0x04 064A 80 DUP1 064B 36 CALLDATASIZE 064C 03 SUB 064D 60 PUSH1 0x20 064F 81 DUP2 0650 10 LT 0651 15 ISZERO 0652 61 PUSH2 0x065a 0655 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0645 stack[0] = 0x0686 // @0648 stack[1] = 0x04 // @064C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x065a, returns to 0x0686, if !(msg.data.length - 0x04 < 0x20) label_0656: // Incoming jump from 0x0655, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0659 memory[0x00:0x00] } 0656 60 PUSH1 0x00 0658 80 DUP1 0659 FD *REVERT // Stack delta = +0 // Outputs[1] { @0659 revert(memory[0x00:0x00]); } // Block terminates label_065A: // Incoming call from 0x0655, returns to 0x0686, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @065B stack[-2] // @065C stack[-1] // @0660 msg.data[stack[-2]:stack[-2] + 0x20] // } 065A 5B JUMPDEST 065B 81 DUP2 065C 01 ADD 065D 90 SWAP1 065E 80 DUP1 065F 80 DUP1 0660 35 CALLDATALOAD 0661 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0676 16 AND 0677 90 SWAP1 0678 60 PUSH1 0x20 067A 01 ADD 067B 90 SWAP1 067C 92 SWAP3 067D 91 SWAP2 067E 90 SWAP1 067F 50 POP 0680 50 POP 0681 50 POP 0682 61 PUSH2 0x0c8a 0685 56 *JUMP // Stack delta = -1 // Outputs[1] { @067C stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0c8a label_0686: // Incoming return from call to 0x065A at 0x0655 // Inputs[4] // { // @0689 memory[0x40:0x60] // @068B stack[-1] // @069A memory[0x40:0x60] // @069F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0686 5B JUMPDEST 0687 60 PUSH1 0x40 0689 51 MLOAD 068A 80 DUP1 068B 82 DUP3 068C 15 ISZERO 068D 15 ISZERO 068E 15 ISZERO 068F 15 ISZERO 0690 81 DUP2 0691 52 MSTORE 0692 60 PUSH1 0x20 0694 01 ADD 0695 91 SWAP2 0696 50 POP 0697 50 POP 0698 60 PUSH1 0x40 069A 51 MLOAD 069B 80 DUP1 069C 91 SWAP2 069D 03 SUB 069E 90 SWAP1 069F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0691 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @069F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_06A0: // Incoming jump from 0x0089, if 0xdd62ed3e == stack[-1] // Inputs[1] { @06A7 msg.data.length } 06A0 5B JUMPDEST 06A1 61 PUSH2 0x0702 06A4 60 PUSH1 0x04 06A6 80 DUP1 06A7 36 CALLDATASIZE 06A8 03 SUB 06A9 60 PUSH1 0x40 06AB 81 DUP2 06AC 10 LT 06AD 15 ISZERO 06AE 61 PUSH2 0x06b6 06B1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06A1 stack[0] = 0x0702 // @06A4 stack[1] = 0x04 // @06A8 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06b6, returns to 0x0702, if !(msg.data.length - 0x04 < 0x40) label_06B2: // Incoming jump from 0x06B1, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @06B5 memory[0x00:0x00] } 06B2 60 PUSH1 0x00 06B4 80 DUP1 06B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B5 revert(memory[0x00:0x00]); } // Block terminates label_06B6: // Incoming call from 0x06B1, returns to 0x0702, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @06B7 stack[-2] // @06B8 stack[-1] // @06BC msg.data[stack[-2]:stack[-2] + 0x20] // @06DC msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 06B6 5B JUMPDEST 06B7 81 DUP2 06B8 01 ADD 06B9 90 SWAP1 06BA 80 DUP1 06BB 80 DUP1 06BC 35 CALLDATALOAD 06BD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06D2 16 AND 06D3 90 SWAP1 06D4 60 PUSH1 0x20 06D6 01 ADD 06D7 90 SWAP1 06D8 92 SWAP3 06D9 91 SWAP2 06DA 90 SWAP1 06DB 80 DUP1 06DC 35 CALLDATALOAD 06DD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06F2 16 AND 06F3 90 SWAP1 06F4 60 PUSH1 0x20 06F6 01 ADD 06F7 90 SWAP1 06F8 92 SWAP3 06F9 91 SWAP2 06FA 90 SWAP1 06FB 50 POP 06FC 50 POP 06FD 50 POP 06FE 61 PUSH2 0x0ca7 0701 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06D8 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @06F8 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0ca7 label_0702: // Incoming return from call to 0x06B6 at 0x06B1 // Inputs[4] // { // @0705 memory[0x40:0x60] // @0707 stack[-1] // @0712 memory[0x40:0x60] // @0717 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0702 5B JUMPDEST 0703 60 PUSH1 0x40 0705 51 MLOAD 0706 80 DUP1 0707 82 DUP3 0708 81 DUP2 0709 52 MSTORE 070A 60 PUSH1 0x20 070C 01 ADD 070D 91 SWAP2 070E 50 POP 070F 50 POP 0710 60 PUSH1 0x40 0712 51 MLOAD 0713 80 DUP1 0714 91 SWAP2 0715 03 SUB 0716 90 SWAP1 0717 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0709 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0717 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0718: // Incoming call from 0x013F, returns to 0x0140 // Inputs[3] // { // @071E storage[0x05] // @073F memory[0x40:0x60] // @0752 storage[0x05] // } 0718 5B JUMPDEST 0719 60 PUSH1 0x60 071B 60 PUSH1 0x05 071D 80 DUP1 071E 54 SLOAD 071F 60 PUSH1 0x01 0721 81 DUP2 0722 60 PUSH1 0x01 0724 16 AND 0725 15 ISZERO 0726 61 PUSH2 0x0100 0729 02 MUL 072A 03 SUB 072B 16 AND 072C 60 PUSH1 0x02 072E 90 SWAP1 072F 04 DIV 0730 80 DUP1 0731 60 PUSH1 0x1f 0733 01 ADD 0734 60 PUSH1 0x20 0736 80 DUP1 0737 91 SWAP2 0738 04 DIV 0739 02 MUL 073A 60 PUSH1 0x20 073C 01 ADD 073D 60 PUSH1 0x40 073F 51 MLOAD 0740 90 SWAP1 0741 81 DUP2 0742 01 ADD 0743 60 PUSH1 0x40 0745 52 MSTORE 0746 80 DUP1 0747 92 SWAP3 0748 91 SWAP2 0749 90 SWAP1 074A 81 DUP2 074B 81 DUP2 074C 52 MSTORE 074D 60 PUSH1 0x20 074F 01 ADD 0750 82 DUP3 0751 80 DUP1 0752 54 SLOAD 0753 60 PUSH1 0x01 0755 81 DUP2 0756 60 PUSH1 0x01 0758 16 AND 0759 15 ISZERO 075A 61 PUSH2 0x0100 075D 02 MUL 075E 03 SUB 075F 16 AND 0760 60 PUSH1 0x02 0762 90 SWAP1 0763 04 DIV 0764 80 DUP1 0765 15 ISZERO 0766 61 PUSH2 0x07b0 0769 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0719 stack[0] = 0x60 // @0745 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) / 0x20 * 0x20 // @0747 stack[1] = memory[0x40:0x60] // @0748 stack[2] = 0x05 // @0749 stack[3] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // @074C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // @074F stack[4] = 0x20 + memory[0x40:0x60] // @0750 stack[5] = 0x05 // @0763 stack[6] = (0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02 // } // Block ends with conditional jump to 0x07b0, if !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) label_076A: // Incoming jump from 0x0769, if not !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) // Inputs[1] { @076A stack[-1] } 076A 80 DUP1 076B 60 PUSH1 0x1f 076D 10 LT 076E 61 PUSH2 0x0785 0771 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0785, if 0x1f < stack[-1] label_0772: // Incoming jump from 0x0771, if not 0x1f < stack[-1] // Inputs[4] // { // @0776 stack[-2] // @0777 storage[stack[-2]] // @077A stack[-3] // @077C stack[-1] // } 0772 61 PUSH2 0x0100 0775 80 DUP1 0776 83 DUP4 0777 54 SLOAD 0778 04 DIV 0779 02 MUL 077A 83 DUP4 077B 52 MSTORE 077C 91 SWAP2 077D 60 PUSH1 0x20 077F 01 ADD 0780 91 SWAP2 0781 61 PUSH2 0x07b0 0784 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @077B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0780 stack[-1] = stack[-1] // @0780 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07b0 label_0785: // Incoming jump from 0x0771, if 0x1f < stack[-1] // Inputs[5] // { // @0786 stack[-3] // @0787 stack[-1] // @0789 stack[-2] // @0791 memory[0x00:0x20] // @0795 storage[keccak256(memory[0x00:0x20])] // } 0785 5B JUMPDEST 0786 82 DUP3 0787 01 ADD 0788 91 SWAP2 0789 90 SWAP1 078A 60 PUSH1 0x00 078C 52 MSTORE 078D 60 PUSH1 0x20 078F 60 PUSH1 0x00 0791 20 SHA3 0792 90 SWAP1 0793 5B JUMPDEST 0794 81 DUP2 0795 54 SLOAD 0796 81 DUP2 0797 52 MSTORE 0798 90 SWAP1 0799 60 PUSH1 0x01 079B 01 ADD 079C 90 SWAP1 079D 60 PUSH1 0x20 079F 01 ADD 07A0 80 DUP1 07A1 83 DUP4 07A2 11 GT 07A3 61 PUSH2 0x0793 07A6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0788 stack[-3] = stack[-3] + stack[-1] // @078C memory[0x00:0x20] = stack[-2] // @0797 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @079C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @079F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0793, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07A7: // Incoming jump from 0x07A6, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x07A6, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @07A7 stack[-3] // @07A8 stack[-1] // } 07A7 82 DUP3 07A8 90 SWAP1 07A9 03 SUB 07AA 60 PUSH1 0x1f 07AC 16 AND 07AD 82 DUP3 07AE 01 ADD 07AF 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @07AF stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @07AF stack[-1] = stack[-3] // } // Block continues label_07B0: // Incoming jump from 0x07AF // Incoming jump from 0x0784 // Incoming jump from 0x0769, if !((0x0100 * !(0x01 & storage[0x05]) - 0x01 & storage[0x05]) / 0x02) // Inputs[3] // { // @07B6 stack[-7] // @07B6 stack[-6] // @07B8 stack[-8] // } 07B0 5B JUMPDEST 07B1 50 POP 07B2 50 POP 07B3 50 POP 07B4 50 POP 07B5 50 POP 07B6 90 SWAP1 07B7 50 POP 07B8 90 SWAP1 07B9 56 *JUMP // Stack delta = -7 // Outputs[1] { @07B8 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_07BA: // Incoming jump from 0x0206 07BA 5B JUMPDEST 07BB 60 PUSH1 0x00 07BD 61 PUSH2 0x07ce 07C0 61 PUSH2 0x07c7 07C3 61 PUSH2 0x0d2e 07C6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07BB stack[0] = 0x00 // @07BD stack[1] = 0x07ce // @07C0 stack[2] = 0x07c7 // } // Block ends with call to 0x0d2e, returns to 0x07C7 label_07C7: // Incoming return from call to 0x0D2E at 0x07C6 // Inputs[2] // { // @07C8 stack[-5] // @07C9 stack[-4] // } 07C7 5B JUMPDEST 07C8 84 DUP5 07C9 84 DUP5 07CA 61 PUSH2 0x0d36 07CD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07C8 stack[0] = stack[-5] // @07C9 stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x0d36 label_07CE: // Incoming return from call to 0x07C7 at 0x07C6 // Inputs[3] // { // @07D1 stack[-1] // @07D3 stack[-4] // @07D4 stack[-3] // } 07CE 5B JUMPDEST 07CF 60 PUSH1 0x01 07D1 90 SWAP1 07D2 50 POP 07D3 92 SWAP3 07D4 91 SWAP2 07D5 50 POP 07D6 50 POP 07D7 56 *JUMP // Stack delta = -3 // Outputs[1] { @07D3 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_07D8: // Incoming call from 0x1346, returns to 0x1347 // Incoming call from 0x0228, returns to 0x0229 // Inputs[2] // { // @07DD storage[0x02] // @07E0 stack[-1] // } 07D8 5B JUMPDEST 07D9 60 PUSH1 0x00 07DB 60 PUSH1 0x02 07DD 54 SLOAD 07DE 90 SWAP1 07DF 50 POP 07E0 90 SWAP1 07E1 56 *JUMP // Stack delta = +0 // Outputs[1] { @07E0 stack[-1] = storage[0x02] } // Block ends with unconditional jump to stack[-1] label_07E2: // Incoming jump from 0x02AA // Inputs[3] // { // @07E8 stack[-3] // @07E9 stack[-2] // @07EA stack[-1] // } 07E2 5B JUMPDEST 07E3 60 PUSH1 0x00 07E5 61 PUSH2 0x07ef 07E8 84 DUP5 07E9 84 DUP5 07EA 84 DUP5 07EB 61 PUSH2 0x0f31 07EE 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @07E3 stack[0] = 0x00 // @07E5 stack[1] = 0x07ef // @07E8 stack[2] = stack[-3] // @07E9 stack[3] = stack[-2] // @07EA stack[4] = stack[-1] // } // Block ends with call to 0x0f31, returns to 0x07EF label_07EF: // Incoming return from call to 0x0F31 at 0x07EE // Inputs[1] { @07F3 stack[-4] } 07EF 5B JUMPDEST 07F0 61 PUSH2 0x08b1 07F3 84 DUP5 07F4 61 PUSH2 0x07fb 07F7 61 PUSH2 0x0d2e 07FA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07F0 stack[0] = 0x08b1 // @07F3 stack[1] = stack[-4] // @07F4 stack[2] = 0x07fb // } // Block ends with call to 0x0d2e, returns to 0x07FB label_07FB: // Incoming return from call to 0x0D2E at 0x07FA // Inputs[4] // { // @07FF stack[-5] // @0804 memory[0x40:0x60] // @081E stack[-7] // @0858 memory[0x00:0x40] // } 07FB 5B JUMPDEST 07FC 61 PUSH2 0x08ac 07FF 85 DUP6 0800 60 PUSH1 0x60 0802 60 PUSH1 0x40 0804 51 MLOAD 0805 90 SWAP1 0806 81 DUP2 0807 01 ADD 0808 60 PUSH1 0x40 080A 52 MSTORE 080B 80 DUP1 080C 60 PUSH1 0x28 080E 81 DUP2 080F 52 MSTORE 0810 60 PUSH1 0x20 0812 01 ADD 0813 61 PUSH2 0x1c7a 0816 60 PUSH1 0x28 0818 91 SWAP2 0819 39 CODECOPY 081A 60 PUSH1 0x01 081C 60 PUSH1 0x00 081E 8B DUP12 081F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0834 16 AND 0835 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 084A 16 AND 084B 81 DUP2 084C 52 MSTORE 084D 60 PUSH1 0x20 084F 01 ADD 0850 90 SWAP1 0851 81 DUP2 0852 52 MSTORE 0853 60 PUSH1 0x20 0855 01 ADD 0856 60 PUSH1 0x00 0858 20 SHA3 0859 60 PUSH1 0x00 085B 61 PUSH2 0x0862 085E 61 PUSH2 0x0d2e 0861 56 *JUMP // Stack delta = +6 // Outputs[11] // { // @07FC stack[0] = 0x08ac // @07FF stack[1] = stack[-5] // @0805 stack[2] = memory[0x40:0x60] // @080A memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @080F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x28 // @0819 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x28] = code[0x1c7a:0x1ca2] // @084C memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-7] // @0852 memory[0x20:0x40] = 0x01 // @0858 stack[3] = keccak256(memory[0x00:0x40]) // @0859 stack[4] = 0x00 // @085B stack[5] = 0x0862 // } // Block ends with call to 0x0d2e, returns to 0x0862 label_0862: // Incoming return from call to 0x0D2E at 0x0861 // Inputs[7] // { // @0878 stack[-1] // @088F stack[-2] // @0894 stack[-3] // @089C memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @089D storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @08A2 stack[-5] // @08A3 stack[-4] // } 0862 5B JUMPDEST 0863 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0878 16 AND 0879 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 088E 16 AND 088F 81 DUP2 0890 52 MSTORE 0891 60 PUSH1 0x20 0893 01 ADD 0894 90 SWAP1 0895 81 DUP2 0896 52 MSTORE 0897 60 PUSH1 0x20 0899 01 ADD 089A 60 PUSH1 0x00 089C 20 SHA3 089D 54 SLOAD 089E 61 PUSH2 0x11ec 08A1 90 SWAP1 08A2 92 SWAP3 08A3 91 SWAP2 08A4 90 SWAP1 08A5 63 PUSH4 0xffffffff 08AA 16 AND 08AB 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0890 memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0896 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @08A2 stack[-5] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @08A3 stack[-4] = stack[-5] // @08A4 stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0xffffffff & 0x11ec label_08AC: // Incoming return from call to 0x0862 at 0x0861 08AC 5B JUMPDEST 08AD 61 PUSH2 0x0d36 08B0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d36 label_08B1: // Incoming return from call to 0x07FB at 0x07FA // Inputs[3] // { // @08B4 stack[-1] // @08B6 stack[-5] // @08B7 stack[-4] // } 08B1 5B JUMPDEST 08B2 60 PUSH1 0x01 08B4 90 SWAP1 08B5 50 POP 08B6 93 SWAP4 08B7 92 SWAP3 08B8 50 POP 08B9 50 POP 08BA 50 POP 08BB 56 *JUMP // Stack delta = -4 // Outputs[1] { @08B6 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_08BC: // Incoming call from 0x02CC, returns to 0x02CD // Inputs[2] // { // @08C4 storage[0x07] // @08D1 stack[-1] // } 08BC 5B JUMPDEST 08BD 60 PUSH1 0x00 08BF 60 PUSH1 0x07 08C1 60 PUSH1 0x00 08C3 90 SWAP1 08C4 54 SLOAD 08C5 90 SWAP1 08C6 61 PUSH2 0x0100 08C9 0A EXP 08CA 90 SWAP1 08CB 04 DIV 08CC 60 PUSH1 0xff 08CE 16 AND 08CF 90 SWAP1 08D0 50 POP 08D1 90 SWAP1 08D2 56 *JUMP // Stack delta = +0 // Outputs[1] { @08D1 stack[-1] = 0xff & storage[0x07] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_08D3: // Incoming call from 0x02F0, returns to 0x02F1 // Inputs[2] // { // @08D8 storage[0x04] // @08DB stack[-1] // } 08D3 5B JUMPDEST 08D4 60 PUSH1 0x00 08D6 60 PUSH1 0x04 08D8 54 SLOAD 08D9 90 SWAP1 08DA 50 POP 08DB 90 SWAP1 08DC 56 *JUMP // Stack delta = +0 // Outputs[1] { @08DB stack[-1] = storage[0x04] } // Block ends with unconditional jump to stack[-1] label_08DD: // Incoming jump from 0x0352 08DD 5B JUMPDEST 08DE 60 PUSH1 0x00 08E0 61 PUSH2 0x0986 08E3 61 PUSH2 0x08ea 08E6 61 PUSH2 0x0d2e 08E9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08DE stack[0] = 0x00 // @08E0 stack[1] = 0x0986 // @08E3 stack[2] = 0x08ea // } // Block ends with call to 0x0d2e, returns to 0x08EA label_08EA: // Incoming return from call to 0x0D2E at 0x08E9 // Inputs[2] // { // @08EB stack[-5] // @08EF stack[-4] // } 08EA 5B JUMPDEST 08EB 84 DUP5 08EC 61 PUSH2 0x0981 08EF 85 DUP6 08F0 60 PUSH1 0x01 08F2 60 PUSH1 0x00 08F4 61 PUSH2 0x08fb 08F7 61 PUSH2 0x0d2e 08FA 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @08EB stack[0] = stack[-5] // @08EC stack[1] = 0x0981 // @08EF stack[2] = stack[-4] // @08F0 stack[3] = 0x01 // @08F2 stack[4] = 0x00 // @08F4 stack[5] = 0x08fb // } // Block ends with call to 0x0d2e, returns to 0x08FB label_08FB: // Incoming return from call to 0x0D2E at 0x08FA // Inputs[8] // { // @0911 stack[-1] // @0928 stack[-2] // @092D stack[-3] // @0935 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0938 stack[-11] // @0972 memory[0x00:0x40] // @0973 storage[keccak256(memory[0x00:0x40])] // @0978 stack[-4] // } 08FB 5B JUMPDEST 08FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0911 16 AND 0912 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0927 16 AND 0928 81 DUP2 0929 52 MSTORE 092A 60 PUSH1 0x20 092C 01 ADD 092D 90 SWAP1 092E 81 DUP2 092F 52 MSTORE 0930 60 PUSH1 0x20 0932 01 ADD 0933 60 PUSH1 0x00 0935 20 SHA3 0936 60 PUSH1 0x00 0938 89 DUP10 0939 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 094E 16 AND 094F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0964 16 AND 0965 81 DUP2 0966 52 MSTORE 0967 60 PUSH1 0x20 0969 01 ADD 096A 90 SWAP1 096B 81 DUP2 096C 52 MSTORE 096D 60 PUSH1 0x20 096F 01 ADD 0970 60 PUSH1 0x00 0972 20 SHA3 0973 54 SLOAD 0974 61 PUSH2 0x12ae 0977 90 SWAP1 0978 91 SWAP2 0979 90 SWAP1 097A 63 PUSH4 0xffffffff 097F 16 AND 0980 56 *JUMP // Stack delta = -2 // Outputs[6] // { // @0929 memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @092F memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @0966 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-11] // @096C memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @0978 stack[-4] = storage[keccak256(memory[0x00:0x40])] // @0979 stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0xffffffff & 0x12ae label_0981: // Incoming return from call to 0x08FB at 0x08FA 0981 5B JUMPDEST 0982 61 PUSH2 0x0d36 0985 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d36 label_0986: // Incoming return from call to 0x08EA at 0x08E9 // Inputs[3] // { // @0989 stack[-1] // @098B stack[-4] // @098C stack[-3] // } 0986 5B JUMPDEST 0987 60 PUSH1 0x01 0989 90 SWAP1 098A 50 POP 098B 92 SWAP3 098C 91 SWAP2 098D 50 POP 098E 50 POP 098F 56 *JUMP // Stack delta = -3 // Outputs[1] { @098B stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0990: // Incoming jump from 0x03B8 0990 5B JUMPDEST 0991 60 PUSH1 0x00 0993 61 PUSH2 0x09a2 0996 61 PUSH2 0x099d 0999 61 PUSH2 0x0d2e 099C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0991 stack[0] = 0x00 // @0993 stack[1] = 0x09a2 // @0996 stack[2] = 0x099d // } // Block ends with call to 0x0d2e, returns to 0x099D label_099D: // Incoming return from call to 0x0D2E at 0x099C 099D 5B JUMPDEST 099E 61 PUSH2 0x0c8a 09A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c8a label_09A2: // Incoming return from call to 0x099D at 0x099C // Inputs[1] { @09A3 stack[-1] } 09A2 5B JUMPDEST 09A3 15 ISZERO 09A4 15 ISZERO 09A5 61 PUSH2 0x09f9 09A8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09f9, if !!stack[-1] label_09A9: // Incoming jump from 0x09A8, if not !!stack[-1] // Inputs[3] // { // @09AB memory[0x40:0x60] // @09F3 memory[0x40:0x60] // @09F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09A9 60 PUSH1 0x40 09AB 51 MLOAD 09AC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 09CD 81 DUP2 09CE 52 MSTORE 09CF 60 PUSH1 0x04 09D1 01 ADD 09D2 80 DUP1 09D3 80 DUP1 09D4 60 PUSH1 0x20 09D6 01 ADD 09D7 82 DUP3 09D8 81 DUP2 09D9 03 SUB 09DA 82 DUP3 09DB 52 MSTORE 09DC 60 PUSH1 0x30 09DE 81 DUP2 09DF 52 MSTORE 09E0 60 PUSH1 0x20 09E2 01 ADD 09E3 80 DUP1 09E4 61 PUSH2 0x1c29 09E7 60 PUSH1 0x30 09E9 91 SWAP2 09EA 39 CODECOPY 09EB 60 PUSH1 0x40 09ED 01 ADD 09EE 91 SWAP2 09EF 50 POP 09F0 50 POP 09F1 60 PUSH1 0x40 09F3 51 MLOAD 09F4 80 DUP1 09F5 91 SWAP2 09F6 03 SUB 09F7 90 SWAP1 09F8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @09CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @09DB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @09DF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x30 // @09EA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x30] = code[0x1c29:0x1c59] // @09F8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09F9: // Incoming jump from 0x09A8, if !!stack[-1] // Inputs[2] // { // @09FD stack[-3] // @09FE stack[-2] // } 09F9 5B JUMPDEST 09FA 61 PUSH2 0x0a03 09FD 83 DUP4 09FE 83 DUP4 09FF 61 PUSH2 0x1338 0A02 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09FA stack[0] = 0x0a03 // @09FD stack[1] = stack[-3] // @09FE stack[2] = stack[-2] // } // Block ends with call to 0x1338, returns to 0x0A03 label_0A03: // Incoming return from call to 0x1338 at 0x0A02 // Inputs[3] // { // @0A06 stack[-1] // @0A08 stack[-4] // @0A09 stack[-3] // } 0A03 5B JUMPDEST 0A04 60 PUSH1 0x01 0A06 90 SWAP1 0A07 50 POP 0A08 92 SWAP3 0A09 91 SWAP2 0A0A 50 POP 0A0B 50 POP 0A0C 56 *JUMP // Stack delta = -3 // Outputs[1] { @0A08 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0A0D: // Incoming jump from 0x03FE 0A0D 5B JUMPDEST 0A0E 61 PUSH2 0x0a1e 0A11 61 PUSH2 0x0a18 0A14 61 PUSH2 0x0d2e 0A17 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A0E stack[0] = 0x0a1e // @0A11 stack[1] = 0x0a18 // } // Block ends with call to 0x0d2e, returns to 0x0A18 label_0A18: // Incoming return from call to 0x0D2E at 0x0A17 // Inputs[1] { @0A19 stack[-3] } 0A18 5B JUMPDEST 0A19 82 DUP3 0A1A 61 PUSH2 0x13d9 0A1D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A19 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x13d9 label_0A1E: // Incoming return from call to 0x0A18 at 0x0A17 // Inputs[1] { @0A20 stack[-2] } 0A1E 5B JUMPDEST 0A1F 50 POP 0A20 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A21: // Incoming jump from 0x0442 // Inputs[4] // { // @0A27 stack[-1] // @0A61 memory[0x00:0x40] // @0A62 storage[keccak256(memory[0x00:0x40])] // @0A65 stack[-2] // } 0A21 5B JUMPDEST 0A22 60 PUSH1 0x00 0A24 80 DUP1 0A25 60 PUSH1 0x00 0A27 83 DUP4 0A28 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A3D 16 AND 0A3E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A53 16 AND 0A54 81 DUP2 0A55 52 MSTORE 0A56 60 PUSH1 0x20 0A58 01 ADD 0A59 90 SWAP1 0A5A 81 DUP2 0A5B 52 MSTORE 0A5C 60 PUSH1 0x20 0A5E 01 ADD 0A5F 60 PUSH1 0x00 0A61 20 SHA3 0A62 54 SLOAD 0A63 90 SWAP1 0A64 50 POP 0A65 91 SWAP2 0A66 90 SWAP1 0A67 50 POP 0A68 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0A55 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A5B memory[0x20:0x40] = 0x00 // @0A65 stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0A69: // Incoming jump from 0x04A4 // Inputs[2] // { // @0A6D stack[-2] // @0A6E stack[-1] // } 0A69 5B JUMPDEST 0A6A 61 PUSH2 0x0a73 0A6D 82 DUP3 0A6E 82 DUP3 0A6F 61 PUSH2 0x1594 0A72 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A6A stack[0] = 0x0a73 // @0A6D stack[1] = stack[-2] // @0A6E stack[2] = stack[-1] // } // Block ends with call to 0x1594, returns to 0x0A73 label_0A73: // Incoming return from call to 0x1594 at 0x0A72 // Inputs[1] { @0A76 stack[-3] } 0A73 5B JUMPDEST 0A74 50 POP 0A75 50 POP 0A76 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0A77: // Incoming call from 0x04AE, returns to 0x04AF // Inputs[3] // { // @0A7D storage[0x06] // @0A9E memory[0x40:0x60] // @0AB1 storage[0x06] // } 0A77 5B JUMPDEST 0A78 60 PUSH1 0x60 0A7A 60 PUSH1 0x06 0A7C 80 DUP1 0A7D 54 SLOAD 0A7E 60 PUSH1 0x01 0A80 81 DUP2 0A81 60 PUSH1 0x01 0A83 16 AND 0A84 15 ISZERO 0A85 61 PUSH2 0x0100 0A88 02 MUL 0A89 03 SUB 0A8A 16 AND 0A8B 60 PUSH1 0x02 0A8D 90 SWAP1 0A8E 04 DIV 0A8F 80 DUP1 0A90 60 PUSH1 0x1f 0A92 01 ADD 0A93 60 PUSH1 0x20 0A95 80 DUP1 0A96 91 SWAP2 0A97 04 DIV 0A98 02 MUL 0A99 60 PUSH1 0x20 0A9B 01 ADD 0A9C 60 PUSH1 0x40 0A9E 51 MLOAD 0A9F 90 SWAP1 0AA0 81 DUP2 0AA1 01 ADD 0AA2 60 PUSH1 0x40 0AA4 52 MSTORE 0AA5 80 DUP1 0AA6 92 SWAP3 0AA7 91 SWAP2 0AA8 90 SWAP1 0AA9 81 DUP2 0AAA 81 DUP2 0AAB 52 MSTORE 0AAC 60 PUSH1 0x20 0AAE 01 ADD 0AAF 82 DUP3 0AB0 80 DUP1 0AB1 54 SLOAD 0AB2 60 PUSH1 0x01 0AB4 81 DUP2 0AB5 60 PUSH1 0x01 0AB7 16 AND 0AB8 15 ISZERO 0AB9 61 PUSH2 0x0100 0ABC 02 MUL 0ABD 03 SUB 0ABE 16 AND 0ABF 60 PUSH1 0x02 0AC1 90 SWAP1 0AC2 04 DIV 0AC3 80 DUP1 0AC4 15 ISZERO 0AC5 61 PUSH2 0x0b0f 0AC8 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @0A78 stack[0] = 0x60 // @0AA4 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) / 0x20 * 0x20 // @0AA6 stack[1] = memory[0x40:0x60] // @0AA7 stack[2] = 0x06 // @0AA8 stack[3] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // @0AAB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // @0AAE stack[4] = 0x20 + memory[0x40:0x60] // @0AAF stack[5] = 0x06 // @0AC2 stack[6] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // } // Block ends with conditional jump to 0x0b0f, if !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) label_0AC9: // Incoming jump from 0x0AC8, if not !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) // Inputs[1] { @0AC9 stack[-1] } 0AC9 80 DUP1 0ACA 60 PUSH1 0x1f 0ACC 10 LT 0ACD 61 PUSH2 0x0ae4 0AD0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ae4, if 0x1f < stack[-1] label_0AD1: // Incoming jump from 0x0AD0, if not 0x1f < stack[-1] // Inputs[4] // { // @0AD5 stack[-2] // @0AD6 storage[stack[-2]] // @0AD9 stack[-3] // @0ADB stack[-1] // } 0AD1 61 PUSH2 0x0100 0AD4 80 DUP1 0AD5 83 DUP4 0AD6 54 SLOAD 0AD7 04 DIV 0AD8 02 MUL 0AD9 83 DUP4 0ADA 52 MSTORE 0ADB 91 SWAP2 0ADC 60 PUSH1 0x20 0ADE 01 ADD 0ADF 91 SWAP2 0AE0 61 PUSH2 0x0b0f 0AE3 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0ADA memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0ADF stack[-1] = stack[-1] // @0ADF stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b0f label_0AE4: // Incoming jump from 0x0AD0, if 0x1f < stack[-1] // Inputs[5] // { // @0AE5 stack[-3] // @0AE6 stack[-1] // @0AE8 stack[-2] // @0AF0 memory[0x00:0x20] // @0AF4 storage[keccak256(memory[0x00:0x20])] // } 0AE4 5B JUMPDEST 0AE5 82 DUP3 0AE6 01 ADD 0AE7 91 SWAP2 0AE8 90 SWAP1 0AE9 60 PUSH1 0x00 0AEB 52 MSTORE 0AEC 60 PUSH1 0x20 0AEE 60 PUSH1 0x00 0AF0 20 SHA3 0AF1 90 SWAP1 0AF2 5B JUMPDEST 0AF3 81 DUP2 0AF4 54 SLOAD 0AF5 81 DUP2 0AF6 52 MSTORE 0AF7 90 SWAP1 0AF8 60 PUSH1 0x01 0AFA 01 ADD 0AFB 90 SWAP1 0AFC 60 PUSH1 0x20 0AFE 01 ADD 0AFF 80 DUP1 0B00 83 DUP4 0B01 11 GT 0B02 61 PUSH2 0x0af2 0B05 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0AE7 stack[-3] = stack[-3] + stack[-1] // @0AEB memory[0x00:0x20] = stack[-2] // @0AF6 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0AFB stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0AFE stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0af2, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B06: // Incoming jump from 0x0B05, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0B05, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0B06 stack[-3] // @0B07 stack[-1] // } 0B06 82 DUP3 0B07 90 SWAP1 0B08 03 SUB 0B09 60 PUSH1 0x1f 0B0B 16 AND 0B0C 82 DUP3 0B0D 01 ADD 0B0E 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B0E stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B0E stack[-1] = stack[-3] // } // Block continues label_0B0F: // Incoming jump from 0x0B0E // Incoming jump from 0x0AC8, if !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) // Incoming jump from 0x0AE3 // Inputs[3] // { // @0B15 stack[-6] // @0B15 stack[-7] // @0B17 stack[-8] // } 0B0F 5B JUMPDEST 0B10 50 POP 0B11 50 POP 0B12 50 POP 0B13 50 POP 0B14 50 POP 0B15 90 SWAP1 0B16 50 POP 0B17 90 SWAP1 0B18 56 *JUMP // Stack delta = -7 // Outputs[1] { @0B17 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0B19: // Incoming jump from 0x056B 0B19 5B JUMPDEST 0B1A 61 PUSH2 0x0b29 0B1D 61 PUSH2 0x0b24 0B20 61 PUSH2 0x0d2e 0B23 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B1A stack[0] = 0x0b29 // @0B1D stack[1] = 0x0b24 // } // Block ends with call to 0x0d2e, returns to 0x0B24 label_0B24: // Incoming return from call to 0x0D2E at 0x0B23 0B24 5B JUMPDEST 0B25 61 PUSH2 0x0c8a 0B28 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c8a label_0B29: // Incoming return from call to 0x0B24 at 0x0B23 // Inputs[1] { @0B2A stack[-1] } 0B29 5B JUMPDEST 0B2A 15 ISZERO 0B2B 15 ISZERO 0B2C 61 PUSH2 0x0b80 0B2F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b80, if !!stack[-1] label_0B30: // Incoming jump from 0x0B2F, if not !!stack[-1] // Inputs[3] // { // @0B32 memory[0x40:0x60] // @0B7A memory[0x40:0x60] // @0B7F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B30 60 PUSH1 0x40 0B32 51 MLOAD 0B33 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0B54 81 DUP2 0B55 52 MSTORE 0B56 60 PUSH1 0x04 0B58 01 ADD 0B59 80 DUP1 0B5A 80 DUP1 0B5B 60 PUSH1 0x20 0B5D 01 ADD 0B5E 82 DUP3 0B5F 81 DUP2 0B60 03 SUB 0B61 82 DUP3 0B62 52 MSTORE 0B63 60 PUSH1 0x30 0B65 81 DUP2 0B66 52 MSTORE 0B67 60 PUSH1 0x20 0B69 01 ADD 0B6A 80 DUP1 0B6B 61 PUSH2 0x1c29 0B6E 60 PUSH1 0x30 0B70 91 SWAP2 0B71 39 CODECOPY 0B72 60 PUSH1 0x40 0B74 01 ADD 0B75 91 SWAP2 0B76 50 POP 0B77 50 POP 0B78 60 PUSH1 0x40 0B7A 51 MLOAD 0B7B 80 DUP1 0B7C 91 SWAP2 0B7D 03 SUB 0B7E 90 SWAP1 0B7F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0B62 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0B66 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x30 // @0B71 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x30] = code[0x1c29:0x1c59] // @0B7F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0B80: // Incoming jump from 0x0B2F, if !!stack[-1] // Inputs[1] { @0B84 stack[-1] } 0B80 5B JUMPDEST 0B81 61 PUSH2 0x0b89 0B84 81 DUP2 0B85 61 PUSH2 0x1664 0B88 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B81 stack[0] = 0x0b89 // @0B84 stack[1] = stack[-1] // } // Block ends with call to 0x1664, returns to 0x0B89 label_0B89: // Incoming return from call to 0x1664 at 0x0B88 // Inputs[1] { @0B8B stack[-2] } 0B89 5B JUMPDEST 0B8A 50 POP 0B8B 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0B8C: // Incoming call from 0x0575, returns to 0x0576 0B8C 5B JUMPDEST 0B8D 61 PUSH2 0x0b9c 0B90 61 PUSH2 0x0b97 0B93 61 PUSH2 0x0d2e 0B96 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B8D stack[0] = 0x0b9c // @0B90 stack[1] = 0x0b97 // } // Block ends with call to 0x0d2e, returns to 0x0B97 label_0B97: // Incoming return from call to 0x0D2E at 0x0B96 0B97 5B JUMPDEST 0B98 61 PUSH2 0x16be 0B9B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x16be label_0B9C: // Incoming return from call to 0x0B97 at 0x0B96 // Inputs[1] { @0B9D stack[-1] } 0B9C 5B JUMPDEST 0B9D 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0B9E: // Incoming jump from 0x05C3 0B9E 5B JUMPDEST 0B9F 60 PUSH1 0x00 0BA1 61 PUSH2 0x0c62 0BA4 61 PUSH2 0x0bab 0BA7 61 PUSH2 0x0d2e 0BAA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B9F stack[0] = 0x00 // @0BA1 stack[1] = 0x0c62 // @0BA4 stack[2] = 0x0bab // } // Block ends with call to 0x0d2e, returns to 0x0BAB label_0BAB: // Incoming return from call to 0x0D2E at 0x0BAA // Inputs[3] // { // @0BAC stack[-5] // @0BB0 stack[-4] // @0BB5 memory[0x40:0x60] // } 0BAB 5B JUMPDEST 0BAC 84 DUP5 0BAD 61 PUSH2 0x0c5d 0BB0 85 DUP6 0BB1 60 PUSH1 0x60 0BB3 60 PUSH1 0x40 0BB5 51 MLOAD 0BB6 90 SWAP1 0BB7 81 DUP2 0BB8 01 ADD 0BB9 60 PUSH1 0x40 0BBB 52 MSTORE 0BBC 80 DUP1 0BBD 60 PUSH1 0x25 0BBF 81 DUP2 0BC0 52 MSTORE 0BC1 60 PUSH1 0x20 0BC3 01 ADD 0BC4 61 PUSH2 0x1d52 0BC7 60 PUSH1 0x25 0BC9 91 SWAP2 0BCA 39 CODECOPY 0BCB 60 PUSH1 0x01 0BCD 60 PUSH1 0x00 0BCF 61 PUSH2 0x0bd6 0BD2 61 PUSH2 0x0d2e 0BD5 56 *JUMP // Stack delta = +7 // Outputs[10] // { // @0BAC stack[0] = stack[-5] // @0BAD stack[1] = 0x0c5d // @0BB0 stack[2] = stack[-4] // @0BB6 stack[3] = memory[0x40:0x60] // @0BBB memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0BC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x25 // @0BCA memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x25] = code[0x1d52:0x1d77] // @0BCB stack[4] = 0x01 // @0BCD stack[5] = 0x00 // @0BCF stack[6] = 0x0bd6 // } // Block ends with call to 0x0d2e, returns to 0x0BD6 label_0BD6: // Incoming return from call to 0x0D2E at 0x0BD5 // Inputs[9] // { // @0BEC stack[-1] // @0C03 stack[-2] // @0C08 stack[-3] // @0C10 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @0C13 stack[-12] // @0C4D memory[0x00:0x40] // @0C4E storage[keccak256(memory[0x00:0x40])] // @0C53 stack[-5] // @0C54 stack[-4] // } 0BD6 5B JUMPDEST 0BD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BEC 16 AND 0BED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C02 16 AND 0C03 81 DUP2 0C04 52 MSTORE 0C05 60 PUSH1 0x20 0C07 01 ADD 0C08 90 SWAP1 0C09 81 DUP2 0C0A 52 MSTORE 0C0B 60 PUSH1 0x20 0C0D 01 ADD 0C0E 60 PUSH1 0x00 0C10 20 SHA3 0C11 60 PUSH1 0x00 0C13 8A DUP11 0C14 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C29 16 AND 0C2A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C3F 16 AND 0C40 81 DUP2 0C41 52 MSTORE 0C42 60 PUSH1 0x20 0C44 01 ADD 0C45 90 SWAP1 0C46 81 DUP2 0C47 52 MSTORE 0C48 60 PUSH1 0x20 0C4A 01 ADD 0C4B 60 PUSH1 0x00 0C4D 20 SHA3 0C4E 54 SLOAD 0C4F 61 PUSH2 0x11ec 0C52 90 SWAP1 0C53 92 SWAP3 0C54 91 SWAP2 0C55 90 SWAP1 0C56 63 PUSH4 0xffffffff 0C5B 16 AND 0C5C 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @0C04 memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0C0A memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @0C41 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-12] // @0C47 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @0C53 stack[-5] = storage[keccak256(memory[0x00:0x40])] // @0C54 stack[-4] = stack[-5] // @0C55 stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0xffffffff & 0x11ec label_0C5D: // Incoming return from call to 0x0BD6 at 0x0BD5 0C5D 5B JUMPDEST 0C5E 61 PUSH2 0x0d36 0C61 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d36 label_0C62: // Incoming return from call to 0x0BAB at 0x0BAA // Inputs[3] // { // @0C65 stack[-1] // @0C67 stack[-4] // @0C68 stack[-3] // } 0C62 5B JUMPDEST 0C63 60 PUSH1 0x01 0C65 90 SWAP1 0C66 50 POP 0C67 92 SWAP3 0C68 91 SWAP2 0C69 50 POP 0C6A 50 POP 0C6B 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C67 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0C6C: // Incoming jump from 0x0629 0C6C 5B JUMPDEST 0C6D 60 PUSH1 0x00 0C6F 61 PUSH2 0x0c80 0C72 61 PUSH2 0x0c79 0C75 61 PUSH2 0x0d2e 0C78 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C6D stack[0] = 0x00 // @0C6F stack[1] = 0x0c80 // @0C72 stack[2] = 0x0c79 // } // Block ends with call to 0x0d2e, returns to 0x0C79 label_0C79: // Incoming return from call to 0x0D2E at 0x0C78 // Inputs[2] // { // @0C7A stack[-5] // @0C7B stack[-4] // } 0C79 5B JUMPDEST 0C7A 84 DUP5 0C7B 84 DUP5 0C7C 61 PUSH2 0x0f31 0C7F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C7A stack[0] = stack[-5] // @0C7B stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x0f31 label_0C80: // Incoming return from call to 0x0C79 at 0x0C78 // Inputs[3] // { // @0C83 stack[-1] // @0C85 stack[-4] // @0C86 stack[-3] // } 0C80 5B JUMPDEST 0C81 60 PUSH1 0x01 0C83 90 SWAP1 0C84 50 POP 0C85 92 SWAP3 0C86 91 SWAP2 0C87 50 POP 0C88 50 POP 0C89 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C85 stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0C8A: // Incoming jump from 0x0B28 // Incoming jump from 0x09A1 // Incoming jump from 0x0685 // Inputs[1] { @0C90 stack[-1] } 0C8A 5B JUMPDEST 0C8B 60 PUSH1 0x00 0C8D 61 PUSH2 0x0ca0 0C90 82 DUP3 0C91 60 PUSH1 0x03 0C93 61 PUSH2 0x1718 0C96 90 SWAP1 0C97 91 SWAP2 0C98 90 SWAP1 0C99 63 PUSH4 0xffffffff 0C9E 16 AND 0C9F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C8B stack[0] = 0x00 // @0C8D stack[1] = 0x0ca0 // @0C97 stack[2] = 0x03 // @0C98 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x1718, returns to 0x0CA0 label_0CA0: // Incoming return from call to 0x1718 at 0x0C9F // Inputs[4] // { // @0CA1 stack[-1] // @0CA1 stack[-2] // @0CA3 stack[-4] // @0CA4 stack[-3] // } 0CA0 5B JUMPDEST 0CA1 90 SWAP1 0CA2 50 POP 0CA3 91 SWAP2 0CA4 90 SWAP1 0CA5 50 POP 0CA6 56 *JUMP // Stack delta = -3 // Outputs[1] { @0CA3 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0CA7: // Incoming jump from 0x0701 // Inputs[6] // { // @0CAE stack[-2] // @0CE8 memory[0x00:0x40] // @0CEB stack[-1] // @0D25 memory[0x00:0x40] // @0D26 storage[keccak256(memory[0x00:0x40])] // @0D29 stack[-3] // } 0CA7 5B JUMPDEST 0CA8 60 PUSH1 0x00 0CAA 60 PUSH1 0x01 0CAC 60 PUSH1 0x00 0CAE 84 DUP5 0CAF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CC4 16 AND 0CC5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CDA 16 AND 0CDB 81 DUP2 0CDC 52 MSTORE 0CDD 60 PUSH1 0x20 0CDF 01 ADD 0CE0 90 SWAP1 0CE1 81 DUP2 0CE2 52 MSTORE 0CE3 60 PUSH1 0x20 0CE5 01 ADD 0CE6 60 PUSH1 0x00 0CE8 20 SHA3 0CE9 60 PUSH1 0x00 0CEB 83 DUP4 0CEC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D01 16 AND 0D02 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D17 16 AND 0D18 81 DUP2 0D19 52 MSTORE 0D1A 60 PUSH1 0x20 0D1C 01 ADD 0D1D 90 SWAP1 0D1E 81 DUP2 0D1F 52 MSTORE 0D20 60 PUSH1 0x20 0D22 01 ADD 0D23 60 PUSH1 0x00 0D25 20 SHA3 0D26 54 SLOAD 0D27 90 SWAP1 0D28 50 POP 0D29 92 SWAP3 0D2A 91 SWAP2 0D2B 50 POP 0D2C 50 POP 0D2D 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0CDC memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0CE2 memory[0x20:0x40] = 0x01 // @0D19 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0D1F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0D29 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0D2E: // Incoming call from 0x0B96, returns to 0x0B97 // Incoming call from 0x15A9, returns to 0x15AA // Incoming call from 0x0BD5, returns to 0x0BD6 // Incoming call from 0x1610, returns to 0x1611 // Incoming call from 0x099C, returns to 0x099D // Incoming call from 0x07C6, returns to 0x07C7 // Incoming call from 0x0861, returns to 0x0862 // Incoming call from 0x08E9, returns to 0x08EA // Incoming call from 0x0B23, returns to 0x0B24 // Incoming call from 0x07FA, returns to 0x07FB // Incoming call from 0x0C78, returns to 0x0C79 // Incoming call from 0x0A17, returns to 0x0A18 // Incoming call from 0x0BAA, returns to 0x0BAB // Incoming call from 0x08FA, returns to 0x08FB // Inputs[2] // { // @0D31 msg.sender // @0D34 stack[-1] // } 0D2E 5B JUMPDEST 0D2F 60 PUSH1 0x00 0D31 33 CALLER 0D32 90 SWAP1 0D33 50 POP 0D34 90 SWAP1 0D35 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D34 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_0D36: // Incoming jump from 0x0985 // Incoming jump from 0x07CD // Incoming jump from 0x08B0 // Incoming jump from 0x0C61 // Incoming jump from 0x165F // Inputs[1] { @0D4F stack[-3] } 0D36 5B JUMPDEST 0D37 60 PUSH1 0x00 0D39 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D4E 16 AND 0D4F 83 DUP4 0D50 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D65 16 AND 0D66 14 EQ 0D67 15 ISZERO 0D68 15 ISZERO 0D69 15 ISZERO 0D6A 61 PUSH2 0x0dbe 0D6D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dbe, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0D6E: // Incoming jump from 0x0D6D, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @0D70 memory[0x40:0x60] // @0DB8 memory[0x40:0x60] // @0DBD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D6E 60 PUSH1 0x40 0D70 51 MLOAD 0D71 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0D92 81 DUP2 0D93 52 MSTORE 0D94 60 PUSH1 0x04 0D96 01 ADD 0D97 80 DUP1 0D98 80 DUP1 0D99 60 PUSH1 0x20 0D9B 01 ADD 0D9C 82 DUP3 0D9D 81 DUP2 0D9E 03 SUB 0D9F 82 DUP3 0DA0 52 MSTORE 0DA1 60 PUSH1 0x24 0DA3 81 DUP2 0DA4 52 MSTORE 0DA5 60 PUSH1 0x20 0DA7 01 ADD 0DA8 80 DUP1 0DA9 61 PUSH2 0x1d2e 0DAC 60 PUSH1 0x24 0DAE 91 SWAP2 0DAF 39 CODECOPY 0DB0 60 PUSH1 0x40 0DB2 01 ADD 0DB3 91 SWAP2 0DB4 50 POP 0DB5 50 POP 0DB6 60 PUSH1 0x40 0DB8 51 MLOAD 0DB9 80 DUP1 0DBA 91 SWAP2 0DBB 03 SUB 0DBC 90 SWAP1 0DBD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0D93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0DA0 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0DA4 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @0DAF memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x1d2e:0x1d52] // @0DBD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0DBE: // Incoming jump from 0x0D6D, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0DD7 stack[-2] } 0DBE 5B JUMPDEST 0DBF 60 PUSH1 0x00 0DC1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DD6 16 AND 0DD7 82 DUP3 0DD8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DED 16 AND 0DEE 14 EQ 0DEF 15 ISZERO 0DF0 15 ISZERO 0DF1 15 ISZERO 0DF2 61 PUSH2 0x0e46 0DF5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e46, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0DF6: // Incoming jump from 0x0DF5, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @0DF8 memory[0x40:0x60] // @0E40 memory[0x40:0x60] // @0E45 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DF6 60 PUSH1 0x40 0DF8 51 MLOAD 0DF9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0E1A 81 DUP2 0E1B 52 MSTORE 0E1C 60 PUSH1 0x04 0E1E 01 ADD 0E1F 80 DUP1 0E20 80 DUP1 0E21 60 PUSH1 0x20 0E23 01 ADD 0E24 82 DUP3 0E25 81 DUP2 0E26 03 SUB 0E27 82 DUP3 0E28 52 MSTORE 0E29 60 PUSH1 0x22 0E2B 81 DUP2 0E2C 52 MSTORE 0E2D 60 PUSH1 0x20 0E2F 01 ADD 0E30 80 DUP1 0E31 61 PUSH2 0x1be1 0E34 60 PUSH1 0x22 0E36 91 SWAP2 0E37 39 CODECOPY 0E38 60 PUSH1 0x40 0E3A 01 ADD 0E3B 91 SWAP2 0E3C 50 POP 0E3D 50 POP 0E3E 60 PUSH1 0x40 0E40 51 MLOAD 0E41 80 DUP1 0E42 91 SWAP2 0E43 03 SUB 0E44 90 SWAP1 0E45 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E28 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0E2C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @0E37 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x1be1:0x1c03] // @0E45 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E46: // Incoming jump from 0x0DF5, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[9] // { // @0E47 stack[-1] // @0E4C stack[-3] // @0E86 memory[0x00:0x40] // @0E89 stack[-2] // @0EC3 memory[0x00:0x40] // @0F1A memory[0x40:0x60] // @0F27 memory[0x40:0x60] // @0F2C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0F30 stack[-4] // } 0E46 5B JUMPDEST 0E47 80 DUP1 0E48 60 PUSH1 0x01 0E4A 60 PUSH1 0x00 0E4C 85 DUP6 0E4D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E62 16 AND 0E63 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E78 16 AND 0E79 81 DUP2 0E7A 52 MSTORE 0E7B 60 PUSH1 0x20 0E7D 01 ADD 0E7E 90 SWAP1 0E7F 81 DUP2 0E80 52 MSTORE 0E81 60 PUSH1 0x20 0E83 01 ADD 0E84 60 PUSH1 0x00 0E86 20 SHA3 0E87 60 PUSH1 0x00 0E89 84 DUP5 0E8A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E9F 16 AND 0EA0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EB5 16 AND 0EB6 81 DUP2 0EB7 52 MSTORE 0EB8 60 PUSH1 0x20 0EBA 01 ADD 0EBB 90 SWAP1 0EBC 81 DUP2 0EBD 52 MSTORE 0EBE 60 PUSH1 0x20 0EC0 01 ADD 0EC1 60 PUSH1 0x00 0EC3 20 SHA3 0EC4 81 DUP2 0EC5 90 SWAP1 0EC6 55 SSTORE 0EC7 50 POP 0EC8 81 DUP2 0EC9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EDE 16 AND 0EDF 83 DUP4 0EE0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EF5 16 AND 0EF6 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0F17 83 DUP4 0F18 60 PUSH1 0x40 0F1A 51 MLOAD 0F1B 80 DUP1 0F1C 82 DUP3 0F1D 81 DUP2 0F1E 52 MSTORE 0F1F 60 PUSH1 0x20 0F21 01 ADD 0F22 91 SWAP2 0F23 50 POP 0F24 50 POP 0F25 60 PUSH1 0x40 0F27 51 MLOAD 0F28 80 DUP1 0F29 91 SWAP2 0F2A 03 SUB 0F2B 90 SWAP1 0F2C A3 LOG3 0F2D 50 POP 0F2E 50 POP 0F2F 50 POP 0F30 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @0E7A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @0E80 memory[0x20:0x40] = 0x01 // @0EB7 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0EBD memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0EC6 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0F1E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0F2C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_0F31: // Incoming call from 0x07EE, returns to 0x07EF // Incoming jump from 0x0C7F // Inputs[1] { @0F4A stack[-3] } 0F31 5B JUMPDEST 0F32 60 PUSH1 0x00 0F34 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F49 16 AND 0F4A 83 DUP4 0F4B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F60 16 AND 0F61 14 EQ 0F62 15 ISZERO 0F63 15 ISZERO 0F64 15 ISZERO 0F65 61 PUSH2 0x0fb9 0F68 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fb9, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0F69: // Incoming jump from 0x0F68, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @0F6B memory[0x40:0x60] // @0FB3 memory[0x40:0x60] // @0FB8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F69 60 PUSH1 0x40 0F6B 51 MLOAD 0F6C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0F8D 81 DUP2 0F8E 52 MSTORE 0F8F 60 PUSH1 0x04 0F91 01 ADD 0F92 80 DUP1 0F93 80 DUP1 0F94 60 PUSH1 0x20 0F96 01 ADD 0F97 82 DUP3 0F98 81 DUP2 0F99 03 SUB 0F9A 82 DUP3 0F9B 52 MSTORE 0F9C 60 PUSH1 0x25 0F9E 81 DUP2 0F9F 52 MSTORE 0FA0 60 PUSH1 0x20 0FA2 01 ADD 0FA3 80 DUP1 0FA4 61 PUSH2 0x1d09 0FA7 60 PUSH1 0x25 0FA9 91 SWAP2 0FAA 39 CODECOPY 0FAB 60 PUSH1 0x40 0FAD 01 ADD 0FAE 91 SWAP2 0FAF 50 POP 0FB0 50 POP 0FB1 60 PUSH1 0x40 0FB3 51 MLOAD 0FB4 80 DUP1 0FB5 91 SWAP2 0FB6 03 SUB 0FB7 90 SWAP1 0FB8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F8E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F9B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0F9F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @0FAA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x1d09:0x1d2e] // @0FB8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0FB9: // Incoming jump from 0x0F68, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @0FD2 stack[-2] } 0FB9 5B JUMPDEST 0FBA 60 PUSH1 0x00 0FBC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FD1 16 AND 0FD2 82 DUP3 0FD3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0FE8 16 AND 0FE9 14 EQ 0FEA 15 ISZERO 0FEB 15 ISZERO 0FEC 15 ISZERO 0FED 61 PUSH2 0x1041 0FF0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1041, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_0FF1: // Incoming jump from 0x0FF0, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @0FF3 memory[0x40:0x60] // @103B memory[0x40:0x60] // @1040 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FF1 60 PUSH1 0x40 0FF3 51 MLOAD 0FF4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1015 81 DUP2 1016 52 MSTORE 1017 60 PUSH1 0x04 1019 01 ADD 101A 80 DUP1 101B 80 DUP1 101C 60 PUSH1 0x20 101E 01 ADD 101F 82 DUP3 1020 81 DUP2 1021 03 SUB 1022 82 DUP3 1023 52 MSTORE 1024 60 PUSH1 0x23 1026 81 DUP2 1027 52 MSTORE 1028 60 PUSH1 0x20 102A 01 ADD 102B 80 DUP1 102C 61 PUSH2 0x1b9c 102F 60 PUSH1 0x23 1031 91 SWAP2 1032 39 CODECOPY 1033 60 PUSH1 0x40 1035 01 ADD 1036 91 SWAP2 1037 50 POP 1038 50 POP 1039 60 PUSH1 0x40 103B 51 MLOAD 103C 80 DUP1 103D 91 SWAP2 103E 03 SUB 103F 90 SWAP1 1040 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1016 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1023 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1027 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @1032 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x1b9c:0x1bbf] // @1040 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1041: // Incoming jump from 0x0FF0, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[5] // { // @1045 stack[-1] // @104A memory[0x40:0x60] // @1063 stack[-3] // @109D memory[0x00:0x40] // @109E storage[keccak256(memory[0x00:0x40])] // } 1041 5B JUMPDEST 1042 61 PUSH2 0x10ad 1045 81 DUP2 1046 60 PUSH1 0x60 1048 60 PUSH1 0x40 104A 51 MLOAD 104B 90 SWAP1 104C 81 DUP2 104D 01 ADD 104E 60 PUSH1 0x40 1050 52 MSTORE 1051 80 DUP1 1052 60 PUSH1 0x26 1054 81 DUP2 1055 52 MSTORE 1056 60 PUSH1 0x20 1058 01 ADD 1059 61 PUSH2 0x1c03 105C 60 PUSH1 0x26 105E 91 SWAP2 105F 39 CODECOPY 1060 60 PUSH1 0x00 1062 80 DUP1 1063 87 DUP8 1064 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1079 16 AND 107A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 108F 16 AND 1090 81 DUP2 1091 52 MSTORE 1092 60 PUSH1 0x20 1094 01 ADD 1095 90 SWAP1 1096 81 DUP2 1097 52 MSTORE 1098 60 PUSH1 0x20 109A 01 ADD 109B 60 PUSH1 0x00 109D 20 SHA3 109E 54 SLOAD 109F 61 PUSH2 0x11ec 10A2 90 SWAP1 10A3 92 SWAP3 10A4 91 SWAP2 10A5 90 SWAP1 10A6 63 PUSH4 0xffffffff 10AB 16 AND 10AC 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1042 stack[0] = 0x10ad // @1050 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1055 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x26 // @105F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x26] = code[0x1c03:0x1c29] // @1091 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1097 memory[0x20:0x40] = 0x00 // @10A3 stack[1] = storage[keccak256(memory[0x00:0x40])] // @10A4 stack[2] = stack[-1] // @10A5 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x11ec, returns to 0x10AD label_10AD: // Incoming return from call to 0x11EC at 0x10AC // Inputs[7] // { // @10B1 stack[-4] // @10EB memory[0x00:0x40] // @10EC stack[-1] // @10F3 stack[-2] // @10F7 stack[-3] // @1131 memory[0x00:0x40] // @1132 storage[keccak256(memory[0x00:0x40])] // } 10AD 5B JUMPDEST 10AE 60 PUSH1 0x00 10B0 80 DUP1 10B1 85 DUP6 10B2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10C7 16 AND 10C8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10DD 16 AND 10DE 81 DUP2 10DF 52 MSTORE 10E0 60 PUSH1 0x20 10E2 01 ADD 10E3 90 SWAP1 10E4 81 DUP2 10E5 52 MSTORE 10E6 60 PUSH1 0x20 10E8 01 ADD 10E9 60 PUSH1 0x00 10EB 20 SHA3 10EC 81 DUP2 10ED 90 SWAP1 10EE 55 SSTORE 10EF 50 POP 10F0 61 PUSH2 0x1140 10F3 81 DUP2 10F4 60 PUSH1 0x00 10F6 80 DUP1 10F7 85 DUP6 10F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 110D 16 AND 110E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1123 16 AND 1124 81 DUP2 1125 52 MSTORE 1126 60 PUSH1 0x20 1128 01 ADD 1129 90 SWAP1 112A 81 DUP2 112B 52 MSTORE 112C 60 PUSH1 0x20 112E 01 ADD 112F 60 PUSH1 0x00 1131 20 SHA3 1132 54 SLOAD 1133 61 PUSH2 0x12ae 1136 90 SWAP1 1137 91 SWAP2 1138 90 SWAP1 1139 63 PUSH4 0xffffffff 113E 16 AND 113F 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @10DF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @10E5 memory[0x20:0x40] = 0x00 // @10EE storage[keccak256(memory[0x00:0x40])] = stack[-1] // @10F0 stack[-1] = 0x1140 // @1125 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @112B memory[0x20:0x40] = 0x00 // @1137 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1138 stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x12ae, returns to 0x1140 label_1140: // Incoming return from call to 0x12AE at 0x113F // Inputs[9] // { // @1144 stack[-3] // @117E memory[0x00:0x40] // @117F stack[-1] // @119A stack[-4] // @11D2 stack[-2] // @11D5 memory[0x40:0x60] // @11E2 memory[0x40:0x60] // @11E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @11EB stack[-5] // } 1140 5B JUMPDEST 1141 60 PUSH1 0x00 1143 80 DUP1 1144 84 DUP5 1145 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 115A 16 AND 115B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1170 16 AND 1171 81 DUP2 1172 52 MSTORE 1173 60 PUSH1 0x20 1175 01 ADD 1176 90 SWAP1 1177 81 DUP2 1178 52 MSTORE 1179 60 PUSH1 0x20 117B 01 ADD 117C 60 PUSH1 0x00 117E 20 SHA3 117F 81 DUP2 1180 90 SWAP1 1181 55 SSTORE 1182 50 POP 1183 81 DUP2 1184 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1199 16 AND 119A 83 DUP4 119B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11B0 16 AND 11B1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 11D2 83 DUP4 11D3 60 PUSH1 0x40 11D5 51 MLOAD 11D6 80 DUP1 11D7 82 DUP3 11D8 81 DUP2 11D9 52 MSTORE 11DA 60 PUSH1 0x20 11DC 01 ADD 11DD 91 SWAP2 11DE 50 POP 11DF 50 POP 11E0 60 PUSH1 0x40 11E2 51 MLOAD 11E3 80 DUP1 11E4 91 SWAP2 11E5 03 SUB 11E6 90 SWAP1 11E7 A3 LOG3 11E8 50 POP 11E9 50 POP 11EA 50 POP 11EB 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @1172 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1178 memory[0x20:0x40] = 0x00 // @1181 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @11D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @11E7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-5] label_11EC: // Incoming jump from 0x0C5C // Incoming call from 0x19F6, returns to 0x19F7 // Incoming call from 0x10AC, returns to 0x10AD // Incoming jump from 0x165A // Incoming call from 0x14CC, returns to 0x14CD // Incoming jump from 0x08AB // Inputs[3] // { // @11EF stack[-3] // @11F0 stack[-2] // @11F3 stack[-1] // } 11EC 5B JUMPDEST 11ED 60 PUSH1 0x00 11EF 83 DUP4 11F0 83 DUP4 11F1 11 GT 11F2 15 ISZERO 11F3 82 DUP3 11F4 90 SWAP1 11F5 15 ISZERO 11F6 15 ISZERO 11F7 61 PUSH2 0x129b 11FA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @11ED stack[0] = 0x00 // @11F4 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x129b, if !!!(stack[-2] > stack[-3]) label_11FB: // Incoming jump from 0x11FA, if not !!!(stack[-2] > stack[-3]) // Inputs[4] // { // @11FD memory[0x40:0x60] // @122E stack[-1] // @1231 memory[stack[-1]:stack[-1] + 0x20] // @123A memory[stack[-1]:stack[-1] + 0x20] // } 11FB 60 PUSH1 0x40 11FD 51 MLOAD 11FE 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 121F 81 DUP2 1220 52 MSTORE 1221 60 PUSH1 0x04 1223 01 ADD 1224 80 DUP1 1225 80 DUP1 1226 60 PUSH1 0x20 1228 01 ADD 1229 82 DUP3 122A 81 DUP2 122B 03 SUB 122C 82 DUP3 122D 52 MSTORE 122E 83 DUP4 122F 81 DUP2 1230 81 DUP2 1231 51 MLOAD 1232 81 DUP2 1233 52 MSTORE 1234 60 PUSH1 0x20 1236 01 ADD 1237 91 SWAP2 1238 50 POP 1239 80 DUP1 123A 51 MLOAD 123B 90 SWAP1 123C 60 PUSH1 0x20 123E 01 ADD 123F 90 SWAP1 1240 80 DUP1 1241 83 DUP4 1242 83 DUP4 1243 60 PUSH1 0x00 1245 5B JUMPDEST 1246 83 DUP4 1247 81 DUP2 1248 10 LT 1249 15 ISZERO 124A 61 PUSH2 0x1260 124D 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @1220 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1223 stack[0] = 0x04 + memory[0x40:0x60] // @1224 stack[1] = 0x04 + memory[0x40:0x60] // @122D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1233 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1237 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @123F stack[3] = 0x20 + stack[-1] // @123F stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @1240 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @1241 stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1242 stack[7] = 0x20 + stack[-1] // @1243 stack[8] = 0x00 // } // Block ends with conditional jump to 0x1260, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_124E: // Incoming jump from 0x124D, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x124D, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @124E stack[-1] // @124F stack[-2] // @1251 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @1253 stack[-3] // } 124E 80 DUP1 124F 82 DUP3 1250 01 ADD 1251 51 MLOAD 1252 81 DUP2 1253 84 DUP5 1254 01 ADD 1255 52 MSTORE 1256 60 PUSH1 0x20 1258 81 DUP2 1259 01 ADD 125A 90 SWAP1 125B 50 POP 125C 61 PUSH2 0x1245 125F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1255 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @125A stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x1245 label_1260: // Incoming jump from 0x124D, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x124D, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1265 stack[-5] // @1265 stack[-6] // @1267 stack[-7] // } 1260 5B JUMPDEST 1261 50 POP 1262 50 POP 1263 50 POP 1264 50 POP 1265 90 SWAP1 1266 50 POP 1267 90 SWAP1 1268 81 DUP2 1269 01 ADD 126A 90 SWAP1 126B 60 PUSH1 0x1f 126D 16 AND 126E 80 DUP1 126F 15 ISZERO 1270 61 PUSH2 0x128d 1273 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @126A stack[-7] = stack[-5] + stack[-7] // @126D stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x128d, if !(0x1f & stack[-5]) label_1274: // Incoming jump from 0x1273, if not !(0x1f & stack[-5]) // Inputs[6] // { // @1274 stack[-1] // @1275 stack[-2] // @1278 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @128F stack[-5] // @1295 memory[0x40:0x60] // @129A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 1274 80 DUP1 1275 82 DUP3 1276 03 SUB 1277 80 DUP1 1278 51 MLOAD 1279 60 PUSH1 0x01 127B 83 DUP4 127C 60 PUSH1 0x20 127E 03 SUB 127F 61 PUSH2 0x0100 1282 0A EXP 1283 03 SUB 1284 19 NOT 1285 16 AND 1286 81 DUP2 1287 52 MSTORE 1288 60 PUSH1 0x20 128A 01 ADD 128B 91 SWAP2 128C 50 POP 128D 5B JUMPDEST 128E 50 POP 128F 92 SWAP3 1290 50 POP 1291 50 POP 1292 50 POP 1293 60 PUSH1 0x40 1295 51 MLOAD 1296 80 DUP1 1297 91 SWAP2 1298 03 SUB 1299 90 SWAP1 129A FD *REVERT // Stack delta = -5 // Outputs[2] // { // @1287 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] // @129A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_129B: // Incoming jump from 0x11FA, if !!!(stack[-2] > stack[-3]) // Inputs[4] // { // @129F stack[-4] // @12A0 stack[-5] // @12A5 stack[-2] // @12A8 stack[-6] // } 129B 5B JUMPDEST 129C 50 POP 129D 60 PUSH1 0x00 129F 83 DUP4 12A0 85 DUP6 12A1 03 SUB 12A2 90 SWAP1 12A3 50 POP 12A4 80 DUP1 12A5 91 SWAP2 12A6 50 POP 12A7 50 POP 12A8 93 SWAP4 12A9 92 SWAP3 12AA 50 POP 12AB 50 POP 12AC 50 POP 12AD 56 *JUMP // Stack delta = -5 // Outputs[1] { @12A8 stack[-6] = stack[-5] - stack[-4] } // Block ends with unconditional jump to stack[-6] label_12AE: // Incoming call from 0x1908, returns to 0x1909 // Incoming call from 0x18B1, returns to 0x18B2 // Incoming jump from 0x1354 // Incoming call from 0x113F, returns to 0x1140 // Incoming jump from 0x0980 // Inputs[2] // { // @12B2 stack[-1] // @12B3 stack[-2] // } 12AE 5B JUMPDEST 12AF 60 PUSH1 0x00 12B1 80 DUP1 12B2 82 DUP3 12B3 84 DUP5 12B4 01 ADD 12B5 90 SWAP1 12B6 50 POP 12B7 83 DUP4 12B8 81 DUP2 12B9 10 LT 12BA 15 ISZERO 12BB 15 ISZERO 12BC 15 ISZERO 12BD 61 PUSH2 0x132e 12C0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @12AF stack[0] = 0x00 // @12B5 stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x132e, if !!!(stack[-2] + stack[-1] < stack[-2]) label_12C1: // Incoming jump from 0x12C0, if not !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @12C3 memory[0x40:0x60] // @1328 memory[0x40:0x60] // @132D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 12C1 60 PUSH1 0x40 12C3 51 MLOAD 12C4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 12E5 81 DUP2 12E6 52 MSTORE 12E7 60 PUSH1 0x04 12E9 01 ADD 12EA 80 DUP1 12EB 80 DUP1 12EC 60 PUSH1 0x20 12EE 01 ADD 12EF 82 DUP3 12F0 81 DUP2 12F1 03 SUB 12F2 82 DUP3 12F3 52 MSTORE 12F4 60 PUSH1 0x1b 12F6 81 DUP2 12F7 52 MSTORE 12F8 60 PUSH1 0x20 12FA 01 ADD 12FB 80 DUP1 12FC 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 131D 81 DUP2 131E 52 MSTORE 131F 50 POP 1320 60 PUSH1 0x20 1322 01 ADD 1323 91 SWAP2 1324 50 POP 1325 50 POP 1326 60 PUSH1 0x40 1328 51 MLOAD 1329 80 DUP1 132A 91 SWAP2 132B 03 SUB 132C 90 SWAP1 132D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @12E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @12F3 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @12F7 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1b // @131E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @132D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_132E: // Incoming jump from 0x12C0, if !!!(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @132F stack[-1] // @1330 stack[-2] // @1333 stack[-5] // @1334 stack[-4] // } 132E 5B JUMPDEST 132F 80 DUP1 1330 91 SWAP2 1331 50 POP 1332 50 POP 1333 92 SWAP3 1334 91 SWAP2 1335 50 POP 1336 50 POP 1337 56 *JUMP // Stack delta = -4 // Outputs[1] { @1333 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1338: // Incoming call from 0x0A02, returns to 0x0A03 // Inputs[2] // { // @133B storage[0x04] // @133F stack[-1] // } 1338 5B JUMPDEST 1339 60 PUSH1 0x04 133B 54 SLOAD 133C 61 PUSH2 0x1355 133F 82 DUP3 1340 61 PUSH2 0x1347 1343 61 PUSH2 0x07d8 1346 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @133B stack[0] = storage[0x04] // @133C stack[1] = 0x1355 // @133F stack[2] = stack[-1] // @1340 stack[3] = 0x1347 // } // Block ends with call to 0x07d8, returns to 0x1347 label_1347: // Incoming return from call to 0x07D8 at 0x1346 // Inputs[2] // { // @134B stack[-1] // @134C stack[-2] // } 1347 5B JUMPDEST 1348 61 PUSH2 0x12ae 134B 90 SWAP1 134C 91 SWAP2 134D 90 SWAP1 134E 63 PUSH4 0xffffffff 1353 16 AND 1354 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @134C stack[-2] = stack[-1] // @134D stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x12ae label_1355: // Incoming return from call to 0x1347 at 0x1346 // Inputs[2] // { // @1356 stack[-2] // @1356 stack[-1] // } 1355 5B JUMPDEST 1356 11 GT 1357 15 ISZERO 1358 15 ISZERO 1359 15 ISZERO 135A 61 PUSH2 0x13cb 135D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x13cb, if !!!(stack[-1] > stack[-2]) label_135E: // Incoming jump from 0x135D, if not !!!(stack[-1] > stack[-2]) // Inputs[3] // { // @1360 memory[0x40:0x60] // @13C5 memory[0x40:0x60] // @13CA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 135E 60 PUSH1 0x40 1360 51 MLOAD 1361 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1382 81 DUP2 1383 52 MSTORE 1384 60 PUSH1 0x04 1386 01 ADD 1387 80 DUP1 1388 80 DUP1 1389 60 PUSH1 0x20 138B 01 ADD 138C 82 DUP3 138D 81 DUP2 138E 03 SUB 138F 82 DUP3 1390 52 MSTORE 1391 60 PUSH1 0x19 1393 81 DUP2 1394 52 MSTORE 1395 60 PUSH1 0x20 1397 01 ADD 1398 80 DUP1 1399 7F PUSH32 0x45524332304361707065643a2063617020657863656564656400000000000000 13BA 81 DUP2 13BB 52 MSTORE 13BC 50 POP 13BD 60 PUSH1 0x20 13BF 01 ADD 13C0 91 SWAP2 13C1 50 POP 13C2 50 POP 13C3 60 PUSH1 0x40 13C5 51 MLOAD 13C6 80 DUP1 13C7 91 SWAP2 13C8 03 SUB 13C9 90 SWAP1 13CA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1383 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1390 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1394 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x19 // @13BB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x45524332304361707065643a2063617020657863656564656400000000000000 // @13CA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_13CB: // Incoming jump from 0x135D, if !!!(stack[-1] > stack[-2]) // Inputs[2] // { // @13CF stack[-2] // @13D0 stack[-1] // } 13CB 5B JUMPDEST 13CC 61 PUSH2 0x13d5 13CF 82 DUP3 13D0 82 DUP3 13D1 61 PUSH2 0x17f8 13D4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13CC stack[0] = 0x13d5 // @13CF stack[1] = stack[-2] // @13D0 stack[2] = stack[-1] // } // Block ends with call to 0x17f8, returns to 0x13D5 label_13D5: // Incoming return from call to 0x17F8 at 0x13D4 // Inputs[1] { @13D8 stack[-3] } 13D5 5B JUMPDEST 13D6 50 POP 13D7 50 POP 13D8 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_13D9: // Incoming jump from 0x0A1D // Incoming call from 0x159D, returns to 0x159E // Inputs[1] { @13F2 stack[-2] } 13D9 5B JUMPDEST 13DA 60 PUSH1 0x00 13DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13F1 16 AND 13F2 82 DUP3 13F3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1408 16 AND 1409 14 EQ 140A 15 ISZERO 140B 15 ISZERO 140C 15 ISZERO 140D 61 PUSH2 0x1461 1410 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1461, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1411: // Incoming jump from 0x1410, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1413 memory[0x40:0x60] // @145B memory[0x40:0x60] // @1460 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1411 60 PUSH1 0x40 1413 51 MLOAD 1414 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1435 81 DUP2 1436 52 MSTORE 1437 60 PUSH1 0x04 1439 01 ADD 143A 80 DUP1 143B 80 DUP1 143C 60 PUSH1 0x20 143E 01 ADD 143F 82 DUP3 1440 81 DUP2 1441 03 SUB 1442 82 DUP3 1443 52 MSTORE 1444 60 PUSH1 0x21 1446 81 DUP2 1447 52 MSTORE 1448 60 PUSH1 0x20 144A 01 ADD 144B 80 DUP1 144C 61 PUSH2 0x1ce8 144F 60 PUSH1 0x21 1451 91 SWAP2 1452 39 CODECOPY 1453 60 PUSH1 0x40 1455 01 ADD 1456 91 SWAP2 1457 50 POP 1458 50 POP 1459 60 PUSH1 0x40 145B 51 MLOAD 145C 80 DUP1 145D 91 SWAP2 145E 03 SUB 145F 90 SWAP1 1460 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1436 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1443 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1447 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @1452 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x1ce8:0x1d09] // @1460 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1461: // Incoming jump from 0x1410, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[5] // { // @1465 stack[-1] // @146A memory[0x40:0x60] // @1483 stack[-2] // @14BD memory[0x00:0x40] // @14BE storage[keccak256(memory[0x00:0x40])] // } 1461 5B JUMPDEST 1462 61 PUSH2 0x14cd 1465 81 DUP2 1466 60 PUSH1 0x60 1468 60 PUSH1 0x40 146A 51 MLOAD 146B 90 SWAP1 146C 81 DUP2 146D 01 ADD 146E 60 PUSH1 0x40 1470 52 MSTORE 1471 80 DUP1 1472 60 PUSH1 0x22 1474 81 DUP2 1475 52 MSTORE 1476 60 PUSH1 0x20 1478 01 ADD 1479 61 PUSH2 0x1bbf 147C 60 PUSH1 0x22 147E 91 SWAP2 147F 39 CODECOPY 1480 60 PUSH1 0x00 1482 80 DUP1 1483 86 DUP7 1484 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1499 16 AND 149A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14AF 16 AND 14B0 81 DUP2 14B1 52 MSTORE 14B2 60 PUSH1 0x20 14B4 01 ADD 14B5 90 SWAP1 14B6 81 DUP2 14B7 52 MSTORE 14B8 60 PUSH1 0x20 14BA 01 ADD 14BB 60 PUSH1 0x00 14BD 20 SHA3 14BE 54 SLOAD 14BF 61 PUSH2 0x11ec 14C2 90 SWAP1 14C3 92 SWAP3 14C4 91 SWAP2 14C5 90 SWAP1 14C6 63 PUSH4 0xffffffff 14CB 16 AND 14CC 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1462 stack[0] = 0x14cd // @1470 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1475 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x22 // @147F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x22] = code[0x1bbf:0x1be1] // @14B1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @14B7 memory[0x20:0x40] = 0x00 // @14C3 stack[1] = storage[keccak256(memory[0x00:0x40])] // @14C4 stack[2] = stack[-1] // @14C5 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x11ec, returns to 0x14CD label_14CD: // Incoming return from call to 0x11EC at 0x14CC // Inputs[5] // { // @14D1 stack[-3] // @150B memory[0x00:0x40] // @150C stack[-1] // @1513 stack[-2] // @1516 storage[0x02] // } 14CD 5B JUMPDEST 14CE 60 PUSH1 0x00 14D0 80 DUP1 14D1 84 DUP5 14D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14E7 16 AND 14E8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14FD 16 AND 14FE 81 DUP2 14FF 52 MSTORE 1500 60 PUSH1 0x20 1502 01 ADD 1503 90 SWAP1 1504 81 DUP2 1505 52 MSTORE 1506 60 PUSH1 0x20 1508 01 ADD 1509 60 PUSH1 0x00 150B 20 SHA3 150C 81 DUP2 150D 90 SWAP1 150E 55 SSTORE 150F 50 POP 1510 61 PUSH2 0x1524 1513 81 DUP2 1514 60 PUSH1 0x02 1516 54 SLOAD 1517 61 PUSH2 0x19b5 151A 90 SWAP1 151B 91 SWAP2 151C 90 SWAP1 151D 63 PUSH4 0xffffffff 1522 16 AND 1523 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @14FF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1505 memory[0x20:0x40] = 0x00 // @150E storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1510 stack[-1] = 0x1524 // @151B stack[0] = storage[0x02] // @151C stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x19b5, returns to 0x1524 label_1524: // Incoming return from call to 0x19B5 at 0x1523 // Inputs[7] // { // @1527 stack[-1] // @1543 stack[-3] // @157B stack[-2] // @157E memory[0x40:0x60] // @158B memory[0x40:0x60] // @1590 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1593 stack[-4] // } 1524 5B JUMPDEST 1525 60 PUSH1 0x02 1527 81 DUP2 1528 90 SWAP1 1529 55 SSTORE 152A 50 POP 152B 60 PUSH1 0x00 152D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1542 16 AND 1543 82 DUP3 1544 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1559 16 AND 155A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 157B 83 DUP4 157C 60 PUSH1 0x40 157E 51 MLOAD 157F 80 DUP1 1580 82 DUP3 1581 81 DUP2 1582 52 MSTORE 1583 60 PUSH1 0x20 1585 01 ADD 1586 91 SWAP2 1587 50 POP 1588 50 POP 1589 60 PUSH1 0x40 158B 51 MLOAD 158C 80 DUP1 158D 91 SWAP2 158E 03 SUB 158F 90 SWAP1 1590 A3 LOG3 1591 50 POP 1592 50 POP 1593 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1529 storage[0x02] = stack[-1] // @1582 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @1590 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // } // Block ends with unconditional jump to stack[-4] label_1594: // Incoming call from 0x0A72, returns to 0x0A73 // Inputs[2] // { // @1598 stack[-2] // @1599 stack[-1] // } 1594 5B JUMPDEST 1595 61 PUSH2 0x159e 1598 82 DUP3 1599 82 DUP3 159A 61 PUSH2 0x13d9 159D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1595 stack[0] = 0x159e // @1598 stack[1] = stack[-2] // @1599 stack[2] = stack[-1] // } // Block ends with call to 0x13d9, returns to 0x159E label_159E: // Incoming return from call to 0x13D9 at 0x159D // Inputs[1] { @15A2 stack[-2] } 159E 5B JUMPDEST 159F 61 PUSH2 0x1660 15A2 82 DUP3 15A3 61 PUSH2 0x15aa 15A6 61 PUSH2 0x0d2e 15A9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @159F stack[0] = 0x1660 // @15A2 stack[1] = stack[-2] // @15A3 stack[2] = 0x15aa // } // Block ends with call to 0x0d2e, returns to 0x15AA label_15AA: // Incoming return from call to 0x0D2E at 0x15A9 // Inputs[4] // { // @15AE stack[-4] // @15B3 memory[0x40:0x60] // @15CD stack[-5] // @1607 memory[0x00:0x40] // } 15AA 5B JUMPDEST 15AB 61 PUSH2 0x165b 15AE 84 DUP5 15AF 60 PUSH1 0x60 15B1 60 PUSH1 0x40 15B3 51 MLOAD 15B4 90 SWAP1 15B5 81 DUP2 15B6 01 ADD 15B7 60 PUSH1 0x40 15B9 52 MSTORE 15BA 80 DUP1 15BB 60 PUSH1 0x24 15BD 81 DUP2 15BE 52 MSTORE 15BF 60 PUSH1 0x20 15C1 01 ADD 15C2 61 PUSH2 0x1cc4 15C5 60 PUSH1 0x24 15C7 91 SWAP2 15C8 39 CODECOPY 15C9 60 PUSH1 0x01 15CB 60 PUSH1 0x00 15CD 89 DUP10 15CE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15E3 16 AND 15E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15F9 16 AND 15FA 81 DUP2 15FB 52 MSTORE 15FC 60 PUSH1 0x20 15FE 01 ADD 15FF 90 SWAP1 1600 81 DUP2 1601 52 MSTORE 1602 60 PUSH1 0x20 1604 01 ADD 1605 60 PUSH1 0x00 1607 20 SHA3 1608 60 PUSH1 0x00 160A 61 PUSH2 0x1611 160D 61 PUSH2 0x0d2e 1610 56 *JUMP // Stack delta = +6 // Outputs[11] // { // @15AB stack[0] = 0x165b // @15AE stack[1] = stack[-4] // @15B4 stack[2] = memory[0x40:0x60] // @15B9 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @15BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x24 // @15C8 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x24] = code[0x1cc4:0x1ce8] // @15FB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1601 memory[0x20:0x40] = 0x01 // @1607 stack[3] = keccak256(memory[0x00:0x40]) // @1608 stack[4] = 0x00 // @160A stack[5] = 0x1611 // } // Block ends with call to 0x0d2e, returns to 0x1611 label_1611: // Incoming return from call to 0x0D2E at 0x1610 // Inputs[7] // { // @1627 stack[-1] // @163E stack[-2] // @1643 stack[-3] // @164B memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @164C storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @1651 stack[-5] // @1652 stack[-4] // } 1611 5B JUMPDEST 1612 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1627 16 AND 1628 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 163D 16 AND 163E 81 DUP2 163F 52 MSTORE 1640 60 PUSH1 0x20 1642 01 ADD 1643 90 SWAP1 1644 81 DUP2 1645 52 MSTORE 1646 60 PUSH1 0x20 1648 01 ADD 1649 60 PUSH1 0x00 164B 20 SHA3 164C 54 SLOAD 164D 61 PUSH2 0x11ec 1650 90 SWAP1 1651 92 SWAP3 1652 91 SWAP2 1653 90 SWAP1 1654 63 PUSH4 0xffffffff 1659 16 AND 165A 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @163F memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1645 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @1651 stack[-5] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @1652 stack[-4] = stack[-5] // @1653 stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0xffffffff & 0x11ec label_165B: // Incoming return from call to 0x1611 at 0x1610 165B 5B JUMPDEST 165C 61 PUSH2 0x0d36 165F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d36 label_1660: // Incoming return from call to 0x15AA at 0x15A9 // Inputs[1] { @1663 stack[-3] } 1660 5B JUMPDEST 1661 50 POP 1662 50 POP 1663 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1664: // Incoming call from 0x0B88, returns to 0x0B89 // Inputs[1] { @1668 stack[-1] } 1664 5B JUMPDEST 1665 61 PUSH2 0x1678 1668 81 DUP2 1669 60 PUSH1 0x03 166B 61 PUSH2 0x19ff 166E 90 SWAP1 166F 91 SWAP2 1670 90 SWAP1 1671 63 PUSH4 0xffffffff 1676 16 AND 1677 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1665 stack[0] = 0x1678 // @166F stack[1] = 0x03 // @1670 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x19ff, returns to 0x1678 label_1678: // Incoming return from call to 0x19FF at 0x1677 // Inputs[5] // { // @1679 stack[-1] // @16B3 memory[0x40:0x60] // @16B6 memory[0x40:0x60] // @16BB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @16BD stack[-2] // } 1678 5B JUMPDEST 1679 80 DUP1 167A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 168F 16 AND 1690 7F PUSH32 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6 16B1 60 PUSH1 0x40 16B3 51 MLOAD 16B4 60 PUSH1 0x40 16B6 51 MLOAD 16B7 80 DUP1 16B8 91 SWAP2 16B9 03 SUB 16BA 90 SWAP1 16BB A2 LOG2 16BC 50 POP 16BD 56 *JUMP // Stack delta = -2 // Outputs[1] { @16BB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); } // Block ends with unconditional jump to stack[-2] label_16BE: // Incoming jump from 0x0B9B // Inputs[1] { @16C2 stack[-1] } 16BE 5B JUMPDEST 16BF 61 PUSH2 0x16d2 16C2 81 DUP2 16C3 60 PUSH1 0x03 16C5 61 PUSH2 0x1adc 16C8 90 SWAP1 16C9 91 SWAP2 16CA 90 SWAP1 16CB 63 PUSH4 0xffffffff 16D0 16 AND 16D1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16BF stack[0] = 0x16d2 // @16C9 stack[1] = 0x03 // @16CA stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x1adc, returns to 0x16D2 label_16D2: // Incoming return from call to 0x1ADC at 0x16D1 // Inputs[5] // { // @16D3 stack[-1] // @170D memory[0x40:0x60] // @1710 memory[0x40:0x60] // @1715 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1717 stack[-2] // } 16D2 5B JUMPDEST 16D3 80 DUP1 16D4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16E9 16 AND 16EA 7F PUSH32 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692 170B 60 PUSH1 0x40 170D 51 MLOAD 170E 60 PUSH1 0x40 1710 51 MLOAD 1711 80 DUP1 1712 91 SWAP2 1713 03 SUB 1714 90 SWAP1 1715 A2 LOG2 1716 50 POP 1717 56 *JUMP // Stack delta = -2 // Outputs[1] { @1715 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); } // Block ends with unconditional jump to stack[-2] label_1718: // Incoming call from 0x1A08, returns to 0x1A09 // Incoming call from 0x0C9F, returns to 0x0CA0 // Incoming call from 0x1AE5, returns to 0x1AE6 // Inputs[1] { @1732 stack[-1] } 1718 5B JUMPDEST 1719 60 PUSH1 0x00 171B 80 DUP1 171C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1731 16 AND 1732 82 DUP3 1733 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1748 16 AND 1749 14 EQ 174A 15 ISZERO 174B 15 ISZERO 174C 15 ISZERO 174D 61 PUSH2 0x17a1 1750 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1719 stack[0] = 0x00 } // Block ends with conditional jump to 0x17a1, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1751: // Incoming jump from 0x1750, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1753 memory[0x40:0x60] // @179B memory[0x40:0x60] // @17A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1751 60 PUSH1 0x40 1753 51 MLOAD 1754 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1775 81 DUP2 1776 52 MSTORE 1777 60 PUSH1 0x04 1779 01 ADD 177A 80 DUP1 177B 80 DUP1 177C 60 PUSH1 0x20 177E 01 ADD 177F 82 DUP3 1780 81 DUP2 1781 03 SUB 1782 82 DUP3 1783 52 MSTORE 1784 60 PUSH1 0x22 1786 81 DUP2 1787 52 MSTORE 1788 60 PUSH1 0x20 178A 01 ADD 178B 80 DUP1 178C 61 PUSH2 0x1ca2 178F 60 PUSH1 0x22 1791 91 SWAP2 1792 39 CODECOPY 1793 60 PUSH1 0x40 1795 01 ADD 1796 91 SWAP2 1797 50 POP 1798 50 POP 1799 60 PUSH1 0x40 179B 51 MLOAD 179C 80 DUP1 179D 91 SWAP2 179E 03 SUB 179F 90 SWAP1 17A0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1776 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1783 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1787 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @1792 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x1ca2:0x1cc4] // @17A0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_17A1: // Incoming jump from 0x1750, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[6] // { // @17A2 stack[-3] // @17A8 stack[-2] // @17E2 memory[0x00:0x40] // @17E6 storage[keccak256(memory[0x00:0x40])] // @17F1 stack[-1] // @17F3 stack[-4] // } 17A1 5B JUMPDEST 17A2 82 DUP3 17A3 60 PUSH1 0x00 17A5 01 ADD 17A6 60 PUSH1 0x00 17A8 83 DUP4 17A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17BE 16 AND 17BF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17D4 16 AND 17D5 81 DUP2 17D6 52 MSTORE 17D7 60 PUSH1 0x20 17D9 01 ADD 17DA 90 SWAP1 17DB 81 DUP2 17DC 52 MSTORE 17DD 60 PUSH1 0x20 17DF 01 ADD 17E0 60 PUSH1 0x00 17E2 20 SHA3 17E3 60 PUSH1 0x00 17E5 90 SWAP1 17E6 54 SLOAD 17E7 90 SWAP1 17E8 61 PUSH2 0x0100 17EB 0A EXP 17EC 90 SWAP1 17ED 04 DIV 17EE 60 PUSH1 0xff 17F0 16 AND 17F1 90 SWAP1 17F2 50 POP 17F3 92 SWAP3 17F4 91 SWAP2 17F5 50 POP 17F6 50 POP 17F7 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @17D6 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @17DC memory[0x20:0x40] = 0x00 + stack[-3] // @17F3 stack[-4] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-4] label_17F8: // Incoming call from 0x13D4, returns to 0x13D5 // Inputs[1] { @1811 stack[-2] } 17F8 5B JUMPDEST 17F9 60 PUSH1 0x00 17FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1810 16 AND 1811 82 DUP3 1812 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1827 16 AND 1828 14 EQ 1829 15 ISZERO 182A 15 ISZERO 182B 15 ISZERO 182C 61 PUSH2 0x189d 182F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x189d, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1830: // Incoming jump from 0x182F, if not !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1832 memory[0x40:0x60] // @1897 memory[0x40:0x60] // @189C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1830 60 PUSH1 0x40 1832 51 MLOAD 1833 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1854 81 DUP2 1855 52 MSTORE 1856 60 PUSH1 0x04 1858 01 ADD 1859 80 DUP1 185A 80 DUP1 185B 60 PUSH1 0x20 185D 01 ADD 185E 82 DUP3 185F 81 DUP2 1860 03 SUB 1861 82 DUP3 1862 52 MSTORE 1863 60 PUSH1 0x1f 1865 81 DUP2 1866 52 MSTORE 1867 60 PUSH1 0x20 1869 01 ADD 186A 80 DUP1 186B 7F PUSH32 0x45524332303a206d696e7420746f20746865207a65726f206164647265737300 188C 81 DUP2 188D 52 MSTORE 188E 50 POP 188F 60 PUSH1 0x20 1891 01 ADD 1892 91 SWAP2 1893 50 POP 1894 50 POP 1895 60 PUSH1 0x40 1897 51 MLOAD 1898 80 DUP1 1899 91 SWAP2 189A 03 SUB 189B 90 SWAP1 189C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1855 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1862 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1866 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1f // @188D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x45524332303a206d696e7420746f20746865207a65726f206164647265737300 // @189C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_189D: // Incoming jump from 0x182F, if !!!(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @18A1 stack[-1] // @18A4 storage[0x02] // } 189D 5B JUMPDEST 189E 61 PUSH2 0x18b2 18A1 81 DUP2 18A2 60 PUSH1 0x02 18A4 54 SLOAD 18A5 61 PUSH2 0x12ae 18A8 90 SWAP1 18A9 91 SWAP2 18AA 90 SWAP1 18AB 63 PUSH4 0xffffffff 18B0 16 AND 18B1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @189E stack[0] = 0x18b2 // @18A9 stack[1] = storage[0x02] // @18AA stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x12ae, returns to 0x18B2 label_18B2: // Incoming return from call to 0x12AE at 0x18B1 // Inputs[5] // { // @18B5 stack[-1] // @18BC stack[-2] // @18C0 stack[-3] // @18FA memory[0x00:0x40] // @18FB storage[keccak256(memory[0x00:0x40])] // } 18B2 5B JUMPDEST 18B3 60 PUSH1 0x02 18B5 81 DUP2 18B6 90 SWAP1 18B7 55 SSTORE 18B8 50 POP 18B9 61 PUSH2 0x1909 18BC 81 DUP2 18BD 60 PUSH1 0x00 18BF 80 DUP1 18C0 85 DUP6 18C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18D6 16 AND 18D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18EC 16 AND 18ED 81 DUP2 18EE 52 MSTORE 18EF 60 PUSH1 0x20 18F1 01 ADD 18F2 90 SWAP1 18F3 81 DUP2 18F4 52 MSTORE 18F5 60 PUSH1 0x20 18F7 01 ADD 18F8 60 PUSH1 0x00 18FA 20 SHA3 18FB 54 SLOAD 18FC 61 PUSH2 0x12ae 18FF 90 SWAP1 1900 91 SWAP2 1901 90 SWAP1 1902 63 PUSH4 0xffffffff 1907 16 AND 1908 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @18B7 storage[0x02] = stack[-1] // @18B9 stack[-1] = 0x1909 // @18EE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @18F4 memory[0x20:0x40] = 0x00 // @1900 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1901 stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x12ae, returns to 0x1909 label_1909: // Incoming return from call to 0x12AE at 0x1908 // Inputs[8] // { // @190D stack[-3] // @1947 memory[0x00:0x40] // @1948 stack[-1] // @199C stack[-2] // @199F memory[0x40:0x60] // @19AC memory[0x40:0x60] // @19B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @19B4 stack[-4] // } 1909 5B JUMPDEST 190A 60 PUSH1 0x00 190C 80 DUP1 190D 84 DUP5 190E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1923 16 AND 1924 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1939 16 AND 193A 81 DUP2 193B 52 MSTORE 193C 60 PUSH1 0x20 193E 01 ADD 193F 90 SWAP1 1940 81 DUP2 1941 52 MSTORE 1942 60 PUSH1 0x20 1944 01 ADD 1945 60 PUSH1 0x00 1947 20 SHA3 1948 81 DUP2 1949 90 SWAP1 194A 55 SSTORE 194B 50 POP 194C 81 DUP2 194D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1962 16 AND 1963 60 PUSH1 0x00 1965 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 197A 16 AND 197B 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 199C 83 DUP4 199D 60 PUSH1 0x40 199F 51 MLOAD 19A0 80 DUP1 19A1 82 DUP3 19A2 81 DUP2 19A3 52 MSTORE 19A4 60 PUSH1 0x20 19A6 01 ADD 19A7 91 SWAP2 19A8 50 POP 19A9 50 POP 19AA 60 PUSH1 0x40 19AC 51 MLOAD 19AD 80 DUP1 19AE 91 SWAP2 19AF 03 SUB 19B0 90 SWAP1 19B1 A3 LOG3 19B2 50 POP 19B3 50 POP 19B4 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @193B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1941 memory[0x20:0x40] = 0x00 // @194A storage[keccak256(memory[0x00:0x40])] = stack[-1] // @19A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @19B1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-4] label_19B5: // Incoming call from 0x1523, returns to 0x1524 // Inputs[3] // { // @19BB stack[-2] // @19BC stack[-1] // @19C0 memory[0x40:0x60] // } 19B5 5B JUMPDEST 19B6 60 PUSH1 0x00 19B8 61 PUSH2 0x19f7 19BB 83 DUP4 19BC 83 DUP4 19BD 60 PUSH1 0x40 19BF 80 DUP1 19C0 51 MLOAD 19C1 90 SWAP1 19C2 81 DUP2 19C3 01 ADD 19C4 60 PUSH1 0x40 19C6 52 MSTORE 19C7 80 DUP1 19C8 60 PUSH1 0x1e 19CA 81 DUP2 19CB 52 MSTORE 19CC 60 PUSH1 0x20 19CE 01 ADD 19CF 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 19F0 81 DUP2 19F1 52 MSTORE 19F2 50 POP 19F3 61 PUSH2 0x11ec 19F6 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @19B6 stack[0] = 0x00 // @19B8 stack[1] = 0x19f7 // @19BB stack[2] = stack[-2] // @19BC stack[3] = stack[-1] // @19C1 stack[4] = memory[0x40:0x60] // @19C6 memory[0x40:0x60] = memory[0x40:0x60] + 0x40 // @19CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @19F1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // } // Block ends with call to 0x11ec, returns to 0x19F7 label_19F7: // Incoming return from call to 0x11EC at 0x19F6 // Inputs[4] // { // @19F8 stack[-2] // @19F8 stack[-1] // @19FA stack[-5] // @19FB stack[-4] // } 19F7 5B JUMPDEST 19F8 90 SWAP1 19F9 50 POP 19FA 92 SWAP3 19FB 91 SWAP2 19FC 50 POP 19FD 50 POP 19FE 56 *JUMP // Stack delta = -4 // Outputs[1] { @19FA stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_19FF: // Incoming call from 0x1677, returns to 0x1678 // Inputs[2] // { // @1A03 stack[-2] // @1A04 stack[-1] // } 19FF 5B JUMPDEST 1A00 61 PUSH2 0x1a09 1A03 82 DUP3 1A04 82 DUP3 1A05 61 PUSH2 0x1718 1A08 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A00 stack[0] = 0x1a09 // @1A03 stack[1] = stack[-2] // @1A04 stack[2] = stack[-1] // } // Block ends with call to 0x1718, returns to 0x1A09 label_1A09: // Incoming return from call to 0x1718 at 0x1A08 // Inputs[1] { @1A0A stack[-1] } 1A09 5B JUMPDEST 1A0A 15 ISZERO 1A0B 15 ISZERO 1A0C 15 ISZERO 1A0D 61 PUSH2 0x1a7e 1A10 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1a7e, if !!!stack[-1] label_1A11: // Incoming jump from 0x1A10, if not !!!stack[-1] // Inputs[3] // { // @1A13 memory[0x40:0x60] // @1A78 memory[0x40:0x60] // @1A7D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A11 60 PUSH1 0x40 1A13 51 MLOAD 1A14 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1A35 81 DUP2 1A36 52 MSTORE 1A37 60 PUSH1 0x04 1A39 01 ADD 1A3A 80 DUP1 1A3B 80 DUP1 1A3C 60 PUSH1 0x20 1A3E 01 ADD 1A3F 82 DUP3 1A40 81 DUP2 1A41 03 SUB 1A42 82 DUP3 1A43 52 MSTORE 1A44 60 PUSH1 0x1f 1A46 81 DUP2 1A47 52 MSTORE 1A48 60 PUSH1 0x20 1A4A 01 ADD 1A4B 80 DUP1 1A4C 7F PUSH32 0x526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500 1A6D 81 DUP2 1A6E 52 MSTORE 1A6F 50 POP 1A70 60 PUSH1 0x20 1A72 01 ADD 1A73 91 SWAP2 1A74 50 POP 1A75 50 POP 1A76 60 PUSH1 0x40 1A78 51 MLOAD 1A79 80 DUP1 1A7A 91 SWAP2 1A7B 03 SUB 1A7C 90 SWAP1 1A7D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1A36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1A43 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1A47 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1f // @1A6E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500 // @1A7D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A7E: // Incoming jump from 0x1A10, if !!!stack[-1] // Inputs[5] // { // @1A81 stack[-2] // @1A87 stack[-1] // @1AC1 memory[0x00:0x40] // @1AC9 storage[keccak256(memory[0x00:0x40])] // @1ADB stack[-3] // } 1A7E 5B JUMPDEST 1A7F 60 PUSH1 0x01 1A81 82 DUP3 1A82 60 PUSH1 0x00 1A84 01 ADD 1A85 60 PUSH1 0x00 1A87 83 DUP4 1A88 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A9D 16 AND 1A9E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AB3 16 AND 1AB4 81 DUP2 1AB5 52 MSTORE 1AB6 60 PUSH1 0x20 1AB8 01 ADD 1AB9 90 SWAP1 1ABA 81 DUP2 1ABB 52 MSTORE 1ABC 60 PUSH1 0x20 1ABE 01 ADD 1ABF 60 PUSH1 0x00 1AC1 20 SHA3 1AC2 60 PUSH1 0x00 1AC4 61 PUSH2 0x0100 1AC7 0A EXP 1AC8 81 DUP2 1AC9 54 SLOAD 1ACA 81 DUP2 1ACB 60 PUSH1 0xff 1ACD 02 MUL 1ACE 19 NOT 1ACF 16 AND 1AD0 90 SWAP1 1AD1 83 DUP4 1AD2 15 ISZERO 1AD3 15 ISZERO 1AD4 02 MUL 1AD5 17 OR 1AD6 90 SWAP1 1AD7 55 SSTORE 1AD8 50 POP 1AD9 50 POP 1ADA 50 POP 1ADB 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1AB5 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1ABB memory[0x20:0x40] = 0x00 + stack[-2] // @1AD7 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] label_1ADC: // Incoming call from 0x16D1, returns to 0x16D2 // Inputs[2] // { // @1AE0 stack[-2] // @1AE1 stack[-1] // } 1ADC 5B JUMPDEST 1ADD 61 PUSH2 0x1ae6 1AE0 82 DUP3 1AE1 82 DUP3 1AE2 61 PUSH2 0x1718 1AE5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1ADD stack[0] = 0x1ae6 // @1AE0 stack[1] = stack[-2] // @1AE1 stack[2] = stack[-1] // } // Block ends with call to 0x1718, returns to 0x1AE6 label_1AE6: // Incoming return from call to 0x1718 at 0x1AE5 // Inputs[1] { @1AE7 stack[-1] } 1AE6 5B JUMPDEST 1AE7 15 ISZERO 1AE8 15 ISZERO 1AE9 61 PUSH2 0x1b3d 1AEC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b3d, if !!stack[-1] label_1AED: // Incoming jump from 0x1AEC, if not !!stack[-1] // Inputs[3] // { // @1AEF memory[0x40:0x60] // @1B37 memory[0x40:0x60] // @1B3C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AED 60 PUSH1 0x40 1AEF 51 MLOAD 1AF0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1B11 81 DUP2 1B12 52 MSTORE 1B13 60 PUSH1 0x04 1B15 01 ADD 1B16 80 DUP1 1B17 80 DUP1 1B18 60 PUSH1 0x20 1B1A 01 ADD 1B1B 82 DUP3 1B1C 81 DUP2 1B1D 03 SUB 1B1E 82 DUP3 1B1F 52 MSTORE 1B20 60 PUSH1 0x21 1B22 81 DUP2 1B23 52 MSTORE 1B24 60 PUSH1 0x20 1B26 01 ADD 1B27 80 DUP1 1B28 61 PUSH2 0x1c59 1B2B 60 PUSH1 0x21 1B2D 91 SWAP2 1B2E 39 CODECOPY 1B2F 60 PUSH1 0x40 1B31 01 ADD 1B32 91 SWAP2 1B33 50 POP 1B34 50 POP 1B35 60 PUSH1 0x40 1B37 51 MLOAD 1B38 80 DUP1 1B39 91 SWAP2 1B3A 03 SUB 1B3B 90 SWAP1 1B3C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1B1F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1B23 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @1B2E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x1c59:0x1c7a] // @1B3C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B3D: // Incoming jump from 0x1AEC, if !!stack[-1] // Inputs[5] // { // @1B40 stack[-2] // @1B46 stack[-1] // @1B80 memory[0x00:0x40] // @1B88 storage[keccak256(memory[0x00:0x40])] // @1B9A stack[-3] // } 1B3D 5B JUMPDEST 1B3E 60 PUSH1 0x00 1B40 82 DUP3 1B41 60 PUSH1 0x00 1B43 01 ADD 1B44 60 PUSH1 0x00 1B46 83 DUP4 1B47 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B5C 16 AND 1B5D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B72 16 AND 1B73 81 DUP2 1B74 52 MSTORE 1B75 60 PUSH1 0x20 1B77 01 ADD 1B78 90 SWAP1 1B79 81 DUP2 1B7A 52 MSTORE 1B7B 60 PUSH1 0x20 1B7D 01 ADD 1B7E 60 PUSH1 0x00 1B80 20 SHA3 1B81 60 PUSH1 0x00 1B83 61 PUSH2 0x0100 1B86 0A EXP 1B87 81 DUP2 1B88 54 SLOAD 1B89 81 DUP2 1B8A 60 PUSH1 0xff 1B8C 02 MUL 1B8D 19 NOT 1B8E 16 AND 1B8F 90 SWAP1 1B90 83 DUP4 1B91 15 ISZERO 1B92 15 ISZERO 1B93 02 MUL 1B94 17 OR 1B95 90 SWAP1 1B96 55 SSTORE 1B97 50 POP 1B98 50 POP 1B99 50 POP 1B9A 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1B74 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1B7A memory[0x20:0x40] = 0x00 + stack[-2] // @1B96 storage[keccak256(memory[0x00:0x40])] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-3] 1B9B FE *ASSERT 1B9C 45 GASLIMIT 1B9D 52 MSTORE 1B9E 43 NUMBER 1B9F 32 ORIGIN 1BA0 30 ADDRESS 1BA1 3A GASPRICE 1BA2 20 SHA3 1BA3 74 PUSH21 0x72616e7366657220746f20746865207a65726f2061 1BB9 64 PUSH5 0x6472657373 1BBF 45 GASLIMIT 1BC0 52 MSTORE 1BC1 43 NUMBER 1BC2 32 ORIGIN 1BC3 30 ADDRESS 1BC4 3A GASPRICE 1BC5 20 SHA3 1BC6 62 PUSH3 0x75726e 1BCA 20 SHA3 1BCB 61 PUSH2 0x6d6f 1BCE 75 PUSH22 0x6e7420657863656564732062616c616e636545524332 1BE5 30 ADDRESS 1BE6 3A GASPRICE 1BE7 20 SHA3 1BE8 61 PUSH2 0x7070 1BEB 72 PUSH19 0x6f766520746f20746865207a65726f20616464 1BFF 72 PUSH19 0x65737345524332303a207472616e7366657220 1C13 61 PUSH2 0x6d6f 1C16 75 PUSH22 0x6e7420657863656564732062616c616e63654d696e74 1C2D 65 PUSH6 0x72526f6c653a 1C34 20 SHA3 1C35 63 PUSH4 0x616c6c65 1C3A 72 PUSH19 0x20646f6573206e6f7420686176652074686520 1C4E 4D 4D 1C4F 69 PUSH10 0x6e74657220726f6c6552 1C5A 6F PUSH16 0x6c65733a206163636f756e7420646f65 1C6B 73 PUSH20 0x206e6f74206861766520726f6c6545524332303a 1C80 20 SHA3 1C81 74 PUSH21 0x72616e7366657220616d6f756e7420657863656564 1C97 73 PUSH20 0x20616c6c6f77616e6365526f6c65733a20616363 1CAC 6F PUSH16 0x756e7420697320746865207a65726f20 1CBD 61 PUSH2 0x6464 1CC0 72 PUSH19 0x65737345524332303a206275726e20616d6f75 1CD4 6E PUSH15 0x74206578636565647320616c6c6f77 1CE4 61 PUSH2 0x6e63 1CE7 65 PUSH6 0x45524332303a 1CEE 20 SHA3 1CEF 62 PUSH3 0x75726e 1CF3 20 SHA3 1CF4 66 PUSH7 0x726f6d20746865 1CFC 20 SHA3 1CFD 7A PUSH27 0x65726f206164647265737345524332303a207472616e7366657220 1D19 66 PUSH7 0x726f6d20746865 1D21 20 SHA3 1D22 7A PUSH27 0x65726f206164647265737345524332303a20617070726f76652066 1D3E 72 PUSH19 0x6f6d20746865207a65726f2061646472657373 1D52 45 GASLIMIT 1D53 52 MSTORE 1D54 43 NUMBER 1D55 32 ORIGIN 1D56 30 ADDRESS 1D57 3A GASPRICE 1D58 20 SHA3 1D59 64 PUSH5 0x6563726561 1D5F 73 PUSH20 0x656420616c6c6f77616e63652062656c6f77207a 1D74 65 PUSH6 0x726fa165627a 1D7B 7A PUSH27 0x72305820c163959f9f71bf275c3c102bd5fa2be1e168e5f999ecf8 1D97 FF *SELFDESTRUCT 1D98 F8 F8 1D99 C4 C4 1D9A B3 B3 1D9B FC FC 1D9C 99 SWAP10 1D9D DE DE 1D9E DD DD 1D9F 42 TIMESTAMP 1DA0 00 *STOP 1DA1 29 29