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 0x00a9 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x00a9, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x39509351 0026 11 GT 0027 61 PUSH2 0x0071 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0071, if 0x39509351 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x39509351 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x39509351 0031 14 EQ 0032 61 PUSH2 0x0145 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0145, if 0x39509351 == stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x39509351 == stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0x70a08231 003C 14 EQ 003D 61 PUSH2 0x0158 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0158, if 0x70a08231 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0x70a08231 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0x95d89b41 0047 14 EQ 0048 61 PUSH2 0x0181 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0181, if 0x95d89b41 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0x95d89b41 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xa457c2d7 0052 14 EQ 0053 61 PUSH2 0x0189 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0189, if 0xa457c2d7 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xa457c2d7 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xa9059cbb 005D 14 EQ 005E 61 PUSH2 0x019c 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019c, if 0xa9059cbb == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xdd62ed3e 0068 14 EQ 0069 61 PUSH2 0x01af 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01af, if 0xdd62ed3e == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x002A, if 0x39509351 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0x06fdde03 0078 14 EQ 0079 61 PUSH2 0x00ae 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ae, if 0x06fdde03 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x06fdde03 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x095ea7b3 0083 14 EQ 0084 61 PUSH2 0x00cc 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00cc, if 0x095ea7b3 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x18160ddd 008E 14 EQ 008F 61 PUSH2 0x00ef 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ef, if 0x18160ddd == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x18160ddd == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0x23b872dd 0099 14 EQ 009A 61 PUSH2 0x0101 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0101, if 0x23b872dd == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0x23b872dd == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0x313ce567 00A4 14 EQ 00A5 61 PUSH2 0x0114 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0114, if 0x313ce567 == stack[-1] label_00A9: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x00A8, if not 0x313ce567 == stack[-1] // Inputs[1] { @00AD memory[0x00:0x00] } 00A9 5B JUMPDEST 00AA 60 PUSH1 0x00 00AC 80 DUP1 00AD FD *REVERT // Stack delta = +0 // Outputs[1] { @00AD revert(memory[0x00:0x00]); } // Block terminates label_00AE: // Incoming jump from 0x007C, if 0x06fdde03 == stack[-1] 00AE 5B JUMPDEST 00AF 61 PUSH2 0x00b6 00B2 61 PUSH2 0x01e8 00B5 56 *JUMP // Stack delta = +1 // Outputs[1] { @00AF stack[0] = 0x00b6 } // Block ends with call to 0x01e8, returns to 0x00B6 label_00B6: // Incoming return from call to 0x037D at 0x0188 // Incoming return from call to 0x01E8 at 0x00B5 // Inputs[2] // { // @00B9 memory[0x40:0x60] // @00BD stack[-1] // } 00B6 5B JUMPDEST 00B7 60 PUSH1 0x40 00B9 51 MLOAD 00BA 61 PUSH2 0x00c3 00BD 91 SWAP2 00BE 90 SWAP1 00BF 61 PUSH2 0x0803 00C2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @00BD stack[-1] = 0x00c3 // @00BE stack[1] = memory[0x40:0x60] // @00BE stack[0] = stack[-1] // } // Block ends with call to 0x0803, returns to 0x00C3 label_00C3: // Incoming jump from 0x0100 // Incoming jump from 0x0144 // Incoming jump from 0x0100 // Incoming jump from 0x00EE // Incoming return from call to 0x0803 at 0x00C2 // Inputs[3] // { // @00C6 memory[0x40:0x60] // @00C8 stack[-1] // @00CB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 00C3 5B JUMPDEST 00C4 60 PUSH1 0x40 00C6 51 MLOAD 00C7 80 DUP1 00C8 91 SWAP2 00C9 03 SUB 00CA 90 SWAP1 00CB F3 *RETURN // Stack delta = -1 // Outputs[1] { @00CB return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_00CC: // Incoming jump from 0x0087, if 0x095ea7b3 == stack[-1] // Inputs[1] { @00D3 msg.data.length } 00CC 5B JUMPDEST 00CD 61 PUSH2 0x00df 00D0 61 PUSH2 0x00da 00D3 36 CALLDATASIZE 00D4 60 PUSH1 0x04 00D6 61 PUSH2 0x07da 00D9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @00CD stack[0] = 0x00df // @00D0 stack[1] = 0x00da // @00D3 stack[2] = msg.data.length // @00D4 stack[3] = 0x04 // } // Block ends with call to 0x07da, returns to 0x00DA label_00DA: // Incoming return from call to 0x07DA at 0x00D9 00DA 5B JUMPDEST 00DB 61 PUSH2 0x027a 00DE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x027a label_00DF: // Incoming return from call to 0x00DA at 0x00D9 // Incoming return from call to 0x0197 at 0x0196 // Incoming return from call to 0x010F at 0x010E // Inputs[2] // { // @00E2 memory[0x40:0x60] // @00E3 stack[-1] // } 00DF 5B JUMPDEST 00E0 60 PUSH1 0x40 00E2 51 MLOAD 00E3 90 SWAP1 00E4 15 ISZERO 00E5 15 ISZERO 00E6 81 DUP2 00E7 52 MSTORE 00E8 60 PUSH1 0x20 00EA 01 ADD 00EB 61 PUSH2 0x00c3 00EE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @00E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @00EA stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00c3 label_00EF: // Incoming jump from 0x0092, if 0x18160ddd == stack[-1] // Inputs[2] // { // @00F2 storage[0x02] // @00F6 memory[0x40:0x60] // } 00EF 5B JUMPDEST 00F0 60 PUSH1 0x02 00F2 54 SLOAD 00F3 5B JUMPDEST 00F4 60 PUSH1 0x40 00F6 51 MLOAD 00F7 90 SWAP1 00F8 81 DUP2 00F9 52 MSTORE 00FA 60 PUSH1 0x20 00FC 01 ADD 00FD 61 PUSH2 0x00c3 0100 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @00F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x02] // @00FC stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00c3 label_0101: // Incoming jump from 0x009D, if 0x23b872dd == stack[-1] // Inputs[1] { @0108 msg.data.length } 0101 5B JUMPDEST 0102 61 PUSH2 0x00df 0105 61 PUSH2 0x010f 0108 36 CALLDATASIZE 0109 60 PUSH1 0x04 010B 61 PUSH2 0x079f 010E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0102 stack[0] = 0x00df // @0105 stack[1] = 0x010f // @0108 stack[2] = msg.data.length // @0109 stack[3] = 0x04 // } // Block ends with call to 0x079f, returns to 0x010F label_010F: // Incoming return from call to 0x079F at 0x010E 010F 5B JUMPDEST 0110 61 PUSH2 0x0290 0113 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0290 label_0114: // Incoming jump from 0x00A8, if 0x313ce567 == stack[-1] // Inputs[1] { @0117 memory[0x40:0x60] } 0114 5B JUMPDEST 0115 60 PUSH1 0x40 0117 51 MLOAD 0118 60 PUSH1 0xff 011A 7F PUSH32 0x0000000000000000000000000000000000000000000000000000000000000012 013B 16 AND 013C 81 DUP2 013D 52 MSTORE 013E 60 PUSH1 0x20 0140 01 ADD 0141 61 PUSH2 0x00c3 0144 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @013D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0000000000000000000000000000000000000000000000000000000000000012 & 0xff // @0140 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x00c3 label_0145: // Incoming jump from 0x0035, if 0x39509351 == stack[-1] // Inputs[1] { @014C msg.data.length } 0145 5B JUMPDEST 0146 61 PUSH2 0x00df 0149 61 PUSH2 0x0153 014C 36 CALLDATASIZE 014D 60 PUSH1 0x04 014F 61 PUSH2 0x07da 0152 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0146 stack[0] = 0x00df // @0149 stack[1] = 0x0153 // @014C stack[2] = msg.data.length // @014D stack[3] = 0x04 // } // Block ends with call to 0x07da, returns to 0x0153 label_0153: // Incoming return from call to 0x07DA at 0x0152 0153 5B JUMPDEST 0154 61 PUSH2 0x0346 0157 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0346 label_0158: // Incoming jump from 0x0040, if 0x70a08231 == stack[-1] // Inputs[1] { @015F msg.data.length } 0158 5B JUMPDEST 0159 61 PUSH2 0x00f3 015C 61 PUSH2 0x0166 015F 36 CALLDATASIZE 0160 60 PUSH1 0x04 0162 61 PUSH2 0x074c 0165 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0159 stack[0] = 0x00f3 // @015C stack[1] = 0x0166 // @015F stack[2] = msg.data.length // @0160 stack[3] = 0x04 // } // Block ends with call to 0x074c, returns to 0x0166 label_0166: // Incoming return from call to 0x074C at 0x0165 // Inputs[4] // { // @016F stack[-1] // @017D memory[0x00:0x40] // @017E storage[keccak256(memory[0x00:0x40])] // @017F stack[-2] // } 0166 5B JUMPDEST 0167 60 PUSH1 0x01 0169 60 PUSH1 0x01 016B 60 PUSH1 0xa0 016D 1B SHL 016E 03 SUB 016F 16 AND 0170 60 PUSH1 0x00 0172 90 SWAP1 0173 81 DUP2 0174 52 MSTORE 0175 60 PUSH1 0x20 0177 81 DUP2 0178 90 SWAP1 0179 52 MSTORE 017A 60 PUSH1 0x40 017C 90 SWAP1 017D 20 SHA3 017E 54 SLOAD 017F 90 SWAP1 0180 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0174 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0179 memory[0x20:0x40] = 0x00 // @017F stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0181: // Incoming jump from 0x004B, if 0x95d89b41 == stack[-1] 0181 5B JUMPDEST 0182 61 PUSH2 0x00b6 0185 61 PUSH2 0x037d 0188 56 *JUMP // Stack delta = +1 // Outputs[1] { @0182 stack[0] = 0x00b6 } // Block ends with call to 0x037d, returns to 0x00B6 label_0189: // Incoming jump from 0x0056, if 0xa457c2d7 == stack[-1] // Inputs[1] { @0190 msg.data.length } 0189 5B JUMPDEST 018A 61 PUSH2 0x00df 018D 61 PUSH2 0x0197 0190 36 CALLDATASIZE 0191 60 PUSH1 0x04 0193 61 PUSH2 0x07da 0196 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @018A stack[0] = 0x00df // @018D stack[1] = 0x0197 // @0190 stack[2] = msg.data.length // @0191 stack[3] = 0x04 // } // Block ends with call to 0x07da, returns to 0x0197 label_0197: // Incoming return from call to 0x07DA at 0x0196 0197 5B JUMPDEST 0198 61 PUSH2 0x038c 019B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x038c label_019C: // Incoming jump from 0x0061, if 0xa9059cbb == stack[-1] // Inputs[1] { @01A3 msg.data.length } 019C 5B JUMPDEST 019D 61 PUSH2 0x00df 01A0 61 PUSH2 0x01aa 01A3 36 CALLDATASIZE 01A4 60 PUSH1 0x04 01A6 61 PUSH2 0x07da 01A9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @019D stack[0] = 0x00df // @01A0 stack[1] = 0x01aa // @01A3 stack[2] = msg.data.length // @01A4 stack[3] = 0x04 // } // Block ends with call to 0x07da, returns to 0x01AA label_01AA: // Incoming return from call to 0x07DA at 0x01A9 01AA 5B JUMPDEST 01AB 61 PUSH2 0x0427 01AE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0427 label_01AF: // Incoming jump from 0x006C, if 0xdd62ed3e == stack[-1] // Inputs[1] { @01B6 msg.data.length } 01AF 5B JUMPDEST 01B0 61 PUSH2 0x00f3 01B3 61 PUSH2 0x01bd 01B6 36 CALLDATASIZE 01B7 60 PUSH1 0x04 01B9 61 PUSH2 0x076d 01BC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01B0 stack[0] = 0x00f3 // @01B3 stack[1] = 0x01bd // @01B6 stack[2] = msg.data.length // @01B7 stack[3] = 0x04 // } // Block ends with call to 0x076d, returns to 0x01BD label_01BD: // Incoming return from call to 0x076D at 0x01BC // Inputs[6] // { // @01C6 stack[-2] // @01D9 memory[0x00:0x40] // @01DA stack[-1] // @01E4 memory[0x00:0x40] // @01E5 storage[keccak256(memory[0x00:0x40])] // @01E6 stack[-3] // } 01BD 5B JUMPDEST 01BE 60 PUSH1 0x01 01C0 60 PUSH1 0x01 01C2 60 PUSH1 0xa0 01C4 1B SHL 01C5 03 SUB 01C6 91 SWAP2 01C7 82 DUP3 01C8 16 AND 01C9 60 PUSH1 0x00 01CB 90 SWAP1 01CC 81 DUP2 01CD 52 MSTORE 01CE 60 PUSH1 0x01 01D0 60 PUSH1 0x20 01D2 90 SWAP1 01D3 81 DUP2 01D4 52 MSTORE 01D5 60 PUSH1 0x40 01D7 80 DUP1 01D8 83 DUP4 01D9 20 SHA3 01DA 93 SWAP4 01DB 90 SWAP1 01DC 94 SWAP5 01DD 16 AND 01DE 82 DUP3 01DF 52 MSTORE 01E0 91 SWAP2 01E1 90 SWAP1 01E2 91 SWAP2 01E3 52 MSTORE 01E4 20 SHA3 01E5 54 SLOAD 01E6 90 SWAP1 01E7 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @01CD memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @01D4 memory[0x20:0x40] = 0x01 // @01DF memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @01E3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @01E6 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_01E8: // Incoming call from 0x00B5, returns to 0x00B6 // Inputs[1] { @01EE storage[0x03] } 01E8 5B JUMPDEST 01E9 60 PUSH1 0x60 01EB 60 PUSH1 0x03 01ED 80 DUP1 01EE 54 SLOAD 01EF 61 PUSH2 0x01f7 01F2 90 SWAP1 01F3 61 PUSH2 0x0885 01F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01E9 stack[0] = 0x60 // @01EB stack[1] = 0x03 // @01F2 stack[2] = 0x01f7 // @01F2 stack[3] = storage[0x03] // } // Block ends with call to 0x0885, returns to 0x01F7 label_01F7: // Incoming return from call to 0x0885 at 0x038B // Incoming return from call to 0x0885 at 0x01F6 // Inputs[4] // { // @01F8 stack[-1] // @0207 memory[0x40:0x60] // @020F stack[-2] // @021A storage[stack[-2]] // } 01F7 5B JUMPDEST 01F8 80 DUP1 01F9 60 PUSH1 0x1f 01FB 01 ADD 01FC 60 PUSH1 0x20 01FE 80 DUP1 01FF 91 SWAP2 0200 04 DIV 0201 02 MUL 0202 60 PUSH1 0x20 0204 01 ADD 0205 60 PUSH1 0x40 0207 51 MLOAD 0208 90 SWAP1 0209 81 DUP2 020A 01 ADD 020B 60 PUSH1 0x40 020D 52 MSTORE 020E 80 DUP1 020F 92 SWAP3 0210 91 SWAP2 0211 90 SWAP1 0212 81 DUP2 0213 81 DUP2 0214 52 MSTORE 0215 60 PUSH1 0x20 0217 01 ADD 0218 82 DUP3 0219 80 DUP1 021A 54 SLOAD 021B 61 PUSH2 0x0223 021E 90 SWAP1 021F 61 PUSH2 0x0885 0222 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @020D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @020F stack[-2] = memory[0x40:0x60] // @0210 stack[-1] = stack[-2] // @0211 stack[0] = stack[-1] // @0214 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0217 stack[1] = 0x20 + memory[0x40:0x60] // @0218 stack[2] = stack[-2] // @021E stack[4] = storage[stack[-2]] // @021E stack[3] = 0x0223 // } // Block ends with call to 0x0885, returns to 0x0223 label_0223: // Incoming return from call to 0x0885 at 0x0222 // Inputs[1] { @0224 stack[-1] } 0223 5B JUMPDEST 0224 80 DUP1 0225 15 ISZERO 0226 61 PUSH2 0x0270 0229 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0270, if !stack[-1] label_022A: // Incoming jump from 0x0229, if not !stack[-1] // Inputs[1] { @022A stack[-1] } 022A 80 DUP1 022B 60 PUSH1 0x1f 022D 10 LT 022E 61 PUSH2 0x0245 0231 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0245, if 0x1f < stack[-1] label_0232: // Incoming jump from 0x0231, if not 0x1f < stack[-1] // Inputs[4] // { // @0236 stack[-2] // @0237 storage[stack[-2]] // @023A stack[-3] // @023C stack[-1] // } 0232 61 PUSH2 0x0100 0235 80 DUP1 0236 83 DUP4 0237 54 SLOAD 0238 04 DIV 0239 02 MUL 023A 83 DUP4 023B 52 MSTORE 023C 91 SWAP2 023D 60 PUSH1 0x20 023F 01 ADD 0240 91 SWAP2 0241 61 PUSH2 0x0270 0244 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @023B memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0240 stack[-1] = stack[-1] // @0240 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0270 label_0245: // Incoming jump from 0x0231, if 0x1f < stack[-1] // Inputs[5] // { // @0246 stack[-3] // @0247 stack[-1] // @0249 stack[-2] // @0251 memory[0x00:0x20] // @0255 storage[keccak256(memory[0x00:0x20])] // } 0245 5B JUMPDEST 0246 82 DUP3 0247 01 ADD 0248 91 SWAP2 0249 90 SWAP1 024A 60 PUSH1 0x00 024C 52 MSTORE 024D 60 PUSH1 0x20 024F 60 PUSH1 0x00 0251 20 SHA3 0252 90 SWAP1 0253 5B JUMPDEST 0254 81 DUP2 0255 54 SLOAD 0256 81 DUP2 0257 52 MSTORE 0258 90 SWAP1 0259 60 PUSH1 0x01 025B 01 ADD 025C 90 SWAP1 025D 60 PUSH1 0x20 025F 01 ADD 0260 80 DUP1 0261 83 DUP4 0262 11 GT 0263 61 PUSH2 0x0253 0266 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0248 stack[-3] = stack[-3] + stack[-1] // @024C memory[0x00:0x20] = stack[-2] // @0257 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @025C stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @025F stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0253, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0267: // Incoming jump from 0x0266, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0266, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0267 stack[-3] // @0268 stack[-1] // } 0267 82 DUP3 0268 90 SWAP1 0269 03 SUB 026A 60 PUSH1 0x1f 026C 16 AND 026D 82 DUP3 026E 01 ADD 026F 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @026F stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @026F stack[-1] = stack[-3] // } // Block continues label_0270: // Incoming jump from 0x0229, if !stack[-1] // Incoming jump from 0x0244 // Incoming jump from 0x026F // Inputs[3] // { // @0276 stack[-7] // @0276 stack[-6] // @0278 stack[-8] // } 0270 5B JUMPDEST 0271 50 POP 0272 50 POP 0273 50 POP 0274 50 POP 0275 50 POP 0276 90 SWAP1 0277 50 POP 0278 90 SWAP1 0279 56 *JUMP // Stack delta = -7 // Outputs[1] { @0278 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_027A: // Incoming jump from 0x00DE // Inputs[3] // { // @0280 msg.sender // @0281 stack[-2] // @0282 stack[-1] // } 027A 5B JUMPDEST 027B 60 PUSH1 0x00 027D 61 PUSH2 0x0287 0280 33 CALLER 0281 84 DUP5 0282 84 DUP5 0283 61 PUSH2 0x0434 0286 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @027B stack[0] = 0x00 // @027D stack[1] = 0x0287 // @0280 stack[2] = msg.sender // @0281 stack[3] = stack[-2] // @0282 stack[4] = stack[-1] // } // Block ends with call to 0x0434, returns to 0x0287 label_0287: // Incoming return from call to 0x0558 at 0x0433 // Incoming return from call to 0x0336 at 0x037C // Incoming return from call to 0x0434 at 0x0286 // Inputs[2] // { // @028B stack[-4] // @028C stack[-3] // } 0287 5B JUMPDEST 0288 50 POP 0289 60 PUSH1 0x01 028B 92 SWAP3 028C 91 SWAP2 028D 50 POP 028E 50 POP 028F 56 *JUMP // Stack delta = -3 // Outputs[1] { @028B stack[-4] = 0x01 } // Block ends with unconditional jump to stack[-4] label_0290: // Incoming jump from 0x0113 // Inputs[3] // { // @0296 stack[-3] // @0297 stack[-2] // @0298 stack[-1] // } 0290 5B JUMPDEST 0291 60 PUSH1 0x00 0293 61 PUSH2 0x029d 0296 84 DUP5 0297 84 DUP5 0298 84 DUP5 0299 61 PUSH2 0x0558 029C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0291 stack[0] = 0x00 // @0293 stack[1] = 0x029d // @0296 stack[2] = stack[-3] // @0297 stack[3] = stack[-2] // @0298 stack[4] = stack[-1] // } // Block ends with call to 0x0558, returns to 0x029D label_029D: // Incoming return from call to 0x0558 at 0x029C // Inputs[6] // { // @02A6 stack[-4] // @02B8 memory[0x00:0x40] // @02B9 msg.sender // @02C0 memory[0x00:0x40] // @02C1 storage[keccak256(memory[0x00:0x40])] // @02C2 stack[-2] // } 029D 5B JUMPDEST 029E 60 PUSH1 0x01 02A0 60 PUSH1 0x01 02A2 60 PUSH1 0xa0 02A4 1B SHL 02A5 03 SUB 02A6 84 DUP5 02A7 16 AND 02A8 60 PUSH1 0x00 02AA 90 SWAP1 02AB 81 DUP2 02AC 52 MSTORE 02AD 60 PUSH1 0x01 02AF 60 PUSH1 0x20 02B1 90 SWAP1 02B2 81 DUP2 02B3 52 MSTORE 02B4 60 PUSH1 0x40 02B6 80 DUP1 02B7 83 DUP4 02B8 20 SHA3 02B9 33 CALLER 02BA 84 DUP5 02BB 52 MSTORE 02BC 90 SWAP1 02BD 91 SWAP2 02BE 52 MSTORE 02BF 90 SWAP1 02C0 20 SHA3 02C1 54 SLOAD 02C2 82 DUP3 02C3 81 DUP2 02C4 10 LT 02C5 15 ISZERO 02C6 61 PUSH2 0x0327 02C9 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @02AC memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @02B3 memory[0x20:0x40] = 0x01 // @02BB memory[0x00:0x20] = msg.sender // @02BE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @02C1 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0327, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) label_02CA: // Incoming jump from 0x02C9, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[1] { @02CC memory[0x40:0x60] } 02CA 60 PUSH1 0x40 02CC 51 MLOAD 02CD 62 PUSH3 0x461bcd 02D1 60 PUSH1 0xe5 02D3 1B SHL 02D4 81 DUP2 02D5 52 MSTORE 02D6 60 PUSH1 0x20 02D8 60 PUSH1 0x04 02DA 82 DUP3 02DB 01 ADD 02DC 52 MSTORE 02DD 60 PUSH1 0x28 02DF 60 PUSH1 0x24 02E1 82 DUP3 02E2 01 ADD 02E3 52 MSTORE 02E4 7F PUSH32 0x45524332303a207472616e7366657220616d6f756e7420657863656564732061 0305 60 PUSH1 0x44 0307 82 DUP3 0308 01 ADD 0309 52 MSTORE 030A 67 PUSH8 0x6c6c6f77616e6365 0313 60 PUSH1 0xc0 0315 1B SHL 0316 60 PUSH1 0x64 0318 82 DUP3 0319 01 ADD 031A 52 MSTORE 031B 60 PUSH1 0x84 031D 01 ADD // Stack delta = +1 // Outputs[6] // { // @02D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @02DC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @02E3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x28 // @0309 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e7366657220616d6f756e7420657863656564732061 // @031A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6c6c6f77616e6365 << 0xc0 // @031D stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_031E: // Incoming jump from 0x0695 // Incoming jump from 0x05BB // Incoming jump from 0x040D // Incoming jump from 0x0495 // Incoming jump from 0x061D // Incoming jump from 0x031D // Incoming jump from 0x04F6 // Inputs[3] // { // @0321 memory[0x40:0x60] // @0323 stack[-1] // @0326 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 031E 5B JUMPDEST 031F 60 PUSH1 0x40 0321 51 MLOAD 0322 80 DUP1 0323 91 SWAP2 0324 03 SUB 0325 90 SWAP1 0326 FD *REVERT // Stack delta = -1 // Outputs[1] { @0326 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0327: // Incoming jump from 0x02C9, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[4] // { // @032B stack[-5] // @032C msg.sender // @0330 stack[-3] // @0331 stack[-1] // } 0327 5B JUMPDEST 0328 61 PUSH2 0x033b 032B 85 DUP6 032C 33 CALLER 032D 61 PUSH2 0x0336 0330 86 DUP7 0331 85 DUP6 0332 61 PUSH2 0x086e 0335 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0328 stack[0] = 0x033b // @032B stack[1] = stack[-5] // @032C stack[2] = msg.sender // @032D stack[3] = 0x0336 // @0330 stack[4] = stack[-3] // @0331 stack[5] = stack[-1] // } // Block ends with call to 0x086e, returns to 0x0336 label_0336: // Incoming return from call to 0x086E at 0x041C // Incoming return from call to 0x086E at 0x0335 // Incoming return from call to 0x0856 at 0x037C 0336 5B JUMPDEST 0337 61 PUSH2 0x0434 033A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0434 label_033B: // Incoming return from call to 0x0336 at 0x0335 // Inputs[2] // { // @033F stack[-6] // @0340 stack[-5] // } 033B 5B JUMPDEST 033C 50 POP 033D 60 PUSH1 0x01 033F 94 SWAP5 0340 93 SWAP4 0341 50 POP 0342 50 POP 0343 50 POP 0344 50 POP 0345 56 *JUMP // Stack delta = -5 // Outputs[1] { @033F stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_0346: // Incoming jump from 0x0157 // Inputs[6] // { // @0347 msg.sender // @0358 memory[0x00:0x40] // @0361 stack[-2] // @0369 memory[0x00:0x40] // @036A storage[keccak256(memory[0x00:0x40])] // @0377 stack[-1] // } 0346 5B JUMPDEST 0347 33 CALLER 0348 60 PUSH1 0x00 034A 81 DUP2 034B 81 DUP2 034C 52 MSTORE 034D 60 PUSH1 0x01 034F 60 PUSH1 0x20 0351 90 SWAP1 0352 81 DUP2 0353 52 MSTORE 0354 60 PUSH1 0x40 0356 80 DUP1 0357 83 DUP4 0358 20 SHA3 0359 60 PUSH1 0x01 035B 60 PUSH1 0x01 035D 60 PUSH1 0xa0 035F 1B SHL 0360 03 SUB 0361 87 DUP8 0362 16 AND 0363 84 DUP5 0364 52 MSTORE 0365 90 SWAP1 0366 91 SWAP2 0367 52 MSTORE 0368 81 DUP2 0369 20 SHA3 036A 54 SLOAD 036B 90 SWAP1 036C 91 SWAP2 036D 61 PUSH2 0x0287 0370 91 SWAP2 0371 85 DUP6 0372 90 SWAP1 0373 61 PUSH2 0x0336 0376 90 SWAP1 0377 86 DUP7 0378 90 SWAP1 0379 61 PUSH2 0x0856 037C 56 *JUMP // Stack delta = +7 // Outputs[11] // { // @034C memory[0x00:0x20] = msg.sender // @0353 memory[0x20:0x40] = 0x01 // @0364 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0367 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @036C stack[0] = 0x00 // @036C stack[2] = msg.sender // @0370 stack[1] = 0x0287 // @0372 stack[3] = stack[-2] // @0376 stack[4] = 0x0336 // @0378 stack[5] = stack[-1] // @0378 stack[6] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x0856, returns to 0x0336 label_037D: // Incoming call from 0x0188, returns to 0x00B6 // Inputs[1] { @0383 storage[0x04] } 037D 5B JUMPDEST 037E 60 PUSH1 0x60 0380 60 PUSH1 0x04 0382 80 DUP1 0383 54 SLOAD 0384 61 PUSH2 0x01f7 0387 90 SWAP1 0388 61 PUSH2 0x0885 038B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @037E stack[0] = 0x60 // @0380 stack[1] = 0x04 // @0387 stack[2] = 0x01f7 // @0387 stack[3] = storage[0x04] // } // Block ends with call to 0x0885, returns to 0x01F7 label_038C: // Incoming jump from 0x019B // Inputs[6] // { // @038D msg.sender // @039E memory[0x00:0x40] // @03A7 stack[-2] // @03AF memory[0x00:0x40] // @03B0 storage[keccak256(memory[0x00:0x40])] // @03B1 stack[-1] // } 038C 5B JUMPDEST 038D 33 CALLER 038E 60 PUSH1 0x00 0390 90 SWAP1 0391 81 DUP2 0392 52 MSTORE 0393 60 PUSH1 0x01 0395 60 PUSH1 0x20 0397 90 SWAP1 0398 81 DUP2 0399 52 MSTORE 039A 60 PUSH1 0x40 039C 80 DUP1 039D 83 DUP4 039E 20 SHA3 039F 60 PUSH1 0x01 03A1 60 PUSH1 0x01 03A3 60 PUSH1 0xa0 03A5 1B SHL 03A6 03 SUB 03A7 86 DUP7 03A8 16 AND 03A9 84 DUP5 03AA 52 MSTORE 03AB 90 SWAP1 03AC 91 SWAP2 03AD 52 MSTORE 03AE 81 DUP2 03AF 20 SHA3 03B0 54 SLOAD 03B1 82 DUP3 03B2 81 DUP2 03B3 10 LT 03B4 15 ISZERO 03B5 61 PUSH2 0x040e 03B8 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @0390 stack[0] = 0x00 // @0392 memory[0x00:0x20] = msg.sender // @0399 memory[0x20:0x40] = 0x01 // @03AA memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @03AD memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @03B0 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x040e, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) label_03B9: // Incoming jump from 0x03B8, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[1] { @03BB memory[0x40:0x60] } 03B9 60 PUSH1 0x40 03BB 51 MLOAD 03BC 62 PUSH3 0x461bcd 03C0 60 PUSH1 0xe5 03C2 1B SHL 03C3 81 DUP2 03C4 52 MSTORE 03C5 60 PUSH1 0x20 03C7 60 PUSH1 0x04 03C9 82 DUP3 03CA 01 ADD 03CB 52 MSTORE 03CC 60 PUSH1 0x25 03CE 60 PUSH1 0x24 03D0 82 DUP3 03D1 01 ADD 03D2 52 MSTORE 03D3 7F PUSH32 0x45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77 03F4 60 PUSH1 0x44 03F6 82 DUP3 03F7 01 ADD 03F8 52 MSTORE 03F9 64 PUSH5 0x207a65726f 03FF 60 PUSH1 0xd8 0401 1B SHL 0402 60 PUSH1 0x64 0404 82 DUP3 0405 01 ADD 0406 52 MSTORE 0407 60 PUSH1 0x84 0409 01 ADD 040A 61 PUSH2 0x031e 040D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @03C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @03CB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @03D2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @03F8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77 // @0406 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x207a65726f << 0xd8 // @0409 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031e label_040E: // Incoming jump from 0x03B8, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[4] // { // @0412 msg.sender // @0413 stack[-4] // @0417 stack[-3] // @0418 stack[-1] // } 040E 5B JUMPDEST 040F 61 PUSH2 0x041d 0412 33 CALLER 0413 85 DUP6 0414 61 PUSH2 0x0336 0417 86 DUP7 0418 85 DUP6 0419 61 PUSH2 0x086e 041C 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @040F stack[0] = 0x041d // @0412 stack[1] = msg.sender // @0413 stack[2] = stack[-4] // @0414 stack[3] = 0x0336 // @0417 stack[4] = stack[-3] // @0418 stack[5] = stack[-1] // } // Block ends with call to 0x086e, returns to 0x0336 label_041D: // Incoming return from call to 0x0336 at 0x041C // Inputs[2] // { // @0421 stack[-5] // @0422 stack[-4] // } 041D 5B JUMPDEST 041E 50 POP 041F 60 PUSH1 0x01 0421 93 SWAP4 0422 92 SWAP3 0423 50 POP 0424 50 POP 0425 50 POP 0426 56 *JUMP // Stack delta = -4 // Outputs[1] { @0421 stack[-5] = 0x01 } // Block ends with unconditional jump to stack[-5] label_0427: // Incoming jump from 0x01AE // Inputs[3] // { // @042D msg.sender // @042E stack[-2] // @042F stack[-1] // } 0427 5B JUMPDEST 0428 60 PUSH1 0x00 042A 61 PUSH2 0x0287 042D 33 CALLER 042E 84 DUP5 042F 84 DUP5 0430 61 PUSH2 0x0558 0433 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0428 stack[0] = 0x00 // @042A stack[1] = 0x0287 // @042D stack[2] = msg.sender // @042E stack[3] = stack[-2] // @042F stack[4] = stack[-1] // } // Block ends with call to 0x0558, returns to 0x0287 label_0434: // Incoming jump from 0x033A // Incoming call from 0x0286, returns to 0x0287 // Inputs[1] { @043D stack[-3] } 0434 5B JUMPDEST 0435 60 PUSH1 0x01 0437 60 PUSH1 0x01 0439 60 PUSH1 0xa0 043B 1B SHL 043C 03 SUB 043D 83 DUP4 043E 16 AND 043F 61 PUSH2 0x0496 0442 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0496, if stack[-3] & (0x01 << 0xa0) - 0x01 label_0443: // Incoming jump from 0x0442, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0445 memory[0x40:0x60] } 0443 60 PUSH1 0x40 0445 51 MLOAD 0446 62 PUSH3 0x461bcd 044A 60 PUSH1 0xe5 044C 1B SHL 044D 81 DUP2 044E 52 MSTORE 044F 60 PUSH1 0x20 0451 60 PUSH1 0x04 0453 82 DUP3 0454 01 ADD 0455 52 MSTORE 0456 60 PUSH1 0x24 0458 80 DUP1 0459 82 DUP3 045A 01 ADD 045B 52 MSTORE 045C 7F PUSH32 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464 047D 60 PUSH1 0x44 047F 82 DUP3 0480 01 ADD 0481 52 MSTORE 0482 63 PUSH4 0x72657373 0487 60 PUSH1 0xe0 0489 1B SHL 048A 60 PUSH1 0x64 048C 82 DUP3 048D 01 ADD 048E 52 MSTORE 048F 60 PUSH1 0x84 0491 01 ADD 0492 61 PUSH2 0x031e 0495 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @044E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0455 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @045B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @0481 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a20617070726f76652066726f6d20746865207a65726f20616464 // @048E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72657373 << 0xe0 // @0491 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031e label_0496: // Incoming jump from 0x0442, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @049F stack[-2] } 0496 5B JUMPDEST 0497 60 PUSH1 0x01 0499 60 PUSH1 0x01 049B 60 PUSH1 0xa0 049D 1B SHL 049E 03 SUB 049F 82 DUP3 04A0 16 AND 04A1 61 PUSH2 0x04f7 04A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f7, if stack[-2] & (0x01 << 0xa0) - 0x01 label_04A5: // Incoming jump from 0x04A4, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @04A7 memory[0x40:0x60] } 04A5 60 PUSH1 0x40 04A7 51 MLOAD 04A8 62 PUSH3 0x461bcd 04AC 60 PUSH1 0xe5 04AE 1B SHL 04AF 81 DUP2 04B0 52 MSTORE 04B1 60 PUSH1 0x20 04B3 60 PUSH1 0x04 04B5 82 DUP3 04B6 01 ADD 04B7 52 MSTORE 04B8 60 PUSH1 0x22 04BA 60 PUSH1 0x24 04BC 82 DUP3 04BD 01 ADD 04BE 52 MSTORE 04BF 7F PUSH32 0x45524332303a20617070726f766520746f20746865207a65726f206164647265 04E0 60 PUSH1 0x44 04E2 82 DUP3 04E3 01 ADD 04E4 52 MSTORE 04E5 61 PUSH2 0x7373 04E8 60 PUSH1 0xf0 04EA 1B SHL 04EB 60 PUSH1 0x64 04ED 82 DUP3 04EE 01 ADD 04EF 52 MSTORE 04F0 60 PUSH1 0x84 04F2 01 ADD 04F3 61 PUSH2 0x031e 04F6 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @04B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @04B7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @04BE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @04E4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a20617070726f766520746f20746865207a65726f206164647265 // @04EF memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7373 << 0xf0 // @04F2 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031e label_04F7: // Incoming jump from 0x04A4, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[9] // { // @0500 stack[-3] // @0513 memory[0x00:0x40] // @0515 stack[-2] // @0520 memory[0x00:0x40] // @0521 stack[-1] // @0525 memory[0x40:0x60] // @054E memory[0x40:0x60] // @0553 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0557 stack[-4] // } 04F7 5B JUMPDEST 04F8 60 PUSH1 0x01 04FA 60 PUSH1 0x01 04FC 60 PUSH1 0xa0 04FE 1B SHL 04FF 03 SUB 0500 83 DUP4 0501 81 DUP2 0502 16 AND 0503 60 PUSH1 0x00 0505 81 DUP2 0506 81 DUP2 0507 52 MSTORE 0508 60 PUSH1 0x01 050A 60 PUSH1 0x20 050C 90 SWAP1 050D 81 DUP2 050E 52 MSTORE 050F 60 PUSH1 0x40 0511 80 DUP1 0512 83 DUP4 0513 20 SHA3 0514 94 SWAP5 0515 87 DUP8 0516 16 AND 0517 80 DUP1 0518 84 DUP5 0519 52 MSTORE 051A 94 SWAP5 051B 82 DUP3 051C 52 MSTORE 051D 91 SWAP2 051E 82 DUP3 051F 90 SWAP1 0520 20 SHA3 0521 85 DUP6 0522 90 SWAP1 0523 55 SSTORE 0524 90 SWAP1 0525 51 MLOAD 0526 84 DUP5 0527 81 DUP2 0528 52 MSTORE 0529 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 054A 91 SWAP2 054B 01 ADD 054C 60 PUSH1 0x40 054E 51 MLOAD 054F 80 DUP1 0550 91 SWAP2 0551 03 SUB 0552 90 SWAP1 0553 A3 LOG3 0554 50 POP 0555 50 POP 0556 50 POP 0557 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @0507 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @050E memory[0x20:0x40] = 0x01 // @0519 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @051C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0523 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @0528 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0553 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_0558: // Incoming call from 0x029C, returns to 0x029D // Incoming call from 0x0433, returns to 0x0287 // Inputs[1] { @0561 stack[-3] } 0558 5B JUMPDEST 0559 60 PUSH1 0x01 055B 60 PUSH1 0x01 055D 60 PUSH1 0xa0 055F 1B SHL 0560 03 SUB 0561 83 DUP4 0562 16 AND 0563 61 PUSH2 0x05bc 0566 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bc, if stack[-3] & (0x01 << 0xa0) - 0x01 label_0567: // Incoming jump from 0x0566, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0569 memory[0x40:0x60] } 0567 60 PUSH1 0x40 0569 51 MLOAD 056A 62 PUSH3 0x461bcd 056E 60 PUSH1 0xe5 0570 1B SHL 0571 81 DUP2 0572 52 MSTORE 0573 60 PUSH1 0x20 0575 60 PUSH1 0x04 0577 82 DUP3 0578 01 ADD 0579 52 MSTORE 057A 60 PUSH1 0x25 057C 60 PUSH1 0x24 057E 82 DUP3 057F 01 ADD 0580 52 MSTORE 0581 7F PUSH32 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164 05A2 60 PUSH1 0x44 05A4 82 DUP3 05A5 01 ADD 05A6 52 MSTORE 05A7 64 PUSH5 0x6472657373 05AD 60 PUSH1 0xd8 05AF 1B SHL 05B0 60 PUSH1 0x64 05B2 82 DUP3 05B3 01 ADD 05B4 52 MSTORE 05B5 60 PUSH1 0x84 05B7 01 ADD 05B8 61 PUSH2 0x031e 05BB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0572 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0579 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0580 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @05A6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e736665722066726f6d20746865207a65726f206164 // @05B4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6472657373 << 0xd8 // @05B7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031e label_05BC: // Incoming jump from 0x0566, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @05C5 stack[-2] } 05BC 5B JUMPDEST 05BD 60 PUSH1 0x01 05BF 60 PUSH1 0x01 05C1 60 PUSH1 0xa0 05C3 1B SHL 05C4 03 SUB 05C5 82 DUP3 05C6 16 AND 05C7 61 PUSH2 0x061e 05CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x061e, if stack[-2] & (0x01 << 0xa0) - 0x01 label_05CB: // Incoming jump from 0x05CA, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @05CD memory[0x40:0x60] } 05CB 60 PUSH1 0x40 05CD 51 MLOAD 05CE 62 PUSH3 0x461bcd 05D2 60 PUSH1 0xe5 05D4 1B SHL 05D5 81 DUP2 05D6 52 MSTORE 05D7 60 PUSH1 0x20 05D9 60 PUSH1 0x04 05DB 82 DUP3 05DC 01 ADD 05DD 52 MSTORE 05DE 60 PUSH1 0x23 05E0 60 PUSH1 0x24 05E2 82 DUP3 05E3 01 ADD 05E4 52 MSTORE 05E5 7F PUSH32 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472 0606 60 PUSH1 0x44 0608 82 DUP3 0609 01 ADD 060A 52 MSTORE 060B 62 PUSH3 0x657373 060F 60 PUSH1 0xe8 0611 1B SHL 0612 60 PUSH1 0x64 0614 82 DUP3 0615 01 ADD 0616 52 MSTORE 0617 60 PUSH1 0x84 0619 01 ADD 061A 61 PUSH2 0x031e 061D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @05D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05DD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05E4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @060A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e7366657220746f20746865207a65726f2061646472 // @0616 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x657373 << 0xe8 // @0619 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031e label_061E: // Incoming jump from 0x05CA, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0627 stack[-3] // @0636 memory[0x00:0x40] // @0637 storage[keccak256(memory[0x00:0x40])] // @0638 stack[-1] // } 061E 5B JUMPDEST 061F 60 PUSH1 0x01 0621 60 PUSH1 0x01 0623 60 PUSH1 0xa0 0625 1B SHL 0626 03 SUB 0627 83 DUP4 0628 16 AND 0629 60 PUSH1 0x00 062B 90 SWAP1 062C 81 DUP2 062D 52 MSTORE 062E 60 PUSH1 0x20 0630 81 DUP2 0631 90 SWAP1 0632 52 MSTORE 0633 60 PUSH1 0x40 0635 90 SWAP1 0636 20 SHA3 0637 54 SLOAD 0638 81 DUP2 0639 81 DUP2 063A 10 LT 063B 15 ISZERO 063C 61 PUSH2 0x0696 063F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @062D memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0632 memory[0x20:0x40] = 0x00 // @0637 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0696, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) label_0640: // Incoming jump from 0x063F, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[1] { @0642 memory[0x40:0x60] } 0640 60 PUSH1 0x40 0642 51 MLOAD 0643 62 PUSH3 0x461bcd 0647 60 PUSH1 0xe5 0649 1B SHL 064A 81 DUP2 064B 52 MSTORE 064C 60 PUSH1 0x20 064E 60 PUSH1 0x04 0650 82 DUP3 0651 01 ADD 0652 52 MSTORE 0653 60 PUSH1 0x26 0655 60 PUSH1 0x24 0657 82 DUP3 0658 01 ADD 0659 52 MSTORE 065A 7F PUSH32 0x45524332303a207472616e7366657220616d6f756e7420657863656564732062 067B 60 PUSH1 0x44 067D 82 DUP3 067E 01 ADD 067F 52 MSTORE 0680 65 PUSH6 0x616c616e6365 0687 60 PUSH1 0xd0 0689 1B SHL 068A 60 PUSH1 0x64 068C 82 DUP3 068D 01 ADD 068E 52 MSTORE 068F 60 PUSH1 0x84 0691 01 ADD 0692 61 PUSH2 0x031e 0695 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @064B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0652 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0659 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @067F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45524332303a207472616e7366657220616d6f756e7420657863656564732062 // @068E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616c616e6365 << 0xd0 // @0691 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031e label_0696: // Incoming jump from 0x063F, if !(storage[keccak256(memory[0x00:0x40])] < stack[-1]) // Inputs[2] // { // @069A stack[-2] // @069B stack[-1] // } 0696 5B JUMPDEST 0697 61 PUSH2 0x06a0 069A 82 DUP3 069B 82 DUP3 069C 61 PUSH2 0x086e 069F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0697 stack[0] = 0x06a0 // @069A stack[1] = stack[-2] // @069B stack[2] = stack[-1] // } // Block ends with call to 0x086e, returns to 0x06A0 label_06A0: // Incoming return from call to 0x086E at 0x069F // Inputs[7] // { // @06AA stack[-5] // @06BA memory[0x00:0x40] // @06BB stack[-1] // @06C0 stack[-4] // @06C6 memory[0x00:0x40] // @06C8 storage[keccak256(memory[0x00:0x40])] // @06C9 stack[-3] // } 06A0 5B JUMPDEST 06A1 60 PUSH1 0x01 06A3 60 PUSH1 0x01 06A5 60 PUSH1 0xa0 06A7 1B SHL 06A8 03 SUB 06A9 80 DUP1 06AA 86 DUP7 06AB 16 AND 06AC 60 PUSH1 0x00 06AE 90 SWAP1 06AF 81 DUP2 06B0 52 MSTORE 06B1 60 PUSH1 0x20 06B3 81 DUP2 06B4 90 SWAP1 06B5 52 MSTORE 06B6 60 PUSH1 0x40 06B8 80 DUP1 06B9 82 DUP3 06BA 20 SHA3 06BB 93 SWAP4 06BC 90 SWAP1 06BD 93 SWAP4 06BE 55 SSTORE 06BF 90 SWAP1 06C0 85 DUP6 06C1 16 AND 06C2 81 DUP2 06C3 52 MSTORE 06C4 90 SWAP1 06C5 81 DUP2 06C6 20 SHA3 06C7 80 DUP1 06C8 54 SLOAD 06C9 84 DUP5 06CA 92 SWAP3 06CB 90 SWAP1 06CC 61 PUSH2 0x06d6 06CF 90 SWAP1 06D0 84 DUP5 06D1 90 SWAP1 06D2 61 PUSH2 0x0856 06D5 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @06B0 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @06B5 memory[0x20:0x40] = 0x00 // @06BE storage[keccak256(memory[0x00:0x40])] = stack[-1] // @06C3 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @06C6 stack[0] = keccak256(memory[0x00:0x40]) // @06CA stack[-1] = stack[-3] // @06CB stack[1] = 0x00 // @06CF stack[2] = 0x06d6 // @06D1 stack[4] = storage[keccak256(memory[0x00:0x40])] // @06D1 stack[3] = stack[-3] // } // Block ends with call to 0x0856, returns to 0x06D6 label_06D6: // Incoming return from call to 0x0856 at 0x06D5 // Inputs[7] // { // @06D7 stack[-1] // @06D7 stack[-4] // @06DB stack[-3] // @06DE stack[-7] // @06E8 stack[-8] // @0713 stack[-6] // @0716 memory[0x40:0x60] // } 06D6 5B JUMPDEST 06D7 92 SWAP3 06D8 50 POP 06D9 50 POP 06DA 81 DUP2 06DB 90 SWAP1 06DC 55 SSTORE 06DD 50 POP 06DE 82 DUP3 06DF 60 PUSH1 0x01 06E1 60 PUSH1 0x01 06E3 60 PUSH1 0xa0 06E5 1B SHL 06E6 03 SUB 06E7 16 AND 06E8 84 DUP5 06E9 60 PUSH1 0x01 06EB 60 PUSH1 0x01 06ED 60 PUSH1 0xa0 06EF 1B SHL 06F0 03 SUB 06F1 16 AND 06F2 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0713 84 DUP5 0714 60 PUSH1 0x40 0716 51 MLOAD 0717 61 PUSH2 0x0722 071A 91 SWAP2 071B 81 DUP2 071C 52 MSTORE 071D 60 PUSH1 0x20 071F 01 ADD 0720 90 SWAP1 0721 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @06DC storage[stack[-3]] = stack[-1] // @06E7 stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-7] // @06F1 stack[-3] = (0x01 << 0xa0) - 0x01 & stack[-8] // @06F2 stack[-2] = 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef // @071C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-6] // @0720 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0722 label_0722: // Incoming jump from 0x0721 // Inputs[7] // { // @0725 memory[0x40:0x60] // @0727 stack[-1] // @072A stack[-3] // @072A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @072A stack[-2] // @072A stack[-4] // @072F stack[-9] // } 0722 5B JUMPDEST 0723 60 PUSH1 0x40 0725 51 MLOAD 0726 80 DUP1 0727 91 SWAP2 0728 03 SUB 0729 90 SWAP1 072A A3 LOG3 072B 50 POP 072C 50 POP 072D 50 POP 072E 50 POP 072F 56 *JUMP // Stack delta = -9 // Outputs[1] { @072A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-9] label_0730: // Incoming call from 0x0787, returns to 0x0788 // Incoming call from 0x07C9, returns to 0x07CA // Incoming call from 0x07BB, returns to 0x07BC // Incoming call from 0x0795, returns to 0x0796 // Incoming call from 0x07F4, returns to 0x07F5 // Incoming call from 0x0765, returns to 0x0766 // Inputs[2] // { // @0731 stack[-1] // @0732 msg.data[stack[-1]:stack[-1] + 0x20] // } 0730 5B JUMPDEST 0731 80 DUP1 0732 35 CALLDATALOAD 0733 60 PUSH1 0x01 0735 60 PUSH1 0x01 0737 60 PUSH1 0xa0 0739 1B SHL 073A 03 SUB 073B 81 DUP2 073C 16 AND 073D 81 DUP2 073E 14 EQ 073F 61 PUSH2 0x0747 0742 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0732 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0747, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_0743: // Incoming jump from 0x0742, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0746 memory[0x00:0x00] } 0743 60 PUSH1 0x00 0745 80 DUP1 0746 FD *REVERT // Stack delta = +0 // Outputs[1] { @0746 revert(memory[0x00:0x00]); } // Block terminates label_0747: // Incoming jump from 0x0742, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0748 stack[-3] // @0748 stack[-1] // @0749 stack[-2] // } 0747 5B JUMPDEST 0748 91 SWAP2 0749 90 SWAP1 074A 50 POP 074B 56 *JUMP // Stack delta = -2 // Outputs[1] { @0748 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_074C: // Incoming call from 0x0165, returns to 0x0166 // Inputs[2] // { // @0751 stack[-1] // @0752 stack[-2] // } 074C 5B JUMPDEST 074D 60 PUSH1 0x00 074F 60 PUSH1 0x20 0751 82 DUP3 0752 84 DUP5 0753 03 SUB 0754 12 SLT 0755 15 ISZERO 0756 61 PUSH2 0x075d 0759 57 *JUMPI // Stack delta = +1 // Outputs[1] { @074D stack[0] = 0x00 } // Block ends with conditional jump to 0x075d, if !(stack[-2] - stack[-1] i< 0x20) label_075A: // Incoming jump from 0x0759, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @075A stack[-1] // @075C memory[stack[-1]:stack[-1] + stack[-1]] // } 075A 80 DUP1 075B 81 DUP2 075C FD *REVERT // Stack delta = +0 // Outputs[1] { @075C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_075D: // Incoming jump from 0x0759, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @0761 stack[-2] } 075D 5B JUMPDEST 075E 61 PUSH2 0x0766 0761 82 DUP3 0762 61 PUSH2 0x0730 0765 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @075E stack[0] = 0x0766 // @0761 stack[1] = stack[-2] // } // Block ends with call to 0x0730, returns to 0x0766 label_0766: // Incoming return from call to 0x0730 at 0x0765 // Inputs[3] // { // @0767 stack[-5] // @0767 stack[-1] // @0768 stack[-4] // } 0766 5B JUMPDEST 0767 93 SWAP4 0768 92 SWAP3 0769 50 POP 076A 50 POP 076B 50 POP 076C 56 *JUMP // Stack delta = -4 // Outputs[1] { @0767 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_076D: // Incoming call from 0x01BC, returns to 0x01BD // Inputs[2] // { // @0773 stack[-1] // @0774 stack[-2] // } 076D 5B JUMPDEST 076E 60 PUSH1 0x00 0770 80 DUP1 0771 60 PUSH1 0x40 0773 83 DUP4 0774 85 DUP6 0775 03 SUB 0776 12 SLT 0777 15 ISZERO 0778 61 PUSH2 0x077f 077B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @076E stack[0] = 0x00 // @0770 stack[1] = 0x00 // } // Block ends with conditional jump to 0x077f, if !(stack[-2] - stack[-1] i< 0x40) label_077C: // Incoming jump from 0x077B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @077C stack[-1] // @077E memory[stack[-1]:stack[-1] + stack[-1]] // } 077C 80 DUP1 077D 81 DUP2 077E FD *REVERT // Stack delta = +0 // Outputs[1] { @077E revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_077F: // Incoming jump from 0x077B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @0783 stack[-3] } 077F 5B JUMPDEST 0780 61 PUSH2 0x0788 0783 83 DUP4 0784 61 PUSH2 0x0730 0787 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0780 stack[0] = 0x0788 // @0783 stack[1] = stack[-3] // } // Block ends with call to 0x0730, returns to 0x0788 label_0788: // Incoming return from call to 0x0730 at 0x0787 // Inputs[3] // { // @0789 stack[-1] // @0789 stack[-3] // @0790 stack[-4] // } 0788 5B JUMPDEST 0789 91 SWAP2 078A 50 POP 078B 61 PUSH2 0x0796 078E 60 PUSH1 0x20 0790 84 DUP5 0791 01 ADD 0792 61 PUSH2 0x0730 0795 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0789 stack[-3] = stack[-1] // @078B stack[-1] = 0x0796 // @0791 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x0730, returns to 0x0796 label_0796: // Incoming return from call to 0x0730 at 0x0795 // Inputs[6] // { // @0797 stack[-2] // @0797 stack[-1] // @0799 stack[-5] // @079B stack[-3] // @079B stack[-6] // @079C stack[-4] // } 0796 5B JUMPDEST 0797 90 SWAP1 0798 50 POP 0799 92 SWAP3 079A 50 POP 079B 92 SWAP3 079C 90 SWAP1 079D 50 POP 079E 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0799 stack[-5] = stack[-1] // @079B stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_079F: // Incoming call from 0x010E, returns to 0x010F // Inputs[2] // { // @07A7 stack[-1] // @07A8 stack[-2] // } 079F 5B JUMPDEST 07A0 60 PUSH1 0x00 07A2 80 DUP1 07A3 60 PUSH1 0x00 07A5 60 PUSH1 0x60 07A7 84 DUP5 07A8 86 DUP7 07A9 03 SUB 07AA 12 SLT 07AB 15 ISZERO 07AC 61 PUSH2 0x07b3 07AF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @07A0 stack[0] = 0x00 // @07A2 stack[1] = 0x00 // @07A3 stack[2] = 0x00 // } // Block ends with conditional jump to 0x07b3, if !(stack[-2] - stack[-1] i< 0x60) label_07B0: // Incoming jump from 0x07AF, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @07B0 stack[-1] // @07B2 memory[stack[-1]:stack[-1] + stack[-1]] // } 07B0 80 DUP1 07B1 81 DUP2 07B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B2 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_07B3: // Incoming jump from 0x07AF, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @07B7 stack[-4] } 07B3 5B JUMPDEST 07B4 61 PUSH2 0x07bc 07B7 84 DUP5 07B8 61 PUSH2 0x0730 07BB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07B4 stack[0] = 0x07bc // @07B7 stack[1] = stack[-4] // } // Block ends with call to 0x0730, returns to 0x07BC label_07BC: // Incoming return from call to 0x0730 at 0x07BB // Inputs[3] // { // @07BD stack[-4] // @07BD stack[-1] // @07C4 stack[-5] // } 07BC 5B JUMPDEST 07BD 92 SWAP3 07BE 50 POP 07BF 61 PUSH2 0x07ca 07C2 60 PUSH1 0x20 07C4 85 DUP6 07C5 01 ADD 07C6 61 PUSH2 0x0730 07C9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @07BD stack[-4] = stack[-1] // @07BF stack[-1] = 0x07ca // @07C5 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x0730, returns to 0x07CA label_07CA: // Incoming return from call to 0x0730 at 0x07C9 // Inputs[8] // { // @07CB stack[-1] // @07CB stack[-3] // @07CF stack[-5] // @07D1 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @07D2 stack[-2] // @07D6 stack[-6] // @07D8 stack[-4] // @07D8 stack[-7] // } 07CA 5B JUMPDEST 07CB 91 SWAP2 07CC 50 POP 07CD 60 PUSH1 0x40 07CF 84 DUP5 07D0 01 ADD 07D1 35 CALLDATALOAD 07D2 90 SWAP1 07D3 50 POP 07D4 92 SWAP3 07D5 50 POP 07D6 92 SWAP3 07D7 50 POP 07D8 92 SWAP3 07D9 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @07D4 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @07D6 stack[-6] = stack[-1] // @07D8 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_07DA: // Incoming call from 0x00D9, returns to 0x00DA // Incoming call from 0x01A9, returns to 0x01AA // Incoming call from 0x0196, returns to 0x0197 // Incoming call from 0x0152, returns to 0x0153 // Inputs[2] // { // @07E0 stack[-1] // @07E1 stack[-2] // } 07DA 5B JUMPDEST 07DB 60 PUSH1 0x00 07DD 80 DUP1 07DE 60 PUSH1 0x40 07E0 83 DUP4 07E1 85 DUP6 07E2 03 SUB 07E3 12 SLT 07E4 15 ISZERO 07E5 61 PUSH2 0x07ec 07E8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @07DB stack[0] = 0x00 // @07DD stack[1] = 0x00 // } // Block ends with conditional jump to 0x07ec, if !(stack[-2] - stack[-1] i< 0x40) label_07E9: // Incoming jump from 0x07E8, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @07E9 stack[-2] // @07EB memory[stack[-2]:stack[-2] + stack[-2]] // } 07E9 81 DUP2 07EA 82 DUP3 07EB FD *REVERT // Stack delta = +0 // Outputs[1] { @07EB revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_07EC: // Incoming jump from 0x07E8, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @07F0 stack[-3] } 07EC 5B JUMPDEST 07ED 61 PUSH2 0x07f5 07F0 83 DUP4 07F1 61 PUSH2 0x0730 07F4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07ED stack[0] = 0x07f5 // @07F0 stack[1] = stack[-3] // } // Block ends with call to 0x0730, returns to 0x07F5 label_07F5: // Incoming return from call to 0x0730 at 0x07F4 // Inputs[5] // { // @07F6 stack[-6] // @07F6 stack[-1] // @07F9 stack[-4] // @07FD msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @07FE stack[-5] // } 07F5 5B JUMPDEST 07F6 94 SWAP5 07F7 60 PUSH1 0x20 07F9 93 SWAP4 07FA 90 SWAP1 07FB 93 SWAP4 07FC 01 ADD 07FD 35 CALLDATALOAD 07FE 93 SWAP4 07FF 50 POP 0800 50 POP 0801 50 POP 0802 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @07F6 stack[-6] = stack[-1] // @07FE stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_0803: // Incoming call from 0x00C2, returns to 0x00C3 // Inputs[3] // { // @0809 stack[-1] // @080B stack[-2] // @080C memory[stack[-2]:stack[-2] + 0x20] // } 0803 5B JUMPDEST 0804 60 PUSH1 0x00 0806 60 PUSH1 0x20 0808 80 DUP1 0809 83 DUP4 080A 52 MSTORE 080B 83 DUP4 080C 51 MLOAD 080D 80 DUP1 080E 82 DUP3 080F 85 DUP6 0810 01 ADD 0811 52 MSTORE 0812 82 DUP3 0813 5B JUMPDEST 0814 81 DUP2 0815 81 DUP2 0816 10 LT 0817 15 ISZERO 0818 61 PUSH2 0x082f 081B 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @0804 stack[0] = 0x00 // @0806 stack[1] = 0x20 // @080A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @080C stack[2] = memory[stack[-2]:stack[-2] + 0x20] // @0811 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @0812 stack[3] = 0x00 // } // Block ends with conditional jump to 0x082f, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_081C: // Incoming jump from 0x081B, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x081B, if not !(stack[-1] < stack[-2]) // Inputs[5] // { // @081C stack[-6] // @081D stack[-1] // @081F stack[-3] // @0821 memory[stack[-3] + stack[-1] + stack[-6]:stack[-3] + stack[-1] + stack[-6] + 0x20] // @0822 stack[-5] // } 081C 85 DUP6 081D 81 DUP2 081E 01 ADD 081F 83 DUP4 0820 01 ADD 0821 51 MLOAD 0822 85 DUP6 0823 82 DUP3 0824 01 ADD 0825 60 PUSH1 0x40 0827 01 ADD 0828 52 MSTORE 0829 82 DUP3 082A 01 ADD 082B 61 PUSH2 0x0813 082E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0828 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] // @082A stack[-1] = stack[-3] + stack[-1] // } // Block ends with unconditional jump to 0x0813 label_082F: // Incoming jump from 0x081B, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x081B, if !(stack[-1] < stack[-2]) // Inputs[2] // { // @0830 stack[-2] // @0831 stack[-1] // } 082F 5B JUMPDEST 0830 81 DUP2 0831 81 DUP2 0832 11 GT 0833 15 ISZERO 0834 61 PUSH2 0x0840 0837 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0840, if !(stack[-1] > stack[-2]) label_0838: // Incoming jump from 0x0837, if not !(stack[-1] > stack[-2]) // Inputs[6] // { // @0838 stack[-4] // @083B stack[-2] // @083C stack[-5] // @084A stack[-3] // @0850 stack[-7] // @0851 stack[-6] // } 0838 83 DUP4 0839 60 PUSH1 0x40 083B 83 DUP4 083C 87 DUP8 083D 01 ADD 083E 01 ADD 083F 52 MSTORE 0840 5B JUMPDEST 0841 50 POP 0842 60 PUSH1 0x1f 0844 01 ADD 0845 60 PUSH1 0x1f 0847 19 NOT 0848 16 AND 0849 92 SWAP3 084A 90 SWAP1 084B 92 SWAP3 084C 01 ADD 084D 60 PUSH1 0x40 084F 01 ADD 0850 93 SWAP4 0851 92 SWAP3 0852 50 POP 0853 50 POP 0854 50 POP 0855 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @083F memory[stack[-5] + stack[-2] + 0x40:stack[-5] + stack[-2] + 0x40 + 0x20] = stack[-4] // @0850 stack[-7] = 0x40 + (~0x1f & 0x1f + stack[-2]) + stack[-5] // } // Block ends with unconditional jump to stack[-7] label_0856: // Incoming call from 0x06D5, returns to 0x06D6 // Incoming call from 0x037C, returns to 0x0336 // Inputs[2] // { // @0859 stack[-2] // @085B stack[-1] // } 0856 5B JUMPDEST 0857 60 PUSH1 0x00 0859 82 DUP3 085A 19 NOT 085B 82 DUP3 085C 11 GT 085D 15 ISZERO 085E 61 PUSH2 0x0869 0861 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0857 stack[0] = 0x00 } // Block ends with conditional jump to 0x0869, if !(stack[-1] > ~stack[-2]) label_0862: // Incoming jump from 0x0861, if not !(stack[-1] > ~stack[-2]) 0862 61 PUSH2 0x0869 0865 61 PUSH2 0x08c0 0868 56 *JUMP // Stack delta = +1 // Outputs[1] { @0862 stack[0] = 0x0869 } // Block ends with unconditional jump to 0x08c0 label_0869: // Incoming jump from 0x0861, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @086B stack[-3] // @086B stack[-2] // @086C stack[-4] // } 0869 5B JUMPDEST 086A 50 POP 086B 01 ADD 086C 90 SWAP1 086D 56 *JUMP // Stack delta = -3 // Outputs[1] { @086C stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_086E: // Incoming call from 0x041C, returns to 0x0336 // Incoming call from 0x069F, returns to 0x06A0 // Incoming call from 0x0335, returns to 0x0336 // Inputs[2] // { // @0871 stack[-2] // @0872 stack[-1] // } 086E 5B JUMPDEST 086F 60 PUSH1 0x00 0871 82 DUP3 0872 82 DUP3 0873 10 LT 0874 15 ISZERO 0875 61 PUSH2 0x0880 0878 57 *JUMPI // Stack delta = +1 // Outputs[1] { @086F stack[0] = 0x00 } // Block ends with conditional jump to 0x0880, if !(stack[-1] < stack[-2]) label_0879: // Incoming jump from 0x0878, if not !(stack[-1] < stack[-2]) 0879 61 PUSH2 0x0880 087C 61 PUSH2 0x08c0 087F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0879 stack[0] = 0x0880 } // Block ends with unconditional jump to 0x08c0 label_0880: // Incoming jump from 0x0878, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @0882 stack[-2] // @0882 stack[-3] // @0883 stack[-4] // } 0880 5B JUMPDEST 0881 50 POP 0882 03 SUB 0883 90 SWAP1 0884 56 *JUMP // Stack delta = -3 // Outputs[1] { @0883 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_0885: // Incoming call from 0x01F6, returns to 0x01F7 // Incoming call from 0x038B, returns to 0x01F7 // Incoming call from 0x0222, returns to 0x0223 // Inputs[1] { @0888 stack[-1] } 0885 5B JUMPDEST 0886 60 PUSH1 0x01 0888 81 DUP2 0889 81 DUP2 088A 1C SHR 088B 90 SWAP1 088C 82 DUP3 088D 16 AND 088E 80 DUP1 088F 61 PUSH2 0x0899 0892 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @088B stack[0] = stack[-1] >> 0x01 // @088D stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x0899, if stack[-1] & 0x01 label_0893: // Incoming jump from 0x0892, if not stack[-1] & 0x01 // Inputs[2] // { // @0895 stack[-2] // @089E stack[-1] // } 0893 60 PUSH1 0x7f 0895 82 DUP3 0896 16 AND 0897 91 SWAP2 0898 50 POP 0899 5B JUMPDEST 089A 60 PUSH1 0x20 089C 82 DUP3 089D 10 LT 089E 81 DUP2 089F 14 EQ 08A0 15 ISZERO 08A1 61 PUSH2 0x08ba 08A4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0897 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x08ba, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_08A5: // Incoming jump from 0x08A4, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x08A4, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @08B9 memory[0x00:0x24] } 08A5 63 PUSH4 0x4e487b71 08AA 60 PUSH1 0xe0 08AC 1B SHL 08AD 60 PUSH1 0x00 08AF 52 MSTORE 08B0 60 PUSH1 0x22 08B2 60 PUSH1 0x04 08B4 52 MSTORE 08B5 60 PUSH1 0x24 08B7 60 PUSH1 0x00 08B9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @08AF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @08B4 memory[0x04:0x24] = 0x22 // @08B9 revert(memory[0x00:0x24]); // } // Block terminates label_08BA: // Incoming jump from 0x08A4, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x08A4, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @08BC stack[-4] // @08BC stack[-2] // @08BD stack[-3] // } 08BA 5B JUMPDEST 08BB 50 POP 08BC 91 SWAP2 08BD 90 SWAP1 08BE 50 POP 08BF 56 *JUMP // Stack delta = -3 // Outputs[1] { @08BC stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_08C0: // Incoming jump from 0x0868 // Incoming jump from 0x087F // Inputs[1] { @08D5 memory[0x00:0x24] } 08C0 5B JUMPDEST 08C1 63 PUSH4 0x4e487b71 08C6 60 PUSH1 0xe0 08C8 1B SHL 08C9 60 PUSH1 0x00 08CB 52 MSTORE 08CC 60 PUSH1 0x11 08CE 60 PUSH1 0x04 08D0 52 MSTORE 08D1 60 PUSH1 0x24 08D3 60 PUSH1 0x00 08D5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @08CB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @08D0 memory[0x04:0x24] = 0x11 // @08D5 revert(memory[0x00:0x24]); // } // Block terminates 08D6 FE *ASSERT 08D7 A2 LOG2 08D8 64 PUSH5 0x6970667358 08DE 22 22 08DF 12 SLT 08E0 20 SHA3 08E1 14 EQ 08E2 4D 4D 08E3 B6 B6 08E4 57 *JUMPI 08E5 23 23 08E6 BE BE 08E7 67 PUSH8 0x4fc6b6059f66e6c1 08F0 61 PUSH2 0xa8a6 08F3 54 SLOAD 08F4 B6 B6 08F5 74 PUSH21 0xf60044e98e303bee19773964736f6c634300080400 090B 33 CALLER