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 0x000f 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x000f, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000E memory[0x00:0x00] } 000C 5F PUSH0 000D 80 DUP1 000E FD *REVERT // Stack delta = +0 // Outputs[1] { @000E revert(memory[0x00:0x00]); } // Block terminates label_000F: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0013 msg.data.length } 000F 5B JUMPDEST 0010 50 POP 0011 60 PUSH1 0x04 0013 36 CALLDATASIZE 0014 10 LT 0015 61 PUSH2 0x00a6 0018 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00a6, if msg.data.length < 0x04 label_0019: // Incoming jump from 0x0018, if not msg.data.length < 0x04 // Inputs[1] { @001A msg.data[0x00:0x20] } 0019 5F PUSH0 001A 35 CALLDATALOAD 001B 60 PUSH1 0xe0 001D 1C SHR 001E 80 DUP1 001F 63 PUSH4 0x39509351 0024 11 GT 0025 61 PUSH2 0x006e 0028 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001D stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x006e, if 0x39509351 > msg.data[0x00:0x20] >> 0xe0 label_0029: // Incoming jump from 0x0028, if not 0x39509351 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0x39509351 002F 14 EQ 0030 61 PUSH2 0x0141 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0141, if 0x39509351 == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0x39509351 == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0x70a08231 003A 14 EQ 003B 61 PUSH2 0x0154 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0154, if 0x70a08231 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0x70a08231 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0x95d89b41 0045 14 EQ 0046 61 PUSH2 0x017c 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x017c, if 0x95d89b41 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0x95d89b41 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xa457c2d7 0050 14 EQ 0051 61 PUSH2 0x0184 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0184, if 0xa457c2d7 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xa457c2d7 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xa9059cbb 005B 14 EQ 005C 61 PUSH2 0x0197 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0197, if 0xa9059cbb == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xdd62ed3e 0066 14 EQ 0067 61 PUSH2 0x01aa 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01aa, if 0xdd62ed3e == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @006D memory[0x00:0x00] } 006B 5F PUSH0 006C 80 DUP1 006D FD *REVERT // Stack delta = +0 // Outputs[1] { @006D revert(memory[0x00:0x00]); } // Block terminates label_006E: // Incoming jump from 0x0028, if 0x39509351 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @006F stack[-1] } 006E 5B JUMPDEST 006F 80 DUP1 0070 63 PUSH4 0x06fdde03 0075 14 EQ 0076 61 PUSH2 0x00aa 0079 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00aa, if 0x06fdde03 == stack[-1] label_007A: // Incoming jump from 0x0079, if not 0x06fdde03 == stack[-1] // Inputs[1] { @007A stack[-1] } 007A 80 DUP1 007B 63 PUSH4 0x095ea7b3 0080 14 EQ 0081 61 PUSH2 0x00c8 0084 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c8, if 0x095ea7b3 == stack[-1] label_0085: // Incoming jump from 0x0084, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0085 stack[-1] } 0085 80 DUP1 0086 63 PUSH4 0x18160ddd 008B 14 EQ 008C 61 PUSH2 0x00eb 008F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00eb, if 0x18160ddd == stack[-1] label_0090: // Incoming jump from 0x008F, if not 0x18160ddd == stack[-1] // Inputs[1] { @0090 stack[-1] } 0090 80 DUP1 0091 63 PUSH4 0x23b872dd 0096 14 EQ 0097 61 PUSH2 0x00fd 009A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fd, if 0x23b872dd == stack[-1] label_009B: // Incoming jump from 0x009A, if not 0x23b872dd == stack[-1] // Inputs[1] { @009B stack[-1] } 009B 80 DUP1 009C 63 PUSH4 0x313ce567 00A1 14 EQ 00A2 61 PUSH2 0x0110 00A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0110, if 0x313ce567 == stack[-1] label_00A6: // Incoming jump from 0x00A5, if not 0x313ce567 == stack[-1] // Incoming jump from 0x0018, if msg.data.length < 0x04 // Inputs[1] { @00A9 memory[0x00:0x00] } 00A6 5B JUMPDEST 00A7 5F PUSH0 00A8 80 DUP1 00A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A9 revert(memory[0x00:0x00]); } // Block terminates label_00AA: // Incoming jump from 0x0079, if 0x06fdde03 == stack[-1] 00AA 5B JUMPDEST 00AB 61 PUSH2 0x00b2 00AE 61 PUSH2 0x01bd 00B1 56 *JUMP // Stack delta = +1 // Outputs[1] { @00AB stack[0] = 0x00b2 } // Block ends with call to 0x01bd, returns to 0x00B2 label_00B2: // Incoming return from call to 0x01BD at 0x00B1 // Incoming return from call to 0x02AA at 0x0183 // Inputs[2] // { // @00B5 memory[0x40:0x60] // @00B9 stack[-1] // } 00B2 5B JUMPDEST 00B3 60 PUSH1 0x40 00B5 51 MLOAD 00B6 61 PUSH2 0x00bf 00B9 91 SWAP2 00BA 90 SWAP1 00BB 61 PUSH2 0x06ac 00BE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00B9 stack[-1] = 0x00bf // @00BA stack[1] = memory[0x40:0x60] // @00BA stack[0] = stack[-1] // } // Block ends with call to 0x06ac, returns to 0x00BF label_00BF: // Incoming jump from 0x00EA // Incoming jump from 0x00FC // Incoming jump from 0x0140 // Incoming jump from 0x00FC // Incoming return from call to 0x06AC at 0x00BE // Inputs[3] // { // @00C2 memory[0x40:0x60] // @00C4 stack[-1] // @00C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00BF 5B JUMPDEST 00C0 60 PUSH1 0x40 00C2 51 MLOAD 00C3 80 DUP1 00C4 91 SWAP2 00C5 03 SUB 00C6 90 SWAP1 00C7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @00C7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_00C8: // Incoming jump from 0x0084, if 0x095ea7b3 == stack[-1] // Inputs[1] { @00CF msg.data.length } 00C8 5B JUMPDEST 00C9 61 PUSH2 0x00db 00CC 61 PUSH2 0x00d6 00CF 36 CALLDATASIZE 00D0 60 PUSH1 0x04 00D2 61 PUSH2 0x0712 00D5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00C9 stack[0] = 0x00db // @00CC stack[1] = 0x00d6 // @00CF stack[2] = msg.data.length // @00D0 stack[3] = 0x04 // } // Block ends with call to 0x0712, returns to 0x00D6 label_00D6: // Incoming return from call to 0x0712 at 0x00D5 00D6 5B JUMPDEST 00D7 61 PUSH2 0x024d 00DA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x024d label_00DB: // Incoming return from call to 0x0192 at 0x0191 // Incoming return from call to 0x01A5 at 0x01A4 // Incoming return from call to 0x00D6 at 0x00D5 // Inputs[2] // { // @00DE memory[0x40:0x60] // @00DF stack[-1] // } 00DB 5B JUMPDEST 00DC 60 PUSH1 0x40 00DE 51 MLOAD 00DF 90 SWAP1 00E0 15 ISZERO 00E1 15 ISZERO 00E2 81 DUP2 00E3 52 MSTORE 00E4 60 PUSH1 0x20 00E6 01 ADD 00E7 61 PUSH2 0x00bf 00EA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @00E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @00E6 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00bf label_00EB: // Incoming jump from 0x008F, if 0x18160ddd == stack[-1] // Inputs[2] // { // @00EE storage[0x02] // @00F2 memory[0x40:0x60] // } 00EB 5B JUMPDEST 00EC 60 PUSH1 0x02 00EE 54 SLOAD 00EF 5B JUMPDEST 00F0 60 PUSH1 0x40 00F2 51 MLOAD 00F3 90 SWAP1 00F4 81 DUP2 00F5 52 MSTORE 00F6 60 PUSH1 0x20 00F8 01 ADD 00F9 61 PUSH2 0x00bf 00FC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @00F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x02] // @00F8 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00bf label_00FD: // Incoming jump from 0x009A, if 0x23b872dd == stack[-1] // Inputs[1] { @0104 msg.data.length } 00FD 5B JUMPDEST 00FE 61 PUSH2 0x00db 0101 61 PUSH2 0x010b 0104 36 CALLDATASIZE 0105 60 PUSH1 0x04 0107 61 PUSH2 0x073a 010A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00FE stack[0] = 0x00db // @0101 stack[1] = 0x010b // @0104 stack[2] = msg.data.length // @0105 stack[3] = 0x04 // } // Block ends with call to 0x073a, returns to 0x010B label_010B: // Incoming return from call to 0x073A at 0x010A 010B 5B JUMPDEST 010C 61 PUSH2 0x0266 010F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0266 label_0110: // Incoming jump from 0x00A5, if 0x313ce567 == stack[-1] // Inputs[1] { @0113 memory[0x40:0x60] } 0110 5B JUMPDEST 0111 60 PUSH1 0x40 0113 51 MLOAD 0114 60 PUSH1 0xff 0116 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000012 0137 16 AND 0138 81 DUP2 0139 52 MSTORE 013A 60 PUSH1 0x20 013C 01 ADD 013D 61 PUSH2 0x00bf 0140 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0139 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0000000000000000000000000000000000000000000000000000000000000012 & 0xff // @013C stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00bf label_0141: // Incoming jump from 0x0033, if 0x39509351 == stack[-1] // Inputs[1] { @0148 msg.data.length } 0141 5B JUMPDEST 0142 61 PUSH2 0x00db 0145 61 PUSH2 0x014f 0148 36 CALLDATASIZE 0149 60 PUSH1 0x04 014B 61 PUSH2 0x0712 014E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0142 stack[0] = 0x00db // @0145 stack[1] = 0x014f // @0148 stack[2] = msg.data.length // @0149 stack[3] = 0x04 // } // Block ends with call to 0x0712, returns to 0x014F label_014F: // Incoming return from call to 0x0712 at 0x014E 014F 5B JUMPDEST 0150 61 PUSH2 0x0289 0153 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0289 label_0154: // Incoming jump from 0x003E, if 0x70a08231 == stack[-1] // Inputs[1] { @015B msg.data.length } 0154 5B JUMPDEST 0155 61 PUSH2 0x00ef 0158 61 PUSH2 0x0162 015B 36 CALLDATASIZE 015C 60 PUSH1 0x04 015E 61 PUSH2 0x0773 0161 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0155 stack[0] = 0x00ef // @0158 stack[1] = 0x0162 // @015B stack[2] = msg.data.length // @015C stack[3] = 0x04 // } // Block ends with call to 0x0773, returns to 0x0162 label_0162: // Incoming return from call to 0x0773 at 0x0161 // Inputs[4] // { // @016B stack[-1] // @0178 memory[0x00:0x40] // @0179 storage[keccak256(memory[0x00:0x40])] // @017A stack[-2] // } 0162 5B JUMPDEST 0163 60 PUSH1 0x01 0165 60 PUSH1 0x01 0167 60 PUSH1 0xa0 0169 1B SHL 016A 03 SUB 016B 16 AND 016C 5F PUSH0 016D 90 SWAP1 016E 81 DUP2 016F 52 MSTORE 0170 60 PUSH1 0x20 0172 81 DUP2 0173 90 SWAP1 0174 52 MSTORE 0175 60 PUSH1 0x40 0177 90 SWAP1 0178 20 SHA3 0179 54 SLOAD 017A 90 SWAP1 017B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @016F memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0174 memory[0x20:0x40] = 0x00 // @017A stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_017C: // Incoming jump from 0x0049, if 0x95d89b41 == stack[-1] 017C 5B JUMPDEST 017D 61 PUSH2 0x00b2 0180 61 PUSH2 0x02aa 0183 56 *JUMP // Stack delta = +1 // Outputs[1] { @017D stack[0] = 0x00b2 } // Block ends with call to 0x02aa, returns to 0x00B2 label_0184: // Incoming jump from 0x0054, if 0xa457c2d7 == stack[-1] // Inputs[1] { @018B msg.data.length } 0184 5B JUMPDEST 0185 61 PUSH2 0x00db 0188 61 PUSH2 0x0192 018B 36 CALLDATASIZE 018C 60 PUSH1 0x04 018E 61 PUSH2 0x0712 0191 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0185 stack[0] = 0x00db // @0188 stack[1] = 0x0192 // @018B stack[2] = msg.data.length // @018C stack[3] = 0x04 // } // Block ends with call to 0x0712, returns to 0x0192 label_0192: // Incoming return from call to 0x0712 at 0x0191 0192 5B JUMPDEST 0193 61 PUSH2 0x02b9 0196 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b9 label_0197: // Incoming jump from 0x005F, if 0xa9059cbb == stack[-1] // Inputs[1] { @019E msg.data.length } 0197 5B JUMPDEST 0198 61 PUSH2 0x00db 019B 61 PUSH2 0x01a5 019E 36 CALLDATASIZE 019F 60 PUSH1 0x04 01A1 61 PUSH2 0x0712 01A4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0198 stack[0] = 0x00db // @019B stack[1] = 0x01a5 // @019E stack[2] = msg.data.length // @019F stack[3] = 0x04 // } // Block ends with call to 0x0712, returns to 0x01A5 label_01A5: // Incoming return from call to 0x0712 at 0x01A4 01A5 5B JUMPDEST 01A6 61 PUSH2 0x0338 01A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0338 label_01AA: // Incoming jump from 0x006A, if 0xdd62ed3e == stack[-1] // Inputs[1] { @01B1 msg.data.length } 01AA 5B JUMPDEST 01AB 61 PUSH2 0x00ef 01AE 61 PUSH2 0x01b8 01B1 36 CALLDATASIZE 01B2 60 PUSH1 0x04 01B4 61 PUSH2 0x0793 01B7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01AB stack[0] = 0x00ef // @01AE stack[1] = 0x01b8 // @01B1 stack[2] = msg.data.length // @01B2 stack[3] = 0x04 // } // Block ends with call to 0x0793, returns to 0x01B8 label_01B8: // Incoming return from call to 0x0793 at 0x01B7 01B8 5B JUMPDEST 01B9 61 PUSH2 0x0345 01BC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0345 label_01BD: // Incoming call from 0x00B1, returns to 0x00B2 // Inputs[1] { @01C3 storage[0x03] } 01BD 5B JUMPDEST 01BE 60 PUSH1 0x60 01C0 60 PUSH1 0x03 01C2 80 DUP1 01C3 54 SLOAD 01C4 61 PUSH2 0x01cc 01C7 90 SWAP1 01C8 61 PUSH2 0x07c4 01CB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01BE stack[0] = 0x60 // @01C0 stack[1] = 0x03 // @01C7 stack[2] = 0x01cc // @01C7 stack[3] = storage[0x03] // } // Block ends with call to 0x07c4, returns to 0x01CC label_01CC: // Incoming return from call to 0x07C4 at 0x01CB // Incoming return from call to 0x07C4 at 0x02B8 // Inputs[4] // { // @01CD stack[-1] // @01DC memory[0x40:0x60] // @01E4 stack[-2] // @01EF storage[stack[-2]] // } 01CC 5B JUMPDEST 01CD 80 DUP1 01CE 60 PUSH1 0x1f 01D0 01 ADD 01D1 60 PUSH1 0x20 01D3 80 DUP1 01D4 91 SWAP2 01D5 04 DIV 01D6 02 MUL 01D7 60 PUSH1 0x20 01D9 01 ADD 01DA 60 PUSH1 0x40 01DC 51 MLOAD 01DD 90 SWAP1 01DE 81 DUP2 01DF 01 ADD 01E0 60 PUSH1 0x40 01E2 52 MSTORE 01E3 80 DUP1 01E4 92 SWAP3 01E5 91 SWAP2 01E6 90 SWAP1 01E7 81 DUP2 01E8 81 DUP2 01E9 52 MSTORE 01EA 60 PUSH1 0x20 01EC 01 ADD 01ED 82 DUP3 01EE 80 DUP1 01EF 54 SLOAD 01F0 61 PUSH2 0x01f8 01F3 90 SWAP1 01F4 61 PUSH2 0x07c4 01F7 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @01E2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @01E4 stack[-2] = memory[0x40:0x60] // @01E5 stack[-1] = stack[-2] // @01E6 stack[0] = stack[-1] // @01E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01EC stack[1] = 0x20 + memory[0x40:0x60] // @01ED stack[2] = stack[-2] // @01F3 stack[4] = storage[stack[-2]] // @01F3 stack[3] = 0x01f8 // } // Block ends with call to 0x07c4, returns to 0x01F8 label_01F8: // Incoming return from call to 0x07C4 at 0x01F7 // Inputs[1] { @01F9 stack[-1] } 01F8 5B JUMPDEST 01F9 80 DUP1 01FA 15 ISZERO 01FB 61 PUSH2 0x0243 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0243, if !stack[-1] label_01FF: // Incoming jump from 0x01FE, if not !stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 60 PUSH1 0x1f 0202 10 LT 0203 61 PUSH2 0x021a 0206 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021a, if 0x1f < stack[-1] label_0207: // Incoming jump from 0x0206, if not 0x1f < stack[-1] // Inputs[4] // { // @020B stack[-2] // @020C storage[stack[-2]] // @020F stack[-3] // @0211 stack[-1] // } 0207 61 PUSH2 0x0100 020A 80 DUP1 020B 83 DUP4 020C 54 SLOAD 020D 04 DIV 020E 02 MUL 020F 83 DUP4 0210 52 MSTORE 0211 91 SWAP2 0212 60 PUSH1 0x20 0214 01 ADD 0215 91 SWAP2 0216 61 PUSH2 0x0243 0219 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0210 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0215 stack[-1] = stack[-1] // @0215 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0243 label_021A: // Incoming jump from 0x0206, if 0x1f < stack[-1] // Inputs[5] // { // @021B stack[-3] // @021C stack[-1] // @021E stack[-2] // @0224 memory[0x00:0x20] // @0228 storage[keccak256(memory[0x00:0x20])] // } 021A 5B JUMPDEST 021B 82 DUP3 021C 01 ADD 021D 91 SWAP2 021E 90 SWAP1 021F 5F PUSH0 0220 52 MSTORE 0221 60 PUSH1 0x20 0223 5F PUSH0 0224 20 SHA3 0225 90 SWAP1 0226 5B JUMPDEST 0227 81 DUP2 0228 54 SLOAD 0229 81 DUP2 022A 52 MSTORE 022B 90 SWAP1 022C 60 PUSH1 0x01 022E 01 ADD 022F 90 SWAP1 0230 60 PUSH1 0x20 0232 01 ADD 0233 80 DUP1 0234 83 DUP4 0235 11 GT 0236 61 PUSH2 0x0226 0239 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @021D stack[-3] = stack[-3] + stack[-1] // @0220 memory[0x00:0x20] = stack[-2] // @022A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @022F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0232 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0226, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_023A: // Incoming jump from 0x0239, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0239, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @023A stack[-3] // @023B stack[-1] // } 023A 82 DUP3 023B 90 SWAP1 023C 03 SUB 023D 60 PUSH1 0x1f 023F 16 AND 0240 82 DUP3 0241 01 ADD 0242 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0242 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0242 stack[-1] = stack[-3] // } // Block continues label_0243: // Incoming jump from 0x01FE, if !stack[-1] // Incoming jump from 0x0219 // Incoming jump from 0x0242 // Inputs[3] // { // @0249 stack[-6] // @0249 stack[-7] // @024B stack[-8] // } 0243 5B JUMPDEST 0244 50 POP 0245 50 POP 0246 50 POP 0247 50 POP 0248 50 POP 0249 90 SWAP1 024A 50 POP 024B 90 SWAP1 024C 56 *JUMP // Stack delta = -7 // Outputs[1] { @024B stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_024D: // Incoming jump from 0x00DA // Inputs[3] // { // @024F msg.sender // @0254 stack[-2] // @0255 stack[-1] // } 024D 5B JUMPDEST 024E 5F PUSH0 024F 33 CALLER 0250 61 PUSH2 0x025a 0253 81 DUP2 0254 85 DUP6 0255 85 DUP6 0256 61 PUSH2 0x036f 0259 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @024E stack[0] = 0x00 // @024F stack[1] = msg.sender // @0250 stack[2] = 0x025a // @0253 stack[3] = msg.sender // @0254 stack[4] = stack[-2] // @0255 stack[5] = stack[-1] // } // Block ends with call to 0x036f, returns to 0x025A label_025A: // Incoming return from call to 0x050A at 0x0344 // Incoming return from call to 0x029B at 0x029A // Incoming return from call to 0x036F at 0x0259 // Inputs[3] // { // @025D stack[-2] // @0261 stack[-5] // @0262 stack[-4] // } 025A 5B JUMPDEST 025B 60 PUSH1 0x01 025D 91 SWAP2 025E 50 POP 025F 50 POP 0260 5B JUMPDEST 0261 92 SWAP3 0262 91 SWAP2 0263 50 POP 0264 50 POP 0265 56 *JUMP // Stack delta = -4 // Outputs[1] { @0261 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0266: // Incoming jump from 0x010F // Inputs[3] // { // @0268 msg.sender // @026C stack[-3] // @026E stack[-1] // } 0266 5B JUMPDEST 0267 5F PUSH0 0268 33 CALLER 0269 61 PUSH2 0x0273 026C 85 DUP6 026D 82 DUP3 026E 85 DUP6 026F 61 PUSH2 0x0492 0272 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0267 stack[0] = 0x00 // @0268 stack[1] = msg.sender // @0269 stack[2] = 0x0273 // @026C stack[3] = stack[-3] // @026D stack[4] = msg.sender // @026E stack[5] = stack[-1] // } // Block ends with call to 0x0492, returns to 0x0273 label_0273: // Incoming return from call to 0x0492 at 0x0272 // Inputs[3] // { // @0277 stack[-5] // @0278 stack[-4] // @0279 stack[-3] // } 0273 5B JUMPDEST 0274 61 PUSH2 0x027e 0277 85 DUP6 0278 85 DUP6 0279 85 DUP6 027A 61 PUSH2 0x050a 027D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0274 stack[0] = 0x027e // @0277 stack[1] = stack[-5] // @0278 stack[2] = stack[-4] // @0279 stack[3] = stack[-3] // } // Block ends with call to 0x050a, returns to 0x027E label_027E: // Incoming return from call to 0x050A at 0x027D // Incoming return from call to 0x036F at 0x0337 // Inputs[2] // { // @0282 stack[-6] // @0283 stack[-5] // } 027E 5B JUMPDEST 027F 50 POP 0280 60 PUSH1 0x01 0282 94 SWAP5 0283 93 SWAP4 0284 50 POP 0285 50 POP 0286 50 POP 0287 50 POP 0288 56 *JUMP // Stack delta = -5 // Outputs[1] { @0282 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_0289: // Incoming jump from 0x0153 // Inputs[3] // { // @028B msg.sender // @0290 stack[-2] // @0291 stack[-1] // } 0289 5B JUMPDEST 028A 5F PUSH0 028B 33 CALLER 028C 61 PUSH2 0x025a 028F 81 DUP2 0290 85 DUP6 0291 85 DUP6 0292 61 PUSH2 0x029b 0295 83 DUP4 0296 83 DUP4 0297 61 PUSH2 0x0345 029A 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @028A stack[0] = 0x00 // @028B stack[1] = msg.sender // @028C stack[2] = 0x025a // @028F stack[3] = msg.sender // @0290 stack[4] = stack[-2] // @0291 stack[5] = stack[-1] // @0292 stack[6] = 0x029b // @0295 stack[7] = msg.sender // @0296 stack[8] = stack[-2] // } // Block ends with call to 0x0345, returns to 0x029B label_029B: // Incoming return from call to 0x0345 at 0x029A // Inputs[2] // { // @029F stack[-2] // @02A0 stack[-1] // } 029B 5B JUMPDEST 029C 61 PUSH2 0x02a5 029F 91 SWAP2 02A0 90 SWAP1 02A1 61 PUSH2 0x07fc 02A4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @029F stack[-2] = 0x02a5 // @02A0 stack[-1] = stack[-2] // @02A0 stack[0] = stack[-1] // } // Block ends with call to 0x07fc, returns to 0x02A5 label_02A5: // Incoming return from call to 0x07FC at 0x02A4 02A5 5B JUMPDEST 02A6 61 PUSH2 0x036f 02A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x036f label_02AA: // Incoming call from 0x0183, returns to 0x00B2 // Inputs[1] { @02B0 storage[0x04] } 02AA 5B JUMPDEST 02AB 60 PUSH1 0x60 02AD 60 PUSH1 0x04 02AF 80 DUP1 02B0 54 SLOAD 02B1 61 PUSH2 0x01cc 02B4 90 SWAP1 02B5 61 PUSH2 0x07c4 02B8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AB stack[0] = 0x60 // @02AD stack[1] = 0x04 // @02B4 stack[2] = 0x01cc // @02B4 stack[3] = storage[0x04] // } // Block ends with call to 0x07c4, returns to 0x01CC label_02B9: // Incoming jump from 0x0196 // Inputs[2] // { // @02BB msg.sender // @02C1 stack[-2] // } 02B9 5B JUMPDEST 02BA 5F PUSH0 02BB 33 CALLER 02BC 81 DUP2 02BD 61 PUSH2 0x02c6 02C0 82 DUP3 02C1 86 DUP7 02C2 61 PUSH2 0x0345 02C5 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @02BA stack[0] = 0x00 // @02BB stack[1] = msg.sender // @02BC stack[2] = 0x00 // @02BD stack[3] = 0x02c6 // @02C0 stack[4] = msg.sender // @02C1 stack[5] = stack[-2] // } // Block ends with call to 0x0345, returns to 0x02C6 label_02C6: // Incoming return from call to 0x0345 at 0x02C5 // Inputs[3] // { // @02C7 stack[-2] // @02C7 stack[-1] // @02C9 stack[-5] // } 02C6 5B JUMPDEST 02C7 90 SWAP1 02C8 50 POP 02C9 83 DUP4 02CA 81 DUP2 02CB 10 LT 02CC 15 ISZERO 02CD 61 PUSH2 0x032b 02D0 57 *JUMPI // Stack delta = -1 // Outputs[1] { @02C7 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x032b, if !(stack[-1] < stack[-5]) label_02D1: // Incoming jump from 0x02D0, if not !(stack[-1] < stack[-5]) // Inputs[1] { @02D3 memory[0x40:0x60] } 02D1 60 PUSH1 0x40 02D3 51 MLOAD 02D4 62 PUSH3 0x461bcd 02D8 60 PUSH1 0xe5 02DA 1B SHL 02DB 81 DUP2 02DC 52 MSTORE 02DD 60 PUSH1 0x20 02DF 60 PUSH1 0x04 02E1 82 DUP3 02E2 01 ADD 02E3 52 MSTORE 02E4 60 PUSH1 0x25 02E6 60 PUSH1 0x24 02E8 82 DUP3 02E9 01 ADD 02EA 52 MSTORE 02EB 7F PUSH32 0x45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77 030C 60 PUSH1 0x44 030E 82 DUP3 030F 01 ADD 0310 52 MSTORE 0311 64 PUSH5 0x207a65726f 0317 60 PUSH1 0xd8 0319 1B SHL 031A 60 PUSH1 0x64 031C 82 DUP3 031D 01 ADD 031E 52 MSTORE 031F 60 PUSH1 0x84 0321 01 ADD // Stack delta = +1 // Outputs[6] // { // @02DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @02E3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @02EA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @0310 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77 // @031E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x207a65726f << 0xd8 // @0321 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0322: // Incoming jump from 0x0321 // Incoming jump from 0x04F6 // Incoming jump from 0x0431 // Incoming jump from 0x056D // Incoming jump from 0x0646 // Incoming jump from 0x03D0 // Incoming jump from 0x05CF // Inputs[3] // { // @0325 memory[0x40:0x60] // @0327 stack[-1] // @032A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0322 5B JUMPDEST 0323 60 PUSH1 0x40 0325 51 MLOAD 0326 80 DUP1 0327 91 SWAP2 0328 03 SUB 0329 90 SWAP1 032A FD *REVERT // Stack delta = -1 // Outputs[1] { @032A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_032B: // Incoming jump from 0x02D0, if !(stack[-1] < stack[-5]) // Inputs[4] // { // @032F stack[-2] // @0330 stack[-5] // @0331 stack[-4] // @0332 stack[-1] // } 032B 5B JUMPDEST 032C 61 PUSH2 0x027e 032F 82 DUP3 0330 86 DUP7 0331 86 DUP7 0332 84 DUP5 0333 03 SUB 0334 61 PUSH2 0x036f 0337 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @032C stack[0] = 0x027e // @032F stack[1] = stack[-2] // @0330 stack[2] = stack[-5] // @0333 stack[3] = stack[-1] - stack[-4] // } // Block ends with call to 0x036f, returns to 0x027E label_0338: // Incoming jump from 0x01A9 // Inputs[3] // { // @033A msg.sender // @033F stack[-2] // @0340 stack[-1] // } 0338 5B JUMPDEST 0339 5F PUSH0 033A 33 CALLER 033B 61 PUSH2 0x025a 033E 81 DUP2 033F 85 DUP6 0340 85 DUP6 0341 61 PUSH2 0x050a 0344 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0339 stack[0] = 0x00 // @033A stack[1] = msg.sender // @033B stack[2] = 0x025a // @033E stack[3] = msg.sender // @033F stack[4] = stack[-2] // @0340 stack[5] = stack[-1] // } // Block ends with call to 0x050a, returns to 0x025A label_0345: // Incoming call from 0x049C, returns to 0x049D // Incoming call from 0x029A, returns to 0x029B // Incoming call from 0x02C5, returns to 0x02C6 // Incoming jump from 0x01BC // Inputs[6] // { // @034E stack[-2] // @0360 memory[0x00:0x40] // @0361 stack[-1] // @036B memory[0x00:0x40] // @036C storage[keccak256(memory[0x00:0x40])] // @036D stack[-3] // } 0345 5B JUMPDEST 0346 60 PUSH1 0x01 0348 60 PUSH1 0x01 034A 60 PUSH1 0xa0 034C 1B SHL 034D 03 SUB 034E 91 SWAP2 034F 82 DUP3 0350 16 AND 0351 5F PUSH0 0352 90 SWAP1 0353 81 DUP2 0354 52 MSTORE 0355 60 PUSH1 0x01 0357 60 PUSH1 0x20 0359 90 SWAP1 035A 81 DUP2 035B 52 MSTORE 035C 60 PUSH1 0x40 035E 80 DUP1 035F 83 DUP4 0360 20 SHA3 0361 93 SWAP4 0362 90 SWAP1 0363 94 SWAP5 0364 16 AND 0365 82 DUP3 0366 52 MSTORE 0367 91 SWAP2 0368 90 SWAP1 0369 91 SWAP2 036A 52 MSTORE 036B 20 SHA3 036C 54 SLOAD 036D 90 SWAP1 036E 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0354 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @035B memory[0x20:0x40] = 0x01 // @0366 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @036A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @036D stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_036F: // Incoming jump from 0x02A9 // Incoming call from 0x0259, returns to 0x025A // Incoming call from 0x0503, returns to 0x0504 // Incoming call from 0x0337, returns to 0x027E // Inputs[1] { @0378 stack[-3] } 036F 5B JUMPDEST 0370 60 PUSH1 0x01 0372 60 PUSH1 0x01 0374 60 PUSH1 0xa0 0376 1B SHL 0377 03 SUB 0378 83 DUP4 0379 16 AND 037A 61 PUSH2 0x03d1 037D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d1, if stack[-3] & (0x01 << 0xa0) - 0x01 label_037E: // Incoming jump from 0x037D, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0380 memory[0x40:0x60] } 037E 60 PUSH1 0x40 0380 51 MLOAD 0381 62 PUSH3 0x461bcd 0385 60 PUSH1 0xe5 0387 1B SHL 0388 81 DUP2 0389 52 MSTORE 038A 60 PUSH1 0x20 038C 60 PUSH1 0x04 038E 82 DUP3 038F 01 ADD 0390 52 MSTORE 0391 60 PUSH1 0x24 0393 80 DUP1 0394 82 DUP3 0395 01 ADD 0396 52 MSTORE 0397 7F PUSH32 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464 03B8 60 PUSH1 0x44 03BA 82 DUP3 03BB 01 ADD 03BC 52 MSTORE 03BD 63 PUSH4 0x72657373 03C2 60 PUSH1 0xe0 03C4 1B SHL 03C5 60 PUSH1 0x64 03C7 82 DUP3 03C8 01 ADD 03C9 52 MSTORE 03CA 60 PUSH1 0x84 03CC 01 ADD 03CD 61 PUSH2 0x0322 03D0 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0389 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0390 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0396 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @03BC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464 // @03C9 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72657373 << 0xe0 // @03CC stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0322 label_03D1: // Incoming jump from 0x037D, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @03DA stack[-2] } 03D1 5B JUMPDEST 03D2 60 PUSH1 0x01 03D4 60 PUSH1 0x01 03D6 60 PUSH1 0xa0 03D8 1B SHL 03D9 03 SUB 03DA 82 DUP3 03DB 16 AND 03DC 61 PUSH2 0x0432 03DF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0432, if stack[-2] & (0x01 << 0xa0) - 0x01 label_03E0: // Incoming jump from 0x03DF, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @03E2 memory[0x40:0x60] } 03E0 60 PUSH1 0x40 03E2 51 MLOAD 03E3 62 PUSH3 0x461bcd 03E7 60 PUSH1 0xe5 03E9 1B SHL 03EA 81 DUP2 03EB 52 MSTORE 03EC 60 PUSH1 0x20 03EE 60 PUSH1 0x04 03F0 82 DUP3 03F1 01 ADD 03F2 52 MSTORE 03F3 60 PUSH1 0x22 03F5 60 PUSH1 0x24 03F7 82 DUP3 03F8 01 ADD 03F9 52 MSTORE 03FA 7F PUSH32 0x45524332303a20617070726f766520746f20746865207a65726f206164647265 041B 60 PUSH1 0x44 041D 82 DUP3 041E 01 ADD 041F 52 MSTORE 0420 61 PUSH2 0x7373 0423 60 PUSH1 0xf0 0425 1B SHL 0426 60 PUSH1 0x64 0428 82 DUP3 0429 01 ADD 042A 52 MSTORE 042B 60 PUSH1 0x84 042D 01 ADD 042E 61 PUSH2 0x0322 0431 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @03EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @03F2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @03F9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @041F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a20617070726f766520746f20746865207a65726f206164647265 // @042A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7373 << 0xf0 // @042D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0322 label_0432: // Incoming jump from 0x03DF, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[9] // { // @043B stack[-3] // @044D memory[0x00:0x40] // @044F stack[-2] // @045A memory[0x00:0x40] // @045B stack[-1] // @045F memory[0x40:0x60] // @0488 memory[0x40:0x60] // @048D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0491 stack[-4] // } 0432 5B JUMPDEST 0433 60 PUSH1 0x01 0435 60 PUSH1 0x01 0437 60 PUSH1 0xa0 0439 1B SHL 043A 03 SUB 043B 83 DUP4 043C 81 DUP2 043D 16 AND 043E 5F PUSH0 043F 81 DUP2 0440 81 DUP2 0441 52 MSTORE 0442 60 PUSH1 0x01 0444 60 PUSH1 0x20 0446 90 SWAP1 0447 81 DUP2 0448 52 MSTORE 0449 60 PUSH1 0x40 044B 80 DUP1 044C 83 DUP4 044D 20 SHA3 044E 94 SWAP5 044F 87 DUP8 0450 16 AND 0451 80 DUP1 0452 84 DUP5 0453 52 MSTORE 0454 94 SWAP5 0455 82 DUP3 0456 52 MSTORE 0457 91 SWAP2 0458 82 DUP3 0459 90 SWAP1 045A 20 SHA3 045B 85 DUP6 045C 90 SWAP1 045D 55 SSTORE 045E 90 SWAP1 045F 51 MLOAD 0460 84 DUP5 0461 81 DUP2 0462 52 MSTORE 0463 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0484 91 SWAP2 0485 01 ADD 0486 60 PUSH1 0x40 0488 51 MLOAD 0489 80 DUP1 048A 91 SWAP2 048B 03 SUB 048C 90 SWAP1 048D A3 LOG3 048E 50 POP 048F 50 POP 0490 50 POP 0491 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @0441 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0448 memory[0x20:0x40] = 0x01 // @0453 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0456 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @045D storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0462 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @048D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] label_0492: // Incoming call from 0x0272, returns to 0x0273 // Inputs[2] // { // @0497 stack[-3] // @0498 stack[-2] // } 0492 5B JUMPDEST 0493 5F PUSH0 0494 61 PUSH2 0x049d 0497 84 DUP5 0498 84 DUP5 0499 61 PUSH2 0x0345 049C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0493 stack[0] = 0x00 // @0494 stack[1] = 0x049d // @0497 stack[2] = stack[-3] // @0498 stack[3] = stack[-2] // } // Block ends with call to 0x0345, returns to 0x049D label_049D: // Incoming return from call to 0x0345 at 0x049C // Inputs[2] // { // @049E stack[-2] // @049E stack[-1] // } 049D 5B JUMPDEST 049E 90 SWAP1 049F 50 POP 04A0 5F PUSH0 04A1 19 NOT 04A2 81 DUP2 04A3 14 EQ 04A4 61 PUSH2 0x0504 04A7 57 *JUMPI // Stack delta = -1 // Outputs[1] { @049E stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0504, if stack[-1] == ~0x00 label_04A8: // Incoming jump from 0x04A7, if not stack[-1] == ~0x00 // Inputs[2] // { // @04A8 stack[-2] // @04A9 stack[-1] // } 04A8 81 DUP2 04A9 81 DUP2 04AA 10 LT 04AB 15 ISZERO 04AC 61 PUSH2 0x04f7 04AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f7, if !(stack[-1] < stack[-2]) label_04B0: // Incoming jump from 0x04AF, if not !(stack[-1] < stack[-2]) // Inputs[1] { @04B2 memory[0x40:0x60] } 04B0 60 PUSH1 0x40 04B2 51 MLOAD 04B3 62 PUSH3 0x461bcd 04B7 60 PUSH1 0xe5 04B9 1B SHL 04BA 81 DUP2 04BB 52 MSTORE 04BC 60 PUSH1 0x20 04BE 60 PUSH1 0x04 04C0 82 DUP3 04C1 01 ADD 04C2 52 MSTORE 04C3 60 PUSH1 0x1d 04C5 60 PUSH1 0x24 04C7 82 DUP3 04C8 01 ADD 04C9 52 MSTORE 04CA 7F PUSH32 0x45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000 04EB 60 PUSH1 0x44 04ED 82 DUP3 04EE 01 ADD 04EF 52 MSTORE 04F0 60 PUSH1 0x64 04F2 01 ADD 04F3 61 PUSH2 0x0322 04F6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @04BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @04C2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @04C9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @04EF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000 // @04F2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0322 label_04F7: // Incoming jump from 0x04AF, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @04FB stack[-4] // @04FC stack[-3] // @04FD stack[-2] // @04FE stack[-1] // } 04F7 5B JUMPDEST 04F8 61 PUSH2 0x0504 04FB 84 DUP5 04FC 84 DUP5 04FD 84 DUP5 04FE 84 DUP5 04FF 03 SUB 0500 61 PUSH2 0x036f 0503 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04F8 stack[0] = 0x0504 // @04FB stack[1] = stack[-4] // @04FC stack[2] = stack[-3] // @04FF stack[3] = stack[-1] - stack[-2] // } // Block ends with call to 0x036f, returns to 0x0504 label_0504: // Incoming jump from 0x06AB // Incoming return from call to 0x036F at 0x0503 // Incoming jump from 0x04A7, if stack[-1] == ~0x00 // Inputs[1] { @0509 stack[-5] } 0504 5B JUMPDEST 0505 50 POP 0506 50 POP 0507 50 POP 0508 50 POP 0509 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_050A: // Incoming call from 0x027D, returns to 0x027E // Incoming call from 0x0344, returns to 0x025A // Inputs[1] { @0513 stack[-3] } 050A 5B JUMPDEST 050B 60 PUSH1 0x01 050D 60 PUSH1 0x01 050F 60 PUSH1 0xa0 0511 1B SHL 0512 03 SUB 0513 83 DUP4 0514 16 AND 0515 61 PUSH2 0x056e 0518 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056e, if stack[-3] & (0x01 << 0xa0) - 0x01 label_0519: // Incoming jump from 0x0518, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @051B memory[0x40:0x60] } 0519 60 PUSH1 0x40 051B 51 MLOAD 051C 62 PUSH3 0x461bcd 0520 60 PUSH1 0xe5 0522 1B SHL 0523 81 DUP2 0524 52 MSTORE 0525 60 PUSH1 0x20 0527 60 PUSH1 0x04 0529 82 DUP3 052A 01 ADD 052B 52 MSTORE 052C 60 PUSH1 0x25 052E 60 PUSH1 0x24 0530 82 DUP3 0531 01 ADD 0532 52 MSTORE 0533 7F PUSH32 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164 0554 60 PUSH1 0x44 0556 82 DUP3 0557 01 ADD 0558 52 MSTORE 0559 64 PUSH5 0x6472657373 055F 60 PUSH1 0xd8 0561 1B SHL 0562 60 PUSH1 0x64 0564 82 DUP3 0565 01 ADD 0566 52 MSTORE 0567 60 PUSH1 0x84 0569 01 ADD 056A 61 PUSH2 0x0322 056D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0524 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @052B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0532 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @0558 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164 // @0566 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6472657373 << 0xd8 // @0569 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0322 label_056E: // Incoming jump from 0x0518, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0577 stack[-2] } 056E 5B JUMPDEST 056F 60 PUSH1 0x01 0571 60 PUSH1 0x01 0573 60 PUSH1 0xa0 0575 1B SHL 0576 03 SUB 0577 82 DUP3 0578 16 AND 0579 61 PUSH2 0x05d0 057C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d0, if stack[-2] & (0x01 << 0xa0) - 0x01 label_057D: // Incoming jump from 0x057C, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @057F memory[0x40:0x60] } 057D 60 PUSH1 0x40 057F 51 MLOAD 0580 62 PUSH3 0x461bcd 0584 60 PUSH1 0xe5 0586 1B SHL 0587 81 DUP2 0588 52 MSTORE 0589 60 PUSH1 0x20 058B 60 PUSH1 0x04 058D 82 DUP3 058E 01 ADD 058F 52 MSTORE 0590 60 PUSH1 0x23 0592 60 PUSH1 0x24 0594 82 DUP3 0595 01 ADD 0596 52 MSTORE 0597 7F PUSH32 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472 05B8 60 PUSH1 0x44 05BA 82 DUP3 05BB 01 ADD 05BC 52 MSTORE 05BD 62 PUSH3 0x657373 05C1 60 PUSH1 0xe8 05C3 1B SHL 05C4 60 PUSH1 0x64 05C6 82 DUP3 05C7 01 ADD 05C8 52 MSTORE 05C9 60 PUSH1 0x84 05CB 01 ADD 05CC 61 PUSH2 0x0322 05CF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0588 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @058F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0596 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @05BC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472 // @05C8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x657373 << 0xe8 // @05CB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0322 label_05D0: // Incoming jump from 0x057C, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @05D9 stack[-3] // @05E7 memory[0x00:0x40] // @05E8 storage[keccak256(memory[0x00:0x40])] // @05E9 stack[-1] // } 05D0 5B JUMPDEST 05D1 60 PUSH1 0x01 05D3 60 PUSH1 0x01 05D5 60 PUSH1 0xa0 05D7 1B SHL 05D8 03 SUB 05D9 83 DUP4 05DA 16 AND 05DB 5F PUSH0 05DC 90 SWAP1 05DD 81 DUP2 05DE 52 MSTORE 05DF 60 PUSH1 0x20 05E1 81 DUP2 05E2 90 SWAP1 05E3 52 MSTORE 05E4 60 PUSH1 0x40 05E6 90 SWAP1 05E7 20 SHA3 05E8 54 SLOAD 05E9 81 DUP2 05EA 81 DUP2 05EB 10 LT 05EC 15 ISZERO 05ED 61 PUSH2 0x0647 05F0 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @05DE memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @05E3 memory[0x20:0x40] = 0x00 // @05E8 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0647, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) label_05F1: // Incoming jump from 0x05F0, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[1] { @05F3 memory[0x40:0x60] } 05F1 60 PUSH1 0x40 05F3 51 MLOAD 05F4 62 PUSH3 0x461bcd 05F8 60 PUSH1 0xe5 05FA 1B SHL 05FB 81 DUP2 05FC 52 MSTORE 05FD 60 PUSH1 0x20 05FF 60 PUSH1 0x04 0601 82 DUP3 0602 01 ADD 0603 52 MSTORE 0604 60 PUSH1 0x26 0606 60 PUSH1 0x24 0608 82 DUP3 0609 01 ADD 060A 52 MSTORE 060B 7F PUSH32 0x45524332303a207472616e7366657220616d6f756e7420657863656564732062 062C 60 PUSH1 0x44 062E 82 DUP3 062F 01 ADD 0630 52 MSTORE 0631 65 PUSH6 0x616c616e6365 0638 60 PUSH1 0xd0 063A 1B SHL 063B 60 PUSH1 0x64 063D 82 DUP3 063E 01 ADD 063F 52 MSTORE 0640 60 PUSH1 0x84 0642 01 ADD 0643 61 PUSH2 0x0322 0646 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @05FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0603 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @060A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0630 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e7366657220616d6f756e7420657863656564732062 // @063F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616c616e6365 << 0xd0 // @0642 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0322 label_0647: // Incoming jump from 0x05F0, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[10] // { // @0650 stack[-4] // @0660 memory[0x00:0x40] // @0661 stack[-2] // @0662 stack[-1] // @0667 stack[-3] // @066F memory[0x00:0x40] // @0671 storage[keccak256(memory[0x00:0x40])] // @0677 memory[0x40:0x60] // @06A2 memory[0x40:0x60] // @06A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]] // } 0647 5B JUMPDEST 0648 60 PUSH1 0x01 064A 60 PUSH1 0x01 064C 60 PUSH1 0xa0 064E 1B SHL 064F 03 SUB 0650 84 DUP5 0651 81 DUP2 0652 16 AND 0653 5F PUSH0 0654 81 DUP2 0655 81 DUP2 0656 52 MSTORE 0657 60 PUSH1 0x20 0659 81 DUP2 065A 81 DUP2 065B 52 MSTORE 065C 60 PUSH1 0x40 065E 80 DUP1 065F 83 DUP4 0660 20 SHA3 0661 87 DUP8 0662 87 DUP8 0663 03 SUB 0664 90 SWAP1 0665 55 SSTORE 0666 93 SWAP4 0667 87 DUP8 0668 16 AND 0669 80 DUP1 066A 83 DUP4 066B 52 MSTORE 066C 91 SWAP2 066D 84 DUP5 066E 90 SWAP1 066F 20 SHA3 0670 80 DUP1 0671 54 SLOAD 0672 87 DUP8 0673 01 ADD 0674 90 SWAP1 0675 55 SSTORE 0676 92 SWAP3 0677 51 MLOAD 0678 85 DUP6 0679 81 DUP2 067A 52 MSTORE 067B 90 SWAP1 067C 92 SWAP3 067D 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 069E 91 SWAP2 069F 01 ADD 06A0 60 PUSH1 0x40 06A2 51 MLOAD 06A3 80 DUP1 06A4 91 SWAP2 06A5 03 SUB 06A6 90 SWAP1 06A7 A3 LOG3 06A8 61 PUSH2 0x0504 06AB 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @0656 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @065B memory[0x20:0x40] = 0x00 // @0665 storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-2] // @066B memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0675 storage[keccak256(memory[0x00:0x40])] = stack[-2] + storage[keccak256(memory[0x00:0x40])] // @067A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @06A7 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to 0x0504 label_06AC: // Incoming call from 0x00BE, returns to 0x00BF // Inputs[3] // { // @06B1 stack[-1] // @06B3 stack[-2] // @06B4 memory[stack[-2]:stack[-2] + 0x20] // } 06AC 5B JUMPDEST 06AD 5F PUSH0 06AE 60 PUSH1 0x20 06B0 80 DUP1 06B1 83 DUP4 06B2 52 MSTORE 06B3 83 DUP4 06B4 51 MLOAD 06B5 80 DUP1 06B6 82 DUP3 06B7 85 DUP6 06B8 01 ADD 06B9 52 MSTORE 06BA 5F PUSH0 06BB 5B JUMPDEST 06BC 81 DUP2 06BD 81 DUP2 06BE 10 LT 06BF 15 ISZERO 06C0 61 PUSH2 0x06d7 06C3 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @06AD stack[0] = 0x00 // @06AE stack[1] = 0x20 // @06B2 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @06B4 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @06B9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @06BA stack[3] = 0x00 // } // Block ends with conditional jump to 0x06d7, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_06C4: // Incoming jump from 0x06C3, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x06C3, if not !(stack[-1] < stack[-2]) // Inputs[5] // { // @06C4 stack[-6] // @06C5 stack[-1] // @06C7 stack[-3] // @06C9 memory[stack[-3] + stack[-1] + stack[-6]:stack[-3] + stack[-1] + stack[-6] + 0x20] // @06CA stack[-5] // } 06C4 85 DUP6 06C5 81 DUP2 06C6 01 ADD 06C7 83 DUP4 06C8 01 ADD 06C9 51 MLOAD 06CA 85 DUP6 06CB 82 DUP3 06CC 01 ADD 06CD 60 PUSH1 0x40 06CF 01 ADD 06D0 52 MSTORE 06D1 82 DUP3 06D2 01 ADD 06D3 61 PUSH2 0x06bb 06D6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06D0 memory[0x40 + stack[-1] + stack[-5]:0x40 + stack[-1] + stack[-5] + 0x20] = memory[stack[-3] + stack[-1] + stack[-6]:stack[-3] + stack[-1] + stack[-6] + 0x20] // @06D2 stack[-1] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x06bb label_06D7: // Incoming jump from 0x06C3, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x06C3, if !(stack[-1] < stack[-2]) // Inputs[5] // { // @06DC stack[-2] // @06DD stack[-5] // @06EE stack[-4] // @06F2 stack[-7] // @06F3 stack[-6] // } 06D7 5B JUMPDEST 06D8 50 POP 06D9 5F PUSH0 06DA 60 PUSH1 0x40 06DC 82 DUP3 06DD 86 DUP7 06DE 01 ADD 06DF 01 ADD 06E0 52 MSTORE 06E1 60 PUSH1 0x40 06E3 60 PUSH1 0x1f 06E5 19 NOT 06E6 60 PUSH1 0x1f 06E8 83 DUP4 06E9 01 ADD 06EA 16 AND 06EB 85 DUP6 06EC 01 ADD 06ED 01 ADD 06EE 92 SWAP3 06EF 50 POP 06F0 50 POP 06F1 50 POP 06F2 92 SWAP3 06F3 91 SWAP2 06F4 50 POP 06F5 50 POP 06F6 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @06E0 memory[stack[-5] + stack[-2] + 0x40:stack[-5] + stack[-2] + 0x40 + 0x20] = 0x00 // @06F2 stack[-7] = stack[-5] + (stack[-2] + 0x1f & ~0x1f) + 0x40 // } // Block ends with unconditional jump to stack[-7] label_06F7: // Incoming call from 0x072B, returns to 0x072C // Incoming call from 0x0754, returns to 0x0755 // Incoming call from 0x07BA, returns to 0x07BB // Incoming call from 0x0762, returns to 0x0763 // Incoming call from 0x078B, returns to 0x078C // Incoming call from 0x07AC, returns to 0x07AD // Inputs[2] // { // @06F8 stack[-1] // @06F9 msg.data[stack[-1]:stack[-1] + 0x20] // } 06F7 5B JUMPDEST 06F8 80 DUP1 06F9 35 CALLDATALOAD 06FA 60 PUSH1 0x01 06FC 60 PUSH1 0x01 06FE 60 PUSH1 0xa0 0700 1B SHL 0701 03 SUB 0702 81 DUP2 0703 16 AND 0704 81 DUP2 0705 14 EQ 0706 61 PUSH2 0x070d 0709 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06F9 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x070d, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_070A: // Incoming jump from 0x0709, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @070C memory[0x00:0x00] } 070A 5F PUSH0 070B 80 DUP1 070C FD *REVERT // Stack delta = +0 // Outputs[1] { @070C revert(memory[0x00:0x00]); } // Block terminates label_070D: // Incoming jump from 0x0709, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @070E stack[-1] // @070E stack[-3] // @070F stack[-2] // } 070D 5B JUMPDEST 070E 91 SWAP2 070F 90 SWAP1 0710 50 POP 0711 56 *JUMP // Stack delta = -2 // Outputs[1] { @070E stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0712: // Incoming call from 0x014E, returns to 0x014F // Incoming call from 0x0191, returns to 0x0192 // Incoming call from 0x00D5, returns to 0x00D6 // Incoming call from 0x01A4, returns to 0x01A5 // Inputs[2] // { // @0717 stack[-1] // @0718 stack[-2] // } 0712 5B JUMPDEST 0713 5F PUSH0 0714 80 DUP1 0715 60 PUSH1 0x40 0717 83 DUP4 0718 85 DUP6 0719 03 SUB 071A 12 SLT 071B 15 ISZERO 071C 61 PUSH2 0x0723 071F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0713 stack[0] = 0x00 // @0714 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0723, if !(stack[-2] - stack[-1] i< 0x40) label_0720: // Incoming jump from 0x071F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0722 memory[0x00:0x00] } 0720 5F PUSH0 0721 80 DUP1 0722 FD *REVERT // Stack delta = +0 // Outputs[1] { @0722 revert(memory[0x00:0x00]); } // Block terminates label_0723: // Incoming jump from 0x071F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0727 stack[-3] } 0723 5B JUMPDEST 0724 61 PUSH2 0x072c 0727 83 DUP4 0728 61 PUSH2 0x06f7 072B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0724 stack[0] = 0x072c // @0727 stack[1] = stack[-3] // } // Block ends with call to 0x06f7, returns to 0x072C label_072C: // Incoming return from call to 0x06F7 at 0x072B // Inputs[5] // { // @072D stack[-1] // @072D stack[-6] // @0730 stack[-4] // @0734 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @0735 stack[-5] // } 072C 5B JUMPDEST 072D 94 SWAP5 072E 60 PUSH1 0x20 0730 93 SWAP4 0731 90 SWAP1 0732 93 SWAP4 0733 01 ADD 0734 35 CALLDATALOAD 0735 93 SWAP4 0736 50 POP 0737 50 POP 0738 50 POP 0739 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @072D stack[-6] = stack[-1] // @0735 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_073A: // Incoming call from 0x010A, returns to 0x010B // Inputs[2] // { // @0740 stack[-1] // @0741 stack[-2] // } 073A 5B JUMPDEST 073B 5F PUSH0 073C 80 DUP1 073D 5F PUSH0 073E 60 PUSH1 0x60 0740 84 DUP5 0741 86 DUP7 0742 03 SUB 0743 12 SLT 0744 15 ISZERO 0745 61 PUSH2 0x074c 0748 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @073B stack[0] = 0x00 // @073C stack[1] = 0x00 // @073D stack[2] = 0x00 // } // Block ends with conditional jump to 0x074c, if !(stack[-2] - stack[-1] i< 0x60) label_0749: // Incoming jump from 0x0748, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @074B memory[0x00:0x00] } 0749 5F PUSH0 074A 80 DUP1 074B FD *REVERT // Stack delta = +0 // Outputs[1] { @074B revert(memory[0x00:0x00]); } // Block terminates label_074C: // Incoming jump from 0x0748, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @0750 stack[-4] } 074C 5B JUMPDEST 074D 61 PUSH2 0x0755 0750 84 DUP5 0751 61 PUSH2 0x06f7 0754 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @074D stack[0] = 0x0755 // @0750 stack[1] = stack[-4] // } // Block ends with call to 0x06f7, returns to 0x0755 label_0755: // Incoming return from call to 0x06F7 at 0x0754 // Inputs[3] // { // @0756 stack[-4] // @0756 stack[-1] // @075D stack[-5] // } 0755 5B JUMPDEST 0756 92 SWAP3 0757 50 POP 0758 61 PUSH2 0x0763 075B 60 PUSH1 0x20 075D 85 DUP6 075E 01 ADD 075F 61 PUSH2 0x06f7 0762 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0756 stack[-4] = stack[-1] // @0758 stack[-1] = 0x0763 // @075E stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x06f7, returns to 0x0763 label_0763: // Incoming return from call to 0x06F7 at 0x0762 // Inputs[8] // { // @0764 stack[-3] // @0764 stack[-1] // @0768 stack[-5] // @076A msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @076B stack[-2] // @076F stack[-6] // @0771 stack[-7] // @0771 stack[-4] // } 0763 5B JUMPDEST 0764 91 SWAP2 0765 50 POP 0766 60 PUSH1 0x40 0768 84 DUP5 0769 01 ADD 076A 35 CALLDATALOAD 076B 90 SWAP1 076C 50 POP 076D 92 SWAP3 076E 50 POP 076F 92 SWAP3 0770 50 POP 0771 92 SWAP3 0772 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @076D stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @076F stack[-6] = stack[-1] // @0771 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_0773: // Incoming call from 0x0161, returns to 0x0162 // Inputs[2] // { // @0777 stack[-1] // @0778 stack[-2] // } 0773 5B JUMPDEST 0774 5F PUSH0 0775 60 PUSH1 0x20 0777 82 DUP3 0778 84 DUP5 0779 03 SUB 077A 12 SLT 077B 15 ISZERO 077C 61 PUSH2 0x0783 077F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0774 stack[0] = 0x00 } // Block ends with conditional jump to 0x0783, if !(stack[-2] - stack[-1] i< 0x20) label_0780: // Incoming jump from 0x077F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0782 memory[0x00:0x00] } 0780 5F PUSH0 0781 80 DUP1 0782 FD *REVERT // Stack delta = +0 // Outputs[1] { @0782 revert(memory[0x00:0x00]); } // Block terminates label_0783: // Incoming jump from 0x077F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0787 stack[-2] } 0783 5B JUMPDEST 0784 61 PUSH2 0x078c 0787 82 DUP3 0788 61 PUSH2 0x06f7 078B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0784 stack[0] = 0x078c // @0787 stack[1] = stack[-2] // } // Block ends with call to 0x06f7, returns to 0x078C label_078C: // Incoming return from call to 0x06F7 at 0x078B // Inputs[3] // { // @078D stack[-5] // @078D stack[-1] // @078E stack[-4] // } 078C 5B JUMPDEST 078D 93 SWAP4 078E 92 SWAP3 078F 50 POP 0790 50 POP 0791 50 POP 0792 56 *JUMP // Stack delta = -4 // Outputs[1] { @078D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0793: // Incoming call from 0x01B7, returns to 0x01B8 // Inputs[2] // { // @0798 stack[-1] // @0799 stack[-2] // } 0793 5B JUMPDEST 0794 5F PUSH0 0795 80 DUP1 0796 60 PUSH1 0x40 0798 83 DUP4 0799 85 DUP6 079A 03 SUB 079B 12 SLT 079C 15 ISZERO 079D 61 PUSH2 0x07a4 07A0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0794 stack[0] = 0x00 // @0795 stack[1] = 0x00 // } // Block ends with conditional jump to 0x07a4, if !(stack[-2] - stack[-1] i< 0x40) label_07A1: // Incoming jump from 0x07A0, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @07A3 memory[0x00:0x00] } 07A1 5F PUSH0 07A2 80 DUP1 07A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @07A3 revert(memory[0x00:0x00]); } // Block terminates label_07A4: // Incoming jump from 0x07A0, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @07A8 stack[-3] } 07A4 5B JUMPDEST 07A5 61 PUSH2 0x07ad 07A8 83 DUP4 07A9 61 PUSH2 0x06f7 07AC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07A5 stack[0] = 0x07ad // @07A8 stack[1] = stack[-3] // } // Block ends with call to 0x06f7, returns to 0x07AD label_07AD: // Incoming return from call to 0x06F7 at 0x07AC // Inputs[3] // { // @07AE stack[-1] // @07AE stack[-3] // @07B5 stack[-4] // } 07AD 5B JUMPDEST 07AE 91 SWAP2 07AF 50 POP 07B0 61 PUSH2 0x07bb 07B3 60 PUSH1 0x20 07B5 84 DUP5 07B6 01 ADD 07B7 61 PUSH2 0x06f7 07BA 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @07AE stack[-3] = stack[-1] // @07B0 stack[-1] = 0x07bb // @07B6 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x06f7, returns to 0x07BB label_07BB: // Incoming return from call to 0x06F7 at 0x07BA // Inputs[6] // { // @07BC stack[-1] // @07BC stack[-2] // @07BE stack[-5] // @07C0 stack[-3] // @07C0 stack[-6] // @07C1 stack[-4] // } 07BB 5B JUMPDEST 07BC 90 SWAP1 07BD 50 POP 07BE 92 SWAP3 07BF 50 POP 07C0 92 SWAP3 07C1 90 SWAP1 07C2 50 POP 07C3 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @07BE stack[-5] = stack[-1] // @07C0 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_07C4: // Incoming call from 0x02B8, returns to 0x01CC // Incoming call from 0x01CB, returns to 0x01CC // Incoming call from 0x01F7, returns to 0x01F8 // Inputs[1] { @07C7 stack[-1] } 07C4 5B JUMPDEST 07C5 60 PUSH1 0x01 07C7 81 DUP2 07C8 81 DUP2 07C9 1C SHR 07CA 90 SWAP1 07CB 82 DUP3 07CC 16 AND 07CD 80 DUP1 07CE 61 PUSH2 0x07d8 07D1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @07CA stack[0] = stack[-1] >> 0x01 // @07CC stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x07d8, if stack[-1] & 0x01 label_07D2: // Incoming jump from 0x07D1, if not stack[-1] & 0x01 // Inputs[2] // { // @07D4 stack[-2] // @07DD stack[-1] // } 07D2 60 PUSH1 0x7f 07D4 82 DUP3 07D5 16 AND 07D6 91 SWAP2 07D7 50 POP 07D8 5B JUMPDEST 07D9 60 PUSH1 0x20 07DB 82 DUP3 07DC 10 LT 07DD 81 DUP2 07DE 03 SUB 07DF 61 PUSH2 0x07f6 07E2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07D6 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x07f6, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_07E3: // Incoming jump from 0x07E2, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x07E2, if not stack[-1] - (stack[-2] < 0x20) // Inputs[1] { @07F5 memory[0x00:0x24] } 07E3 63 PUSH4 0x4e487b71 07E8 60 PUSH1 0xe0 07EA 1B SHL 07EB 5F PUSH0 07EC 52 MSTORE 07ED 60 PUSH1 0x22 07EF 60 PUSH1 0x04 07F1 52 MSTORE 07F2 60 PUSH1 0x24 07F4 5F PUSH0 07F5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @07EC memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @07F1 memory[0x04:0x24] = 0x22 // @07F5 revert(memory[0x00:0x24]); // } // Block terminates label_07F6: // Incoming jump from 0x07E2, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x07E2, if stack[-1] - (stack[-2] < 0x20) // Inputs[3] // { // @07F8 stack[-4] // @07F8 stack[-2] // @07F9 stack[-3] // } 07F6 5B JUMPDEST 07F7 50 POP 07F8 91 SWAP2 07F9 90 SWAP1 07FA 50 POP 07FB 56 *JUMP // Stack delta = -3 // Outputs[1] { @07F8 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_07FC: // Incoming call from 0x02A4, returns to 0x02A5 // Inputs[2] // { // @07FD stack[-1] // @07FE stack[-2] // } 07FC 5B JUMPDEST 07FD 80 DUP1 07FE 82 DUP3 07FF 01 ADD 0800 80 DUP1 0801 82 DUP3 0802 11 GT 0803 15 ISZERO 0804 61 PUSH2 0x0260 0807 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07FF stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x0260, if !(stack[-1] > stack[-2] + stack[-1]) label_0808: // Incoming jump from 0x0807, if not !(stack[-1] > stack[-2] + stack[-1]) // Inputs[1] { @081A memory[0x00:0x24] } 0808 63 PUSH4 0x4e487b71 080D 60 PUSH1 0xe0 080F 1B SHL 0810 5F PUSH0 0811 52 MSTORE 0812 60 PUSH1 0x11 0814 60 PUSH1 0x04 0816 52 MSTORE 0817 60 PUSH1 0x24 0819 5F PUSH0 081A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0811 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0816 memory[0x04:0x24] = 0x11 // @081A revert(memory[0x00:0x24]); // } // Block terminates 081B FE *ASSERT 081C A2 LOG2 081D 64 PUSH5 0x6970667358 0823 22 22 0824 12 SLT 0825 20 SHA3 0826 BE BE 0827 CA CA 0828 17 OR 0829 3F EXTCODEHASH 082A 6A PUSH11 0xb68937f295aa45fd8e1b98 0836 AC AC 0837 59 MSIZE 0838 FC FC 0839 2A 2A 083A 21 21 083B 77 PUSH24 0x9728cfe59ae7461ee7a264736f6c63430008140033