Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x00c2 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x00c2, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x313ce567 0019 11 GT 001A 61 PUSH2 0x007f 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x007f, if 0x313ce567 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x313ce567 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa9059cbb 0024 11 GT 0025 61 PUSH2 0x0059 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0059, if 0xa9059cbb > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa9059cbb > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xa9059cbb 002F 14 EQ 0030 61 PUSH2 0x030d 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030d, if 0xa9059cbb == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xa9059cbb == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xaa2f5220 003A 14 EQ 003B 61 PUSH2 0x0339 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0339, if 0xaa2f5220 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xaa2f5220 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xd6d2b6ba 0045 14 EQ 0046 61 PUSH2 0x03de 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03de, if 0xd6d2b6ba == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xd6d2b6ba == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xdd62ed3e 0050 14 EQ 0051 61 PUSH2 0x0496 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0496, if 0xdd62ed3e == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xdd62ed3e == stack[-1] 0055 61 PUSH2 0x00c2 0058 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00c2 label_0059: // Incoming jump from 0x0028, if 0xa9059cbb > stack[-1] // Inputs[1] { @005A stack[-1] } 0059 5B JUMPDEST 005A 80 DUP1 005B 63 PUSH4 0x313ce567 0060 14 EQ 0061 61 PUSH2 0x02b0 0064 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b0, if 0x313ce567 == stack[-1] label_0065: // Incoming jump from 0x0064, if not 0x313ce567 == stack[-1] // Inputs[1] { @0065 stack[-1] } 0065 80 DUP1 0066 63 PUSH4 0x70a08231 006B 14 EQ 006C 61 PUSH2 0x02c5 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c5, if 0x70a08231 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x70a08231 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0x95d89b41 0076 14 EQ 0077 61 PUSH2 0x02f8 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f8, if 0x95d89b41 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x95d89b41 == stack[-1] 007B 61 PUSH2 0x00c2 007E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x00c2 label_007F: // Incoming jump from 0x001D, if 0x313ce567 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0080 stack[-1] } 007F 5B JUMPDEST 0080 80 DUP1 0081 63 PUSH4 0x06fdde03 0086 14 EQ 0087 61 PUSH2 0x00d1 008A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d1, if 0x06fdde03 == stack[-1] label_008B: // Incoming jump from 0x008A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @008B stack[-1] } 008B 80 DUP1 008C 63 PUSH4 0x095ea7b3 0091 14 EQ 0092 61 PUSH2 0x015b 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015b, if 0x095ea7b3 == stack[-1] label_0096: // Incoming jump from 0x0095, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0x18160ddd 009C 14 EQ 009D 61 PUSH2 0x019b 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x019b, if 0x18160ddd == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x18160ddd == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x1ba1ccab 00A7 14 EQ 00A8 61 PUSH2 0x01c2 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c2, if 0x1ba1ccab == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x1ba1ccab == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x23b872dd 00B2 14 EQ 00B3 61 PUSH2 0x0265 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0265, if 0x23b872dd == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x23b872dd == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x295b4e17 00BD 14 EQ 00BE 61 PUSH2 0x029b 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029b, if 0x295b4e17 == stack[-1] label_00C2: // Incoming jump from 0x0058 // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x007E // Incoming jump from 0x00C1, if not 0x295b4e17 == stack[-1] // Inputs[1] { @00C6 storage[0x08] } 00C2 5B JUMPDEST 00C3 60 PUSH1 0x08 00C5 80 DUP1 00C6 54 SLOAD 00C7 60 PUSH1 0xff 00C9 19 NOT 00CA 16 AND 00CB 60 PUSH1 0x01 00CD 17 OR 00CE 90 SWAP1 00CF 55 SSTORE 00D0 00 *STOP // Stack delta = +0 // Outputs[2] // { // @00CF storage[0x08] = 0x01 | (~0xff & storage[0x08]) // @00D0 stop(); // } // Block terminates label_00D1: // Incoming jump from 0x008A, if 0x06fdde03 == stack[-1] // Inputs[1] { @00D2 msg.value } 00D1 5B JUMPDEST 00D2 34 CALLVALUE 00D3 80 DUP1 00D4 15 ISZERO 00D5 61 PUSH2 0x00dd 00D8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @00D2 stack[0] = msg.value } // Block ends with conditional jump to 0x00dd, if !msg.value label_00D9: // Incoming jump from 0x00D8, if not !msg.value // Inputs[1] { @00DC memory[0x00:0x00] } 00D9 60 PUSH1 0x00 00DB 80 DUP1 00DC FD *REVERT // Stack delta = +0 // Outputs[1] { @00DC revert(memory[0x00:0x00]); } // Block terminates label_00DD: // Incoming jump from 0x00D8, if !msg.value 00DD 5B JUMPDEST 00DE 50 POP 00DF 61 PUSH2 0x00e6 00E2 61 PUSH2 0x04d1 00E5 56 *JUMP // Stack delta = +0 // Outputs[1] { @00DF stack[-1] = 0x00e6 } // Block ends with call to 0x04d1, returns to 0x00E6 label_00E6: // Incoming return from call to 0x0809 at 0x030C // Incoming return from call to 0x04D1 at 0x00E5 // Inputs[4] // { // @00EA memory[0x40:0x60] // @00F0 stack[-1] // @00F1 memory[stack[-1]:stack[-1] + 0x20] // @00F7 memory[stack[-1]:stack[-1] + 0x20] // } 00E6 5B JUMPDEST 00E7 60 PUSH1 0x40 00E9 80 DUP1 00EA 51 MLOAD 00EB 60 PUSH1 0x20 00ED 80 DUP1 00EE 82 DUP3 00EF 52 MSTORE 00F0 83 DUP4 00F1 51 MLOAD 00F2 81 DUP2 00F3 83 DUP4 00F4 01 ADD 00F5 52 MSTORE 00F6 83 DUP4 00F7 51 MLOAD 00F8 91 SWAP2 00F9 92 SWAP3 00FA 83 DUP4 00FB 92 SWAP3 00FC 90 SWAP1 00FD 83 DUP4 00FE 01 ADD 00FF 91 SWAP2 0100 85 DUP6 0101 01 ADD 0102 90 SWAP1 0103 80 DUP1 0104 83 DUP4 0105 83 DUP4 0106 60 PUSH1 0x00 0108 5B JUMPDEST 0109 83 DUP4 010A 81 DUP2 010B 10 LT 010C 15 ISZERO 010D 61 PUSH2 0x0120 0110 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @00EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @00F5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @00F9 stack[0] = memory[0x40:0x60] // @00FB stack[1] = memory[0x40:0x60] // @00FF stack[2] = memory[0x40:0x60] + 0x40 // @0102 stack[3] = stack[-1] + 0x20 // @0102 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0103 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0104 stack[6] = memory[0x40:0x60] + 0x40 // @0105 stack[7] = stack[-1] + 0x20 // @0106 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0120, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0111: // Incoming jump from 0x0110, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0110, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0111 stack[-2] // @0112 stack[-1] // @0114 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @0115 stack[-3] // } 0111 81 DUP2 0112 81 DUP2 0113 01 ADD 0114 51 MLOAD 0115 83 DUP4 0116 82 DUP3 0117 01 ADD 0118 52 MSTORE 0119 60 PUSH1 0x20 011B 01 ADD 011C 61 PUSH2 0x0108 011F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0118 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @011B stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0108 label_0120: // Incoming jump from 0x0110, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0110, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0125 stack[-6] // @0125 stack[-5] // @0127 stack[-7] // } 0120 5B JUMPDEST 0121 50 POP 0122 50 POP 0123 50 POP 0124 50 POP 0125 90 SWAP1 0126 50 POP 0127 90 SWAP1 0128 81 DUP2 0129 01 ADD 012A 90 SWAP1 012B 60 PUSH1 0x1f 012D 16 AND 012E 80 DUP1 012F 15 ISZERO 0130 61 PUSH2 0x014d 0133 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @012A stack[-7] = stack[-5] + stack[-7] // @012D stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x014d, if !(0x1f & stack[-5]) label_0134: // Incoming jump from 0x0133, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0134 stack[-1] // @0135 stack[-2] // @0138 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @014F stack[-5] // @0155 memory[0x40:0x60] // @015A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0134 80 DUP1 0135 82 DUP3 0136 03 SUB 0137 80 DUP1 0138 51 MLOAD 0139 60 PUSH1 0x01 013B 83 DUP4 013C 60 PUSH1 0x20 013E 03 SUB 013F 61 PUSH2 0x0100 0142 0A EXP 0143 03 SUB 0144 19 NOT 0145 16 AND 0146 81 DUP2 0147 52 MSTORE 0148 60 PUSH1 0x20 014A 01 ADD 014B 91 SWAP2 014C 50 POP 014D 5B JUMPDEST 014E 50 POP 014F 92 SWAP3 0150 50 POP 0151 50 POP 0152 50 POP 0153 60 PUSH1 0x40 0155 51 MLOAD 0156 80 DUP1 0157 91 SWAP2 0158 03 SUB 0159 90 SWAP1 015A F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0147 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @015A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_015B: // Incoming jump from 0x0095, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0162 msg.data.length } 015B 5B JUMPDEST 015C 61 PUSH2 0x0187 015F 60 PUSH1 0x04 0161 80 DUP1 0162 36 CALLDATASIZE 0163 03 SUB 0164 60 PUSH1 0x40 0166 81 DUP2 0167 10 LT 0168 15 ISZERO 0169 61 PUSH2 0x0171 016C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @015C stack[0] = 0x0187 // @015F stack[1] = 0x04 // @0163 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0171, returns to 0x0187, if !(msg.data.length - 0x04 < 0x40) label_016D: // Incoming jump from 0x016C, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0170 memory[0x00:0x00] } 016D 60 PUSH1 0x00 016F 80 DUP1 0170 FD *REVERT // Stack delta = +0 // Outputs[1] { @0170 revert(memory[0x00:0x00]); } // Block terminates label_0171: // Incoming call from 0x016C, returns to 0x0187, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @017B stack[-2] // @017C msg.data[stack[-2]:stack[-2] + 0x20] // @0182 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0171 5B JUMPDEST 0172 50 POP 0173 60 PUSH1 0x01 0175 60 PUSH1 0x01 0177 60 PUSH1 0xa0 0179 1B SHL 017A 03 SUB 017B 81 DUP2 017C 35 CALLDATALOAD 017D 16 AND 017E 90 SWAP1 017F 60 PUSH1 0x20 0181 01 ADD 0182 35 CALLDATALOAD 0183 61 PUSH2 0x055f 0186 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @017E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0182 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x055f label_0187: // Incoming return from call to 0x027B at 0x0276 // Incoming return from call to 0x0171 at 0x016C // Incoming return from call to 0x01D8 at 0x01D3 // Incoming return from call to 0x034F at 0x034A // Incoming return from call to 0x07E8 at 0x02AF // Inputs[4] // { // @018B memory[0x40:0x60] // @018C stack[-1] // @0191 memory[0x40:0x60] // @019A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0187 5B JUMPDEST 0188 60 PUSH1 0x40 018A 80 DUP1 018B 51 MLOAD 018C 91 SWAP2 018D 15 ISZERO 018E 15 ISZERO 018F 82 DUP3 0190 52 MSTORE 0191 51 MLOAD 0192 90 SWAP1 0193 81 DUP2 0194 90 SWAP1 0195 03 SUB 0196 60 PUSH1 0x20 0198 01 ADD 0199 90 SWAP1 019A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0190 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @019A return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_019B: // Incoming jump from 0x00A0, if 0x18160ddd == stack[-1] // Inputs[1] { @019C msg.value } 019B 5B JUMPDEST 019C 34 CALLVALUE 019D 80 DUP1 019E 15 ISZERO 019F 61 PUSH2 0x01a7 01A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @019C stack[0] = msg.value } // Block ends with conditional jump to 0x01a7, if !msg.value label_01A3: // Incoming jump from 0x01A2, if not !msg.value // Inputs[1] { @01A6 memory[0x00:0x00] } 01A3 60 PUSH1 0x00 01A5 80 DUP1 01A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A6 revert(memory[0x00:0x00]); } // Block terminates label_01A7: // Incoming jump from 0x01A2, if !msg.value 01A7 5B JUMPDEST 01A8 50 POP 01A9 61 PUSH2 0x01b0 01AC 61 PUSH2 0x05c5 01AF 56 *JUMP // Stack delta = +0 // Outputs[1] { @01A9 stack[-1] = 0x01b0 } // Block ends with call to 0x05c5, returns to 0x01B0 label_01B0: // Incoming return from call to 0x07F1 at 0x02C4 // Incoming return from call to 0x02E8 at 0x02E3 // Incoming return from call to 0x05C5 at 0x01AF // Incoming return from call to 0x04B9 at 0x04B4 // Inputs[4] // { // @01B4 memory[0x40:0x60] // @01B5 stack[-1] // @01B8 memory[0x40:0x60] // @01C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 01B0 5B JUMPDEST 01B1 60 PUSH1 0x40 01B3 80 DUP1 01B4 51 MLOAD 01B5 91 SWAP2 01B6 82 DUP3 01B7 52 MSTORE 01B8 51 MLOAD 01B9 90 SWAP1 01BA 81 DUP2 01BB 90 SWAP1 01BC 03 SUB 01BD 60 PUSH1 0x20 01BF 01 ADD 01C0 90 SWAP1 01C1 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01C1 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_01C2: // Incoming jump from 0x00AB, if 0x1ba1ccab == stack[-1] // Inputs[1] { @01C9 msg.data.length } 01C2 5B JUMPDEST 01C3 61 PUSH2 0x0187 01C6 60 PUSH1 0x04 01C8 80 DUP1 01C9 36 CALLDATASIZE 01CA 03 SUB 01CB 60 PUSH1 0x20 01CD 81 DUP2 01CE 10 LT 01CF 15 ISZERO 01D0 61 PUSH2 0x01d8 01D3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01C3 stack[0] = 0x0187 // @01C6 stack[1] = 0x04 // @01CA stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01d8, returns to 0x0187, if !(msg.data.length - 0x04 < 0x20) label_01D4: // Incoming jump from 0x01D3, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @01D7 memory[0x00:0x00] } 01D4 60 PUSH1 0x00 01D6 80 DUP1 01D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D7 revert(memory[0x00:0x00]); } // Block terminates label_01D8: // Incoming call from 0x01D3, returns to 0x0187, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @01D9 stack[-2] // @01DA stack[-1] // @01E1 msg.data[stack[-2]:stack[-2] + 0x20] // } 01D8 5B JUMPDEST 01D9 81 DUP2 01DA 01 ADD 01DB 90 SWAP1 01DC 60 PUSH1 0x20 01DE 81 DUP2 01DF 01 ADD 01E0 81 DUP2 01E1 35 CALLDATALOAD 01E2 64 PUSH5 0x0100000000 01E8 81 DUP2 01E9 11 GT 01EA 15 ISZERO 01EB 61 PUSH2 0x01f3 01EE 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @01DB stack[-1] = stack[-2] // @01DB stack[-2] = stack[-2] + stack[-1] // @01DF stack[0] = stack[-2] + 0x20 // @01E1 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x01f3, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_01EF: // Incoming jump from 0x01EE, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @01F2 memory[0x00:0x00] } 01EF 60 PUSH1 0x00 01F1 80 DUP1 01F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F2 revert(memory[0x00:0x00]); } // Block terminates label_01F3: // Incoming jump from 0x01EE, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @01F4 stack[-3] // @01F5 stack[-1] // @01F6 stack[-4] // } 01F3 5B JUMPDEST 01F4 82 DUP3 01F5 01 ADD 01F6 83 DUP4 01F7 60 PUSH1 0x20 01F9 82 DUP3 01FA 01 ADD 01FB 11 GT 01FC 15 ISZERO 01FD 61 PUSH2 0x0205 0200 57 *JUMPI // Stack delta = +0 // Outputs[1] { @01F5 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0205, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0201: // Incoming jump from 0x0200, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0204 memory[0x00:0x00] } 0201 60 PUSH1 0x00 0203 80 DUP1 0204 FD *REVERT // Stack delta = +0 // Outputs[1] { @0204 revert(memory[0x00:0x00]); } // Block terminates label_0205: // Incoming jump from 0x0200, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0206 stack[-1] // @0207 msg.data[stack[-1]:stack[-1] + 0x20] // @020C stack[-2] // @020D stack[-4] // } 0205 5B JUMPDEST 0206 80 DUP1 0207 35 CALLDATALOAD 0208 90 SWAP1 0209 60 PUSH1 0x20 020B 01 ADD 020C 91 SWAP2 020D 84 DUP5 020E 60 PUSH1 0x20 0210 83 DUP4 0211 02 MUL 0212 84 DUP5 0213 01 ADD 0214 11 GT 0215 64 PUSH5 0x0100000000 021B 83 DUP4 021C 11 GT 021D 17 OR 021E 15 ISZERO 021F 61 PUSH2 0x0227 0222 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0208 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @020C stack[0] = stack[-2] // @020C stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0227, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_0223: // Incoming jump from 0x0222, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0226 memory[0x00:0x00] } 0223 60 PUSH1 0x00 0225 80 DUP1 0226 FD *REVERT // Stack delta = +0 // Outputs[1] { @0226 revert(memory[0x00:0x00]); } // Block terminates label_0227: // Incoming jump from 0x0222, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[7] // { // @0228 stack[-1] // @0228 stack[-3] // @0229 stack[-2] // @0234 memory[0x40:0x60] // @024E msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0259 stack[-5] // @025E stack[-4] // } 0227 5B JUMPDEST 0228 91 SWAP2 0229 90 SWAP1 022A 80 DUP1 022B 80 DUP1 022C 60 PUSH1 0x20 022E 02 MUL 022F 60 PUSH1 0x20 0231 01 ADD 0232 60 PUSH1 0x40 0234 51 MLOAD 0235 90 SWAP1 0236 81 DUP2 0237 01 ADD 0238 60 PUSH1 0x40 023A 52 MSTORE 023B 80 DUP1 023C 93 SWAP4 023D 92 SWAP3 023E 91 SWAP2 023F 90 SWAP1 0240 81 DUP2 0241 81 DUP2 0242 52 MSTORE 0243 60 PUSH1 0x20 0245 01 ADD 0246 83 DUP4 0247 83 DUP4 0248 60 PUSH1 0x20 024A 02 MUL 024B 80 DUP1 024C 82 DUP3 024D 84 DUP5 024E 37 CALLDATACOPY 024F 60 PUSH1 0x00 0251 92 SWAP3 0252 01 ADD 0253 91 SWAP2 0254 90 SWAP1 0255 91 SWAP2 0256 52 MSTORE 0257 50 POP 0258 92 SWAP3 0259 95 SWAP6 025A 50 POP 025B 61 PUSH2 0x05cb 025E 94 SWAP5 025F 50 POP 0260 50 POP 0261 50 POP 0262 50 POP 0263 50 POP 0264 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @023A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @0242 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @024E memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0256 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0259 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05cb label_0265: // Incoming jump from 0x00B6, if 0x23b872dd == stack[-1] // Inputs[1] { @026C msg.data.length } 0265 5B JUMPDEST 0266 61 PUSH2 0x0187 0269 60 PUSH1 0x04 026B 80 DUP1 026C 36 CALLDATASIZE 026D 03 SUB 026E 60 PUSH1 0x60 0270 81 DUP2 0271 10 LT 0272 15 ISZERO 0273 61 PUSH2 0x027b 0276 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0266 stack[0] = 0x0187 // @0269 stack[1] = 0x04 // @026D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x027b, returns to 0x0187, if !(msg.data.length - 0x04 < 0x60) label_0277: // Incoming jump from 0x0276, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @027A memory[0x00:0x00] } 0277 60 PUSH1 0x00 0279 80 DUP1 027A FD *REVERT // Stack delta = +0 // Outputs[1] { @027A revert(memory[0x00:0x00]); } // Block terminates label_027B: // Incoming call from 0x0276, returns to 0x0187, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0285 stack[-2] // @0286 msg.data[stack[-2]:stack[-2] + 0x20] // @028E msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0296 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 027B 5B JUMPDEST 027C 50 POP 027D 60 PUSH1 0x01 027F 60 PUSH1 0x01 0281 60 PUSH1 0xa0 0283 1B SHL 0284 03 SUB 0285 81 DUP2 0286 35 CALLDATALOAD 0287 81 DUP2 0288 16 AND 0289 91 SWAP2 028A 60 PUSH1 0x20 028C 81 DUP2 028D 01 ADD 028E 35 CALLDATALOAD 028F 90 SWAP1 0290 91 SWAP2 0291 16 AND 0292 90 SWAP1 0293 60 PUSH1 0x40 0295 01 ADD 0296 35 CALLDATALOAD 0297 61 PUSH2 0x0653 029A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0289 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0292 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0296 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0653 label_029B: // Incoming jump from 0x00C1, if 0x295b4e17 == stack[-1] // Inputs[1] { @029C msg.value } 029B 5B JUMPDEST 029C 34 CALLVALUE 029D 80 DUP1 029E 15 ISZERO 029F 61 PUSH2 0x02a7 02A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @029C stack[0] = msg.value } // Block ends with conditional jump to 0x02a7, if !msg.value label_02A3: // Incoming jump from 0x02A2, if not !msg.value // Inputs[1] { @02A6 memory[0x00:0x00] } 02A3 60 PUSH1 0x00 02A5 80 DUP1 02A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A6 revert(memory[0x00:0x00]); } // Block terminates label_02A7: // Incoming jump from 0x02A2, if !msg.value 02A7 5B JUMPDEST 02A8 50 POP 02A9 61 PUSH2 0x0187 02AC 61 PUSH2 0x07e8 02AF 56 *JUMP // Stack delta = +0 // Outputs[1] { @02A9 stack[-1] = 0x0187 } // Block ends with call to 0x07e8, returns to 0x0187 label_02B0: // Incoming jump from 0x0064, if 0x313ce567 == stack[-1] // Inputs[1] { @02B1 msg.value } 02B0 5B JUMPDEST 02B1 34 CALLVALUE 02B2 80 DUP1 02B3 15 ISZERO 02B4 61 PUSH2 0x02bc 02B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B1 stack[0] = msg.value } // Block ends with conditional jump to 0x02bc, if !msg.value label_02B8: // Incoming jump from 0x02B7, if not !msg.value // Inputs[1] { @02BB memory[0x00:0x00] } 02B8 60 PUSH1 0x00 02BA 80 DUP1 02BB FD *REVERT // Stack delta = +0 // Outputs[1] { @02BB revert(memory[0x00:0x00]); } // Block terminates label_02BC: // Incoming jump from 0x02B7, if !msg.value 02BC 5B JUMPDEST 02BD 50 POP 02BE 61 PUSH2 0x01b0 02C1 61 PUSH2 0x07f1 02C4 56 *JUMP // Stack delta = +0 // Outputs[1] { @02BE stack[-1] = 0x01b0 } // Block ends with call to 0x07f1, returns to 0x01B0 label_02C5: // Incoming jump from 0x006F, if 0x70a08231 == stack[-1] // Inputs[1] { @02C6 msg.value } 02C5 5B JUMPDEST 02C6 34 CALLVALUE 02C7 80 DUP1 02C8 15 ISZERO 02C9 61 PUSH2 0x02d1 02CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C6 stack[0] = msg.value } // Block ends with conditional jump to 0x02d1, if !msg.value label_02CD: // Incoming jump from 0x02CC, if not !msg.value // Inputs[1] { @02D0 memory[0x00:0x00] } 02CD 60 PUSH1 0x00 02CF 80 DUP1 02D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D0 revert(memory[0x00:0x00]); } // Block terminates label_02D1: // Incoming jump from 0x02CC, if !msg.value // Inputs[1] { @02D9 msg.data.length } 02D1 5B JUMPDEST 02D2 50 POP 02D3 61 PUSH2 0x01b0 02D6 60 PUSH1 0x04 02D8 80 DUP1 02D9 36 CALLDATASIZE 02DA 03 SUB 02DB 60 PUSH1 0x20 02DD 81 DUP2 02DE 10 LT 02DF 15 ISZERO 02E0 61 PUSH2 0x02e8 02E3 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @02D3 stack[-1] = 0x01b0 // @02D6 stack[0] = 0x04 // @02DA stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02e8, returns to 0x01B0, if !(msg.data.length - 0x04 < 0x20) label_02E4: // Incoming jump from 0x02E3, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @02E7 memory[0x00:0x00] } 02E4 60 PUSH1 0x00 02E6 80 DUP1 02E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E7 revert(memory[0x00:0x00]); } // Block terminates label_02E8: // Incoming call from 0x02E3, returns to 0x01B0, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @02EA msg.data[stack[-2]:stack[-2] + 0x20] // @02EA stack[-2] // } 02E8 5B JUMPDEST 02E9 50 POP 02EA 35 CALLDATALOAD 02EB 60 PUSH1 0x01 02ED 60 PUSH1 0x01 02EF 60 PUSH1 0xa0 02F1 1B SHL 02F2 03 SUB 02F3 16 AND 02F4 61 PUSH2 0x07f7 02F7 56 *JUMP // Stack delta = -1 // Outputs[1] { @02F3 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x07f7 label_02F8: // Incoming jump from 0x007A, if 0x95d89b41 == stack[-1] // Inputs[1] { @02F9 msg.value } 02F8 5B JUMPDEST 02F9 34 CALLVALUE 02FA 80 DUP1 02FB 15 ISZERO 02FC 61 PUSH2 0x0304 02FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0304, if !msg.value label_0300: // Incoming jump from 0x02FF, if not !msg.value // Inputs[1] { @0303 memory[0x00:0x00] } 0300 60 PUSH1 0x00 0302 80 DUP1 0303 FD *REVERT // Stack delta = +0 // Outputs[1] { @0303 revert(memory[0x00:0x00]); } // Block terminates label_0304: // Incoming jump from 0x02FF, if !msg.value 0304 5B JUMPDEST 0305 50 POP 0306 61 PUSH2 0x00e6 0309 61 PUSH2 0x0809 030C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0306 stack[-1] = 0x00e6 } // Block ends with call to 0x0809, returns to 0x00E6 label_030D: // Incoming jump from 0x0033, if 0xa9059cbb == stack[-1] // Inputs[1] { @0314 msg.data.length } 030D 5B JUMPDEST 030E 61 PUSH2 0x0187 0311 60 PUSH1 0x04 0313 80 DUP1 0314 36 CALLDATASIZE 0315 03 SUB 0316 60 PUSH1 0x40 0318 81 DUP2 0319 10 LT 031A 15 ISZERO 031B 61 PUSH2 0x0323 031E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @030E stack[0] = 0x0187 // @0311 stack[1] = 0x04 // @0315 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0323, if !(msg.data.length - 0x04 < 0x40) label_031F: // Incoming jump from 0x031E, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0322 memory[0x00:0x00] } 031F 60 PUSH1 0x00 0321 80 DUP1 0322 FD *REVERT // Stack delta = +0 // Outputs[1] { @0322 revert(memory[0x00:0x00]); } // Block terminates label_0323: // Incoming jump from 0x031E, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @032D stack[-2] // @032E msg.data[stack[-2]:stack[-2] + 0x20] // @0334 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0323 5B JUMPDEST 0324 50 POP 0325 60 PUSH1 0x01 0327 60 PUSH1 0x01 0329 60 PUSH1 0xa0 032B 1B SHL 032C 03 SUB 032D 81 DUP2 032E 35 CALLDATALOAD 032F 16 AND 0330 90 SWAP1 0331 60 PUSH1 0x20 0333 01 ADD 0334 35 CALLDATALOAD 0335 61 PUSH2 0x0864 0338 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0330 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0334 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0864 label_0339: // Incoming jump from 0x003E, if 0xaa2f5220 == stack[-1] // Inputs[1] { @0340 msg.data.length } 0339 5B JUMPDEST 033A 61 PUSH2 0x0187 033D 60 PUSH1 0x04 033F 80 DUP1 0340 36 CALLDATASIZE 0341 03 SUB 0342 60 PUSH1 0x40 0344 81 DUP2 0345 10 LT 0346 15 ISZERO 0347 61 PUSH2 0x034f 034A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @033A stack[0] = 0x0187 // @033D stack[1] = 0x04 // @0341 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x034f, returns to 0x0187, if !(msg.data.length - 0x04 < 0x40) label_034B: // Incoming jump from 0x034A, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @034E memory[0x00:0x00] } 034B 60 PUSH1 0x00 034D 80 DUP1 034E FD *REVERT // Stack delta = +0 // Outputs[1] { @034E revert(memory[0x00:0x00]); } // Block terminates label_034F: // Incoming call from 0x034A, returns to 0x0187, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0350 stack[-2] // @0351 stack[-1] // @0358 msg.data[stack[-2]:stack[-2] + 0x20] // } 034F 5B JUMPDEST 0350 81 DUP2 0351 01 ADD 0352 90 SWAP1 0353 60 PUSH1 0x20 0355 81 DUP2 0356 01 ADD 0357 81 DUP2 0358 35 CALLDATALOAD 0359 64 PUSH5 0x0100000000 035F 81 DUP2 0360 11 GT 0361 15 ISZERO 0362 61 PUSH2 0x036a 0365 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0352 stack[-1] = stack[-2] // @0352 stack[-2] = stack[-2] + stack[-1] // @0356 stack[0] = stack[-2] + 0x20 // @0358 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x036a, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0366: // Incoming jump from 0x0365, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0369 memory[0x00:0x00] } 0366 60 PUSH1 0x00 0368 80 DUP1 0369 FD *REVERT // Stack delta = +0 // Outputs[1] { @0369 revert(memory[0x00:0x00]); } // Block terminates label_036A: // Incoming jump from 0x0365, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @036B stack[-3] // @036C stack[-1] // @036D stack[-4] // } 036A 5B JUMPDEST 036B 82 DUP3 036C 01 ADD 036D 83 DUP4 036E 60 PUSH1 0x20 0370 82 DUP3 0371 01 ADD 0372 11 GT 0373 15 ISZERO 0374 61 PUSH2 0x037c 0377 57 *JUMPI // Stack delta = +0 // Outputs[1] { @036C stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x037c, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0378: // Incoming jump from 0x0377, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @037B memory[0x00:0x00] } 0378 60 PUSH1 0x00 037A 80 DUP1 037B FD *REVERT // Stack delta = +0 // Outputs[1] { @037B revert(memory[0x00:0x00]); } // Block terminates label_037C: // Incoming jump from 0x0377, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @037D stack[-1] // @037E msg.data[stack[-1]:stack[-1] + 0x20] // @0383 stack[-2] // @0384 stack[-4] // } 037C 5B JUMPDEST 037D 80 DUP1 037E 35 CALLDATALOAD 037F 90 SWAP1 0380 60 PUSH1 0x20 0382 01 ADD 0383 91 SWAP2 0384 84 DUP5 0385 60 PUSH1 0x20 0387 83 DUP4 0388 02 MUL 0389 84 DUP5 038A 01 ADD 038B 11 GT 038C 64 PUSH5 0x0100000000 0392 83 DUP4 0393 11 GT 0394 17 OR 0395 15 ISZERO 0396 61 PUSH2 0x039e 0399 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @037F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0383 stack[0] = stack[-2] // @0383 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x039e, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_039A: // Incoming jump from 0x0399, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @039D memory[0x00:0x00] } 039A 60 PUSH1 0x00 039C 80 DUP1 039D FD *REVERT // Stack delta = +0 // Outputs[1] { @039D revert(memory[0x00:0x00]); } // Block terminates label_039E: // Incoming jump from 0x0399, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @039F stack[-1] // @039F stack[-3] // @03A0 stack[-2] // @03AB memory[0x40:0x60] // @03C5 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @03D0 stack[-5] // @03D4 msg.data[stack[-1]:stack[-1] + 0x20] // @03D5 stack[-4] // } 039E 5B JUMPDEST 039F 91 SWAP2 03A0 90 SWAP1 03A1 80 DUP1 03A2 80 DUP1 03A3 60 PUSH1 0x20 03A5 02 MUL 03A6 60 PUSH1 0x20 03A8 01 ADD 03A9 60 PUSH1 0x40 03AB 51 MLOAD 03AC 90 SWAP1 03AD 81 DUP2 03AE 01 ADD 03AF 60 PUSH1 0x40 03B1 52 MSTORE 03B2 80 DUP1 03B3 93 SWAP4 03B4 92 SWAP3 03B5 91 SWAP2 03B6 90 SWAP1 03B7 81 DUP2 03B8 81 DUP2 03B9 52 MSTORE 03BA 60 PUSH1 0x20 03BC 01 ADD 03BD 83 DUP4 03BE 83 DUP4 03BF 60 PUSH1 0x20 03C1 02 MUL 03C2 80 DUP1 03C3 82 DUP3 03C4 84 DUP5 03C5 37 CALLDATACOPY 03C6 60 PUSH1 0x00 03C8 92 SWAP3 03C9 01 ADD 03CA 91 SWAP2 03CB 90 SWAP1 03CC 91 SWAP2 03CD 52 MSTORE 03CE 50 POP 03CF 92 SWAP3 03D0 95 SWAP6 03D1 50 POP 03D2 50 POP 03D3 91 SWAP2 03D4 35 CALLDATALOAD 03D5 92 SWAP3 03D6 50 POP 03D7 61 PUSH2 0x0871 03DA 91 SWAP2 03DB 50 POP 03DC 50 POP 03DD 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @03B1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @03B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @03C5 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @03CD memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @03D0 stack[-5] = memory[0x40:0x60] // @03D5 stack[-4] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x0871 label_03DE: // Incoming jump from 0x0049, if 0xd6d2b6ba == stack[-1] // Inputs[1] { @03E5 msg.data.length } 03DE 5B JUMPDEST 03DF 61 PUSH2 0x0494 03E2 60 PUSH1 0x04 03E4 80 DUP1 03E5 36 CALLDATASIZE 03E6 03 SUB 03E7 60 PUSH1 0x40 03E9 81 DUP2 03EA 10 LT 03EB 15 ISZERO 03EC 61 PUSH2 0x03f4 03EF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03DF stack[0] = 0x0494 // @03E2 stack[1] = 0x04 // @03E6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03f4, returns to 0x0494, if !(msg.data.length - 0x04 < 0x40) label_03F0: // Incoming jump from 0x03EF, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03F3 memory[0x00:0x00] } 03F0 60 PUSH1 0x00 03F2 80 DUP1 03F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F3 revert(memory[0x00:0x00]); } // Block terminates label_03F4: // Incoming call from 0x03EF, returns to 0x0494, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @03FD stack[-2] // @03FE msg.data[stack[-2]:stack[-2] + 0x20] // @0401 stack[-1] // @040D msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 03F4 5B JUMPDEST 03F5 60 PUSH1 0x01 03F7 60 PUSH1 0x01 03F9 60 PUSH1 0xa0 03FB 1B SHL 03FC 03 SUB 03FD 82 DUP3 03FE 35 CALLDATALOAD 03FF 16 AND 0400 91 SWAP2 0401 90 SWAP1 0402 81 DUP2 0403 01 ADD 0404 90 SWAP1 0405 60 PUSH1 0x40 0407 81 DUP2 0408 01 ADD 0409 60 PUSH1 0x20 040B 82 DUP3 040C 01 ADD 040D 35 CALLDATALOAD 040E 64 PUSH5 0x0100000000 0414 81 DUP2 0415 11 GT 0416 15 ISZERO 0417 61 PUSH2 0x041f 041A 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0400 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0404 stack[0] = stack[-2] // @0404 stack[-1] = stack[-2] + stack[-1] // @0408 stack[1] = stack[-2] + 0x40 // @040D stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x041f, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) label_041B: // Incoming jump from 0x041A, if not !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[1] { @041E memory[0x00:0x00] } 041B 60 PUSH1 0x00 041D 80 DUP1 041E FD *REVERT // Stack delta = +0 // Outputs[1] { @041E revert(memory[0x00:0x00]); } // Block terminates label_041F: // Incoming jump from 0x041A, if !(msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] > 0x0100000000) // Inputs[3] // { // @0420 stack[-3] // @0421 stack[-1] // @0422 stack[-4] // } 041F 5B JUMPDEST 0420 82 DUP3 0421 01 ADD 0422 83 DUP4 0423 60 PUSH1 0x20 0425 82 DUP3 0426 01 ADD 0427 11 GT 0428 15 ISZERO 0429 61 PUSH2 0x0431 042C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0421 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0431, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_042D: // Incoming jump from 0x042C, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0430 memory[0x00:0x00] } 042D 60 PUSH1 0x00 042F 80 DUP1 0430 FD *REVERT // Stack delta = +0 // Outputs[1] { @0430 revert(memory[0x00:0x00]); } // Block terminates label_0431: // Incoming jump from 0x042C, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0432 stack[-1] // @0433 msg.data[stack[-1]:stack[-1] + 0x20] // @0438 stack[-2] // @0439 stack[-4] // } 0431 5B JUMPDEST 0432 80 DUP1 0433 35 CALLDATALOAD 0434 90 SWAP1 0435 60 PUSH1 0x20 0437 01 ADD 0438 91 SWAP2 0439 84 DUP5 043A 60 PUSH1 0x01 043C 83 DUP4 043D 02 MUL 043E 84 DUP5 043F 01 ADD 0440 11 GT 0441 64 PUSH5 0x0100000000 0447 83 DUP4 0448 11 GT 0449 17 OR 044A 15 ISZERO 044B 61 PUSH2 0x0453 044E 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0434 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0438 stack[0] = stack[-2] // @0438 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0453, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_044F: // Incoming jump from 0x044E, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0452 memory[0x00:0x00] } 044F 60 PUSH1 0x00 0451 80 DUP1 0452 FD *REVERT // Stack delta = +0 // Outputs[1] { @0452 revert(memory[0x00:0x00]); } // Block terminates label_0453: // Incoming jump from 0x044E, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0454 stack[-3] // @0454 stack[-1] // @0455 stack[-2] // @0466 memory[0x40:0x60] // @047D msg.data[stack[-3]:stack[-3] + stack[-2]] // @0488 stack[-5] // @048D stack[-4] // } 0453 5B JUMPDEST 0454 91 SWAP2 0455 90 SWAP1 0456 80 DUP1 0457 80 DUP1 0458 60 PUSH1 0x1f 045A 01 ADD 045B 60 PUSH1 0x20 045D 80 DUP1 045E 91 SWAP2 045F 04 DIV 0460 02 MUL 0461 60 PUSH1 0x20 0463 01 ADD 0464 60 PUSH1 0x40 0466 51 MLOAD 0467 90 SWAP1 0468 81 DUP2 0469 01 ADD 046A 60 PUSH1 0x40 046C 52 MSTORE 046D 80 DUP1 046E 93 SWAP4 046F 92 SWAP3 0470 91 SWAP2 0471 90 SWAP1 0472 81 DUP2 0473 81 DUP2 0474 52 MSTORE 0475 60 PUSH1 0x20 0477 01 ADD 0478 83 DUP4 0479 83 DUP4 047A 80 DUP1 047B 82 DUP3 047C 84 DUP5 047D 37 CALLDATACOPY 047E 60 PUSH1 0x00 0480 92 SWAP3 0481 01 ADD 0482 91 SWAP2 0483 90 SWAP1 0484 91 SWAP2 0485 52 MSTORE 0486 50 POP 0487 92 SWAP3 0488 95 SWAP6 0489 50 POP 048A 61 PUSH2 0x0961 048D 94 SWAP5 048E 50 POP 048F 50 POP 0490 50 POP 0491 50 POP 0492 50 POP 0493 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @046C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0474 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @047D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0485 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0488 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0961 label_0494: // Incoming return from call to 0x03F4 at 0x03EF 0494 5B JUMPDEST 0495 00 *STOP // Stack delta = +0 // Outputs[1] { @0495 stop(); } // Block terminates label_0496: // Incoming jump from 0x0054, if 0xdd62ed3e == stack[-1] // Inputs[1] { @0497 msg.value } 0496 5B JUMPDEST 0497 34 CALLVALUE 0498 80 DUP1 0499 15 ISZERO 049A 61 PUSH2 0x04a2 049D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0497 stack[0] = msg.value } // Block ends with conditional jump to 0x04a2, if !msg.value label_049E: // Incoming jump from 0x049D, if not !msg.value // Inputs[1] { @04A1 memory[0x00:0x00] } 049E 60 PUSH1 0x00 04A0 80 DUP1 04A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A1 revert(memory[0x00:0x00]); } // Block terminates label_04A2: // Incoming jump from 0x049D, if !msg.value // Inputs[1] { @04AA msg.data.length } 04A2 5B JUMPDEST 04A3 50 POP 04A4 61 PUSH2 0x01b0 04A7 60 PUSH1 0x04 04A9 80 DUP1 04AA 36 CALLDATASIZE 04AB 03 SUB 04AC 60 PUSH1 0x40 04AE 81 DUP2 04AF 10 LT 04B0 15 ISZERO 04B1 61 PUSH2 0x04b9 04B4 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04A4 stack[-1] = 0x01b0 // @04A7 stack[0] = 0x04 // @04AB stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04b9, returns to 0x01B0, if !(msg.data.length - 0x04 < 0x40) label_04B5: // Incoming jump from 0x04B4, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @04B8 memory[0x00:0x00] } 04B5 60 PUSH1 0x00 04B7 80 DUP1 04B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B8 revert(memory[0x00:0x00]); } // Block terminates label_04B9: // Incoming call from 0x04B4, returns to 0x01B0, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @04C3 stack[-2] // @04C4 msg.data[stack[-2]:stack[-2] + 0x20] // @04CB msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 04B9 5B JUMPDEST 04BA 50 POP 04BB 60 PUSH1 0x01 04BD 60 PUSH1 0x01 04BF 60 PUSH1 0xa0 04C1 1B SHL 04C2 03 SUB 04C3 81 DUP2 04C4 35 CALLDATALOAD 04C5 81 DUP2 04C6 16 AND 04C7 91 SWAP2 04C8 60 PUSH1 0x20 04CA 01 ADD 04CB 35 CALLDATALOAD 04CC 16 AND 04CD 61 PUSH2 0x0a23 04D0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @04C7 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @04CC stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x0a23 label_04D1: // Incoming call from 0x00E5, returns to 0x00E6 // Inputs[2] // { // @04D5 storage[0x06] // @04D9 memory[0x40:0x60] // } 04D1 5B JUMPDEST 04D2 60 PUSH1 0x06 04D4 80 DUP1 04D5 54 SLOAD 04D6 60 PUSH1 0x40 04D8 80 DUP1 04D9 51 MLOAD 04DA 60 PUSH1 0x20 04DC 60 PUSH1 0x02 04DE 60 PUSH1 0x01 04E0 85 DUP6 04E1 16 AND 04E2 15 ISZERO 04E3 61 PUSH2 0x0100 04E6 02 MUL 04E7 60 PUSH1 0x00 04E9 19 NOT 04EA 01 ADD 04EB 90 SWAP1 04EC 94 SWAP5 04ED 16 AND 04EE 93 SWAP4 04EF 90 SWAP1 04F0 93 SWAP4 04F1 04 DIV 04F2 60 PUSH1 0x1f 04F4 81 DUP2 04F5 01 ADD 04F6 84 DUP5 04F7 90 SWAP1 04F8 04 DIV 04F9 84 DUP5 04FA 02 MUL 04FB 82 DUP3 04FC 01 ADD 04FD 84 DUP5 04FE 01 ADD 04FF 90 SWAP1 0500 92 SWAP3 0501 52 MSTORE 0502 81 DUP2 0503 81 DUP2 0504 52 MSTORE 0505 92 SWAP3 0506 91 SWAP2 0507 83 DUP4 0508 01 ADD 0509 82 DUP3 050A 82 DUP3 050B 80 DUP1 050C 15 ISZERO 050D 61 PUSH2 0x0557 0510 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0500 stack[2] = (storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02 // @0501 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02 + 0x1f) / 0x20) // @0504 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02 // @0505 stack[0] = memory[0x40:0x60] // @0506 stack[1] = 0x06 // @0508 stack[3] = memory[0x40:0x60] + 0x20 // @0509 stack[4] = 0x06 // @050A stack[5] = (storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x0557, if !((storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02) label_0511: // Incoming jump from 0x0510, if not !((storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02) // Inputs[1] { @0511 stack[-1] } 0511 80 DUP1 0512 60 PUSH1 0x1f 0514 10 LT 0515 61 PUSH2 0x052c 0518 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052c, if 0x1f < stack[-1] label_0519: // Incoming jump from 0x0518, if not 0x1f < stack[-1] // Inputs[4] // { // @051D stack[-2] // @051E storage[stack[-2]] // @0521 stack[-3] // @0523 stack[-1] // } 0519 61 PUSH2 0x0100 051C 80 DUP1 051D 83 DUP4 051E 54 SLOAD 051F 04 DIV 0520 02 MUL 0521 83 DUP4 0522 52 MSTORE 0523 91 SWAP2 0524 60 PUSH1 0x20 0526 01 ADD 0527 91 SWAP2 0528 61 PUSH2 0x0557 052B 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0522 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0527 stack[-1] = stack[-1] // @0527 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0557 label_052C: // Incoming jump from 0x0518, if 0x1f < stack[-1] // Incoming jump from 0x0850, if 0x1f < stack[-1] // Inputs[5] // { // @052D stack[-3] // @052E stack[-1] // @0530 stack[-2] // @0538 memory[0x00:0x20] // @053C storage[keccak256(memory[0x00:0x20])] // } 052C 5B JUMPDEST 052D 82 DUP3 052E 01 ADD 052F 91 SWAP2 0530 90 SWAP1 0531 60 PUSH1 0x00 0533 52 MSTORE 0534 60 PUSH1 0x20 0536 60 PUSH1 0x00 0538 20 SHA3 0539 90 SWAP1 053A 5B JUMPDEST 053B 81 DUP2 053C 54 SLOAD 053D 81 DUP2 053E 52 MSTORE 053F 90 SWAP1 0540 60 PUSH1 0x01 0542 01 ADD 0543 90 SWAP1 0544 60 PUSH1 0x20 0546 01 ADD 0547 80 DUP1 0548 83 DUP4 0549 11 GT 054A 61 PUSH2 0x053a 054D 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @052F stack[-3] = stack[-3] + stack[-1] // @0533 memory[0x00:0x20] = stack[-2] // @053E memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0543 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0546 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x053a, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_054E: // Incoming jump from 0x054D, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x054D, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @054E stack[-3] // @054F stack[-1] // } 054E 82 DUP3 054F 90 SWAP1 0550 03 SUB 0551 60 PUSH1 0x1f 0553 16 AND 0554 82 DUP3 0555 01 ADD 0556 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0556 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0556 stack[-1] = stack[-3] // } // Block continues label_0557: // Incoming jump from 0x0510, if !((storage[0x06] & ~0x00 + 0x0100 * !(storage[0x06] & 0x01)) / 0x02) // Incoming jump from 0x0863 // Incoming jump from 0x0848, if !((storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02) // Incoming jump from 0x0556 // Incoming jump from 0x052B // Inputs[1] { @055D stack[-7] } 0557 5B JUMPDEST 0558 50 POP 0559 50 POP 055A 50 POP 055B 50 POP 055C 50 POP 055D 81 DUP2 055E 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_055F: // Incoming jump from 0x0186 // Inputs[9] // { // @0560 msg.sender // @0571 memory[0x00:0x40] // @057A stack[-2] // @0584 memory[0x00:0x40] // @0585 stack[-1] // @0589 memory[0x40:0x60] // @058E memory[0x40:0x60] // @05BC memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20] // @05C0 stack[-3] // } 055F 5B JUMPDEST 0560 33 CALLER 0561 60 PUSH1 0x00 0563 81 DUP2 0564 81 DUP2 0565 52 MSTORE 0566 60 PUSH1 0x03 0568 60 PUSH1 0x20 056A 90 SWAP1 056B 81 DUP2 056C 52 MSTORE 056D 60 PUSH1 0x40 056F 80 DUP1 0570 83 DUP4 0571 20 SHA3 0572 60 PUSH1 0x01 0574 60 PUSH1 0x01 0576 60 PUSH1 0xa0 0578 1B SHL 0579 03 SUB 057A 87 DUP8 057B 16 AND 057C 80 DUP1 057D 85 DUP6 057E 52 MSTORE 057F 90 SWAP1 0580 83 DUP4 0581 52 MSTORE 0582 81 DUP2 0583 84 DUP5 0584 20 SHA3 0585 86 DUP7 0586 90 SWAP1 0587 55 SSTORE 0588 81 DUP2 0589 51 MLOAD 058A 86 DUP7 058B 81 DUP2 058C 52 MSTORE 058D 91 SWAP2 058E 51 MLOAD 058F 93 SWAP4 0590 94 SWAP5 0591 90 SWAP1 0592 93 SWAP4 0593 90 SWAP1 0594 92 SWAP3 0595 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 05B6 92 SWAP3 05B7 82 DUP3 05B8 90 SWAP1 05B9 03 SUB 05BA 01 ADD 05BB 90 SWAP1 05BC A3 LOG3 05BD 50 POP 05BE 60 PUSH1 0x01 05C0 92 SWAP3 05C1 91 SWAP2 05C2 50 POP 05C3 50 POP 05C4 56 *JUMP // Stack delta = -2 // Outputs[8] // { // @0565 memory[0x00:0x20] = msg.sender // @056C memory[0x20:0x40] = 0x03 // @057E memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0581 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0587 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @058C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05BC log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60] + 0x20], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // @05C0 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_05C5: // Incoming call from 0x01AF, returns to 0x01B0 // Inputs[2] // { // @05C8 storage[0x05] // @05C9 stack[-1] // } 05C5 5B JUMPDEST 05C6 60 PUSH1 0x05 05C8 54 SLOAD 05C9 81 DUP2 05CA 56 *JUMP // Stack delta = +1 // Outputs[1] { @05C8 stack[0] = storage[0x05] } // Block ends with unconditional jump to stack[-1] label_05CB: // Incoming jump from 0x0264 // Inputs[2] // { // @05CE storage[0x08] // @05E0 msg.sender // } 05CB 5B JUMPDEST 05CC 60 PUSH1 0x08 05CE 54 SLOAD 05CF 60 PUSH1 0x00 05D1 90 SWAP1 05D2 61 PUSH2 0x0100 05D5 90 SWAP1 05D6 04 DIV 05D7 60 PUSH1 0x01 05D9 60 PUSH1 0x01 05DB 60 PUSH1 0xa0 05DD 1B SHL 05DE 03 SUB 05DF 16 AND 05E0 33 CALLER 05E1 14 EQ 05E2 61 PUSH2 0x05ea 05E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D1 stack[0] = 0x00 } // Block ends with conditional jump to 0x05ea, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 label_05E6: // Incoming jump from 0x05E5, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 // Inputs[1] { @05E9 memory[0x00:0x00] } 05E6 60 PUSH1 0x00 05E8 80 DUP1 05E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E9 revert(memory[0x00:0x00]); } // Block terminates label_05EA: // Incoming jump from 0x05E5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 // Inputs[2] // { // @05EE stack[-2] // @05EF memory[stack[-2]:stack[-2] + 0x20] // } 05EA 5B JUMPDEST 05EB 60 PUSH1 0x00 05ED 5B JUMPDEST 05EE 82 DUP3 05EF 51 MLOAD 05F0 81 DUP2 05F1 10 LT 05F2 15 ISZERO 05F3 61 PUSH2 0x064d 05F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05EB stack[0] = 0x00 } // Block ends with conditional jump to 0x064d, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_05F7: // Incoming jump from 0x05F6, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x05F6, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @05FA storage[0x08] // @0604 stack[-3] // @0605 memory[stack[-3]:stack[-3] + 0x20] // @060B stack[-1] // } 05F7 60 PUSH1 0x08 05F9 80 DUP1 05FA 54 SLOAD 05FB 60 PUSH1 0xff 05FD 19 NOT 05FE 16 AND 05FF 60 PUSH1 0x01 0601 17 OR 0602 90 SWAP1 0603 55 SSTORE 0604 82 DUP3 0605 51 MLOAD 0606 60 PUSH1 0x00 0608 90 SWAP1 0609 84 DUP5 060A 90 SWAP1 060B 83 DUP4 060C 90 SWAP1 060D 81 DUP2 060E 10 LT 060F 61 PUSH2 0x0614 0612 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @0603 storage[0x08] = 0x01 | (~0xff & storage[0x08]) // @0608 stack[0] = 0x00 // @060A stack[1] = stack[-3] // @060C stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0614, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_0613: // Incoming jump from 0x0612, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 0613 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0613 assert(); } // Block terminates label_0614: // Incoming jump from 0x0612, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[7] // { // @0617 stack[-1] // @061A stack[-2] // @0620 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0638 memory[0x00:0x40] // @063A storage[keccak256(memory[0x00:0x40])] // @0643 stack[-4] // @0644 stack[-3] // } 0614 5B JUMPDEST 0615 60 PUSH1 0x20 0617 90 SWAP1 0618 81 DUP2 0619 02 MUL 061A 91 SWAP2 061B 90 SWAP1 061C 91 SWAP2 061D 01 ADD 061E 81 DUP2 061F 01 ADD 0620 51 MLOAD 0621 60 PUSH1 0x01 0623 60 PUSH1 0x01 0625 60 PUSH1 0xa0 0627 1B SHL 0628 03 SUB 0629 16 AND 062A 60 PUSH1 0x00 062C 90 SWAP1 062D 81 DUP2 062E 52 MSTORE 062F 60 PUSH1 0x01 0631 91 SWAP2 0632 82 DUP3 0633 90 SWAP1 0634 52 MSTORE 0635 60 PUSH1 0x40 0637 90 SWAP1 0638 20 SHA3 0639 80 DUP1 063A 54 SLOAD 063B 60 PUSH1 0xff 063D 19 NOT 063E 16 AND 063F 82 DUP3 0640 17 OR 0641 90 SWAP1 0642 55 SSTORE 0643 91 SWAP2 0644 90 SWAP1 0645 91 SWAP2 0646 01 ADD 0647 90 SWAP1 0648 50 POP 0649 61 PUSH2 0x05ed 064C 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @062E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0634 memory[0x20:0x40] = 0x01 // @0642 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0647 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x05ed label_064D: // Incoming jump from 0x05F6, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x05F6, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @064F stack[-4] // @064F stack[-2] // @0650 stack[-3] // } 064D 5B JUMPDEST 064E 50 POP 064F 91 SWAP2 0650 90 SWAP1 0651 50 POP 0652 56 *JUMP // Stack delta = -3 // Outputs[1] { @064F stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_0653: // Incoming jump from 0x029A // Incoming call from 0x0870, returns to 0x07E1 // Inputs[1] { @0656 stack[-1] } 0653 5B JUMPDEST 0654 60 PUSH1 0x00 0656 81 DUP2 0657 61 PUSH2 0x0662 065A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0654 stack[0] = 0x00 } // Block ends with conditional jump to 0x0662, if stack[-1] label_065B: // Incoming jump from 0x065A, if not stack[-1] 065B 50 POP 065C 60 PUSH1 0x01 065E 61 PUSH2 0x07e1 0661 56 *JUMP // Stack delta = +0 // Outputs[1] { @065C stack[-1] = 0x01 } // Block ends with unconditional jump to 0x07e1 label_0662: // Incoming jump from 0x065A, if stack[-1] // Inputs[2] // { // @0663 msg.sender // @066C stack[-4] // } 0662 5B JUMPDEST 0663 33 CALLER 0664 60 PUSH1 0x01 0666 60 PUSH1 0x01 0668 60 PUSH1 0xa0 066A 1B SHL 066B 03 SUB 066C 85 DUP6 066D 16 AND 066E 14 EQ 066F 80 DUP1 0670 15 ISZERO 0671 90 SWAP1 0672 61 PUSH2 0x0688 0675 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0671 stack[0] = !(stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x0688, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_0676: // Incoming jump from 0x0675, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[3] // { // @0677 tx.origin // @0685 memory[0x00:0x40] // @0686 storage[keccak256(memory[0x00:0x40])] // } 0676 50 POP 0677 32 ORIGIN 0678 60 PUSH1 0x00 067A 90 SWAP1 067B 81 DUP2 067C 52 MSTORE 067D 60 PUSH1 0x20 067F 81 DUP2 0680 90 SWAP1 0681 52 MSTORE 0682 60 PUSH1 0x40 0684 90 SWAP1 0685 20 SHA3 0686 54 SLOAD 0687 15 ISZERO 0688 5B JUMPDEST 0689 15 ISZERO 068A 61 PUSH2 0x06e8 068D 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @067C memory[0x00:0x20] = tx.origin // @0681 memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x06e8, if !!storage[keccak256(memory[0x00:0x40])] label_068E: // Incoming jump from 0x068D, if not !!storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x068D, if not !stack[-1] // Inputs[6] // { // @0696 stack[-4] // @06A8 memory[0x00:0x40] // @06A9 msg.sender // @06B0 memory[0x00:0x40] // @06B1 storage[keccak256(memory[0x00:0x40])] // @06B2 stack[-2] // } 068E 60 PUSH1 0x01 0690 60 PUSH1 0x01 0692 60 PUSH1 0xa0 0694 1B SHL 0695 03 SUB 0696 84 DUP5 0697 16 AND 0698 60 PUSH1 0x00 069A 90 SWAP1 069B 81 DUP2 069C 52 MSTORE 069D 60 PUSH1 0x03 069F 60 PUSH1 0x20 06A1 90 SWAP1 06A2 81 DUP2 06A3 52 MSTORE 06A4 60 PUSH1 0x40 06A6 80 DUP1 06A7 83 DUP4 06A8 20 SHA3 06A9 33 CALLER 06AA 84 DUP5 06AB 52 MSTORE 06AC 90 SWAP1 06AD 91 SWAP2 06AE 52 MSTORE 06AF 90 SWAP1 06B0 20 SHA3 06B1 54 SLOAD 06B2 82 DUP3 06B3 11 GT 06B4 15 ISZERO 06B5 61 PUSH2 0x06bd 06B8 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @069C memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @06A3 memory[0x20:0x40] = 0x03 // @06AB memory[0x00:0x20] = msg.sender // @06AE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x06bd, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])]) label_06B9: // Incoming jump from 0x06B8, if not !(stack[-2] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @06BC memory[0x00:0x00] } 06B9 60 PUSH1 0x00 06BB 80 DUP1 06BC FD *REVERT // Stack delta = +0 // Outputs[1] { @06BC revert(memory[0x00:0x00]); } // Block terminates label_06BD: // Incoming jump from 0x06B8, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])]) // Inputs[6] // { // @06C6 stack[-4] // @06D8 memory[0x00:0x40] // @06D9 msg.sender // @06E0 memory[0x00:0x40] // @06E2 storage[keccak256(memory[0x00:0x40])] // @06E3 stack[-2] // } 06BD 5B JUMPDEST 06BE 60 PUSH1 0x01 06C0 60 PUSH1 0x01 06C2 60 PUSH1 0xa0 06C4 1B SHL 06C5 03 SUB 06C6 84 DUP5 06C7 16 AND 06C8 60 PUSH1 0x00 06CA 90 SWAP1 06CB 81 DUP2 06CC 52 MSTORE 06CD 60 PUSH1 0x03 06CF 60 PUSH1 0x20 06D1 90 SWAP1 06D2 81 DUP2 06D3 52 MSTORE 06D4 60 PUSH1 0x40 06D6 80 DUP1 06D7 83 DUP4 06D8 20 SHA3 06D9 33 CALLER 06DA 84 DUP5 06DB 52 MSTORE 06DC 90 SWAP1 06DD 91 SWAP2 06DE 52 MSTORE 06DF 90 SWAP1 06E0 20 SHA3 06E1 80 DUP1 06E2 54 SLOAD 06E3 83 DUP4 06E4 90 SWAP1 06E5 03 SUB 06E6 90 SWAP1 06E7 55 SSTORE // Stack delta = +0 // Outputs[5] // { // @06CC memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @06D3 memory[0x20:0x40] = 0x03 // @06DB memory[0x00:0x20] = msg.sender // @06DE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @06E7 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-2] // } // Block continues label_06E8: // Incoming jump from 0x068D, if !stack[-1] // Incoming jump from 0x06E7 // Incoming jump from 0x068D, if !!storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @06F1 stack[-4] // @0700 memory[0x00:0x40] // @0701 storage[keccak256(memory[0x00:0x40])] // @0702 stack[-2] // } 06E8 5B JUMPDEST 06E9 60 PUSH1 0x01 06EB 60 PUSH1 0x01 06ED 60 PUSH1 0xa0 06EF 1B SHL 06F0 03 SUB 06F1 84 DUP5 06F2 16 AND 06F3 60 PUSH1 0x00 06F5 90 SWAP1 06F6 81 DUP2 06F7 52 MSTORE 06F8 60 PUSH1 0x02 06FA 60 PUSH1 0x20 06FC 52 MSTORE 06FD 60 PUSH1 0x40 06FF 90 SWAP1 0700 20 SHA3 0701 54 SLOAD 0702 82 DUP3 0703 11 GT 0704 15 ISZERO 0705 61 PUSH2 0x070d 0708 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @06F7 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @06FC memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x070d, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])]) label_0709: // Incoming jump from 0x0708, if not !(stack[-2] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @070C memory[0x00:0x00] } 0709 60 PUSH1 0x00 070B 80 DUP1 070C FD *REVERT // Stack delta = +0 // Outputs[1] { @070C revert(memory[0x00:0x00]); } // Block terminates label_070D: // Incoming jump from 0x0708, if !(stack[-2] > storage[keccak256(memory[0x00:0x40])]) // Inputs[7] // { // @0717 stack[-4] // @0729 memory[0x00:0x40] // @072B storage[keccak256(memory[0x00:0x40])] // @072C stack[-2] // @0732 stack[-3] // @073A memory[0x00:0x40] // @073B storage[keccak256(memory[0x00:0x40])] // } 070D 5B JUMPDEST 070E 60 PUSH1 0x01 0710 60 PUSH1 0x01 0712 60 PUSH1 0xa0 0714 1B SHL 0715 03 SUB 0716 80 DUP1 0717 85 DUP6 0718 16 AND 0719 60 PUSH1 0x00 071B 90 SWAP1 071C 81 DUP2 071D 52 MSTORE 071E 60 PUSH1 0x02 0720 60 PUSH1 0x20 0722 90 SWAP1 0723 81 DUP2 0724 52 MSTORE 0725 60 PUSH1 0x40 0727 80 DUP1 0728 83 DUP4 0729 20 SHA3 072A 80 DUP1 072B 54 SLOAD 072C 87 DUP8 072D 90 SWAP1 072E 03 SUB 072F 90 SWAP1 0730 55 SSTORE 0731 92 SWAP3 0732 86 DUP7 0733 16 AND 0734 82 DUP3 0735 52 MSTORE 0736 60 PUSH1 0x01 0738 90 SWAP1 0739 52 MSTORE 073A 20 SHA3 073B 54 SLOAD 073C 60 PUSH1 0xff 073E 16 AND 073F 80 DUP1 0740 61 PUSH2 0x0761 0743 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @071D memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @0724 memory[0x20:0x40] = 0x02 // @0730 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-2] // @0735 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0739 memory[0x20:0x40] = 0x01 // @073E stack[0] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0761, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0744: // Incoming jump from 0x0743, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @074D stack[-5] // @075C memory[0x00:0x40] // @075D storage[keccak256(memory[0x00:0x40])] // } 0744 50 POP 0745 60 PUSH1 0x01 0747 60 PUSH1 0x01 0749 60 PUSH1 0xa0 074B 1B SHL 074C 03 SUB 074D 84 DUP5 074E 16 AND 074F 60 PUSH1 0x00 0751 90 SWAP1 0752 81 DUP2 0753 52 MSTORE 0754 60 PUSH1 0x01 0756 60 PUSH1 0x20 0758 52 MSTORE 0759 60 PUSH1 0x40 075B 90 SWAP1 075C 20 SHA3 075D 54 SLOAD 075E 60 PUSH1 0xff 0760 16 AND 0761 5B JUMPDEST 0762 15 ISZERO 0763 61 PUSH2 0x076e 0766 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0753 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0758 memory[0x20:0x40] = 0x01 // } // Block ends with conditional jump to 0x076e, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0767: // Incoming jump from 0x0766, if not !stack[-1] // Incoming jump from 0x0766, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) 0767 50 POP 0768 60 PUSH1 0x01 076A 61 PUSH2 0x07e1 076D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0768 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x07e1 label_076E: // Incoming jump from 0x0766, if !stack[-1] // Incoming jump from 0x0766, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0774 stack[-4] // @0775 stack[-3] // @0776 stack[-2] // } 076E 5B JUMPDEST 076F 60 PUSH1 0x00 0771 61 PUSH2 0x077b 0774 85 DUP6 0775 85 DUP6 0776 85 DUP6 0777 61 PUSH2 0x0a40 077A 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @076F stack[0] = 0x00 // @0771 stack[1] = 0x077b // @0774 stack[2] = stack[-4] // @0775 stack[3] = stack[-3] // @0776 stack[4] = stack[-2] // } // Block ends with call to 0x0a40, returns to 0x077B label_077B: // Incoming return from call to 0x0A40 at 0x077A // Inputs[11] // { // @0785 stack[-5] // @0798 memory[0x00:0x40] // @079A storage[keccak256(memory[0x00:0x40])] // @079B stack[-1] // @079C stack[-4] // @07A2 memory[0x40:0x60] // @07A7 memory[0x40:0x60] // @07A9 stack[-2] // @07AE stack[-6] // @07DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @07DE stack[-3] // } 077B 5B JUMPDEST 077C 60 PUSH1 0x01 077E 60 PUSH1 0x01 0780 60 PUSH1 0xa0 0782 1B SHL 0783 03 SUB 0784 80 DUP1 0785 86 DUP7 0786 16 AND 0787 60 PUSH1 0x00 0789 81 DUP2 078A 81 DUP2 078B 52 MSTORE 078C 60 PUSH1 0x02 078E 60 PUSH1 0x20 0790 90 SWAP1 0791 81 DUP2 0792 52 MSTORE 0793 60 PUSH1 0x40 0795 91 SWAP2 0796 82 DUP3 0797 90 SWAP1 0798 20 SHA3 0799 80 DUP1 079A 54 SLOAD 079B 86 DUP7 079C 8A DUP11 079D 03 SUB 079E 01 ADD 079F 90 SWAP1 07A0 55 SSTORE 07A1 81 DUP2 07A2 51 MLOAD 07A3 88 DUP9 07A4 81 DUP2 07A5 52 MSTORE 07A6 91 SWAP2 07A7 51 MLOAD 07A8 94 SWAP5 07A9 95 SWAP6 07AA 50 POP 07AB 91 SWAP2 07AC 93 SWAP4 07AD 92 SWAP3 07AE 89 DUP10 07AF 16 AND 07B0 92 SWAP3 07B1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 07D2 92 SWAP3 07D3 91 SWAP2 07D4 81 DUP2 07D5 90 SWAP1 07D6 03 SUB 07D7 90 SWAP1 07D8 91 SWAP2 07D9 01 ADD 07DA 90 SWAP1 07DB A3 LOG3 07DC 60 PUSH1 0x01 07DE 91 SWAP2 07DF 50 POP 07E0 50 POP // Stack delta = -2 // Outputs[6] // { // @078B memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0792 memory[0x20:0x40] = 0x02 // @07A0 storage[keccak256(memory[0x00:0x40])] = stack[-4] - stack[-1] + storage[keccak256(memory[0x00:0x40])] // @07A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @07DB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01]); // @07DE stack[-3] = 0x01 // } // Block continues label_07E1: // Incoming jump from 0x076D // Incoming jump from 0x07E0 // Incoming jump from 0x0661 // Incoming return from call to 0x0653 at 0x0870 // Incoming jump from 0x0B46 // Inputs[3] // { // @07E2 stack[-5] // @07E2 stack[-1] // @07E3 stack[-4] // } 07E1 5B JUMPDEST 07E2 93 SWAP4 07E3 92 SWAP3 07E4 50 POP 07E5 50 POP 07E6 50 POP 07E7 56 *JUMP // Stack delta = -4 // Outputs[1] { @07E2 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_07E8: // Incoming call from 0x02AF, returns to 0x0187 // Inputs[2] // { // @07EB storage[0x08] // @07EF stack[-1] // } 07E8 5B JUMPDEST 07E9 60 PUSH1 0x08 07EB 54 SLOAD 07EC 60 PUSH1 0xff 07EE 16 AND 07EF 81 DUP2 07F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @07EE stack[0] = 0xff & storage[0x08] } // Block ends with unconditional jump to stack[-1] label_07F1: // Incoming call from 0x02C4, returns to 0x01B0 // Inputs[2] // { // @07F4 storage[0x04] // @07F5 stack[-1] // } 07F1 5B JUMPDEST 07F2 60 PUSH1 0x04 07F4 54 SLOAD 07F5 81 DUP2 07F6 56 *JUMP // Stack delta = +1 // Outputs[1] { @07F4 stack[0] = storage[0x04] } // Block ends with unconditional jump to stack[-1] label_07F7: // Incoming jump from 0x02F7 // Inputs[4] // { // @07FF stack[-1] // @0805 memory[0x00:0x40] // @0806 storage[keccak256(memory[0x00:0x40])] // @0807 stack[-2] // } 07F7 5B JUMPDEST 07F8 60 PUSH1 0x02 07FA 60 PUSH1 0x20 07FC 52 MSTORE 07FD 60 PUSH1 0x00 07FF 90 SWAP1 0800 81 DUP2 0801 52 MSTORE 0802 60 PUSH1 0x40 0804 90 SWAP1 0805 20 SHA3 0806 54 SLOAD 0807 81 DUP2 0808 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @07FC memory[0x20:0x40] = 0x02 // @0801 memory[0x00:0x20] = stack[-1] // @0806 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0809: // Incoming call from 0x030C, returns to 0x00E6 // Inputs[2] // { // @080D storage[0x07] // @0811 memory[0x40:0x60] // } 0809 5B JUMPDEST 080A 60 PUSH1 0x07 080C 80 DUP1 080D 54 SLOAD 080E 60 PUSH1 0x40 0810 80 DUP1 0811 51 MLOAD 0812 60 PUSH1 0x20 0814 60 PUSH1 0x02 0816 60 PUSH1 0x01 0818 85 DUP6 0819 16 AND 081A 15 ISZERO 081B 61 PUSH2 0x0100 081E 02 MUL 081F 60 PUSH1 0x00 0821 19 NOT 0822 01 ADD 0823 90 SWAP1 0824 94 SWAP5 0825 16 AND 0826 93 SWAP4 0827 90 SWAP1 0828 93 SWAP4 0829 04 DIV 082A 60 PUSH1 0x1f 082C 81 DUP2 082D 01 ADD 082E 84 DUP5 082F 90 SWAP1 0830 04 DIV 0831 84 DUP5 0832 02 MUL 0833 82 DUP3 0834 01 ADD 0835 84 DUP5 0836 01 ADD 0837 90 SWAP1 0838 92 SWAP3 0839 52 MSTORE 083A 81 DUP2 083B 81 DUP2 083C 52 MSTORE 083D 92 SWAP3 083E 91 SWAP2 083F 83 DUP4 0840 01 ADD 0841 82 DUP3 0842 82 DUP3 0843 80 DUP1 0844 15 ISZERO 0845 61 PUSH2 0x0557 0848 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @0838 stack[2] = (storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02 // @0839 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02 + 0x1f) / 0x20) // @083C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02 // @083D stack[0] = memory[0x40:0x60] // @083E stack[1] = 0x07 // @0840 stack[3] = memory[0x40:0x60] + 0x20 // @0841 stack[4] = 0x07 // @0842 stack[5] = (storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x0557, if !((storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02) label_0849: // Incoming jump from 0x0848, if not !((storage[0x07] & ~0x00 + 0x0100 * !(storage[0x07] & 0x01)) / 0x02) // Inputs[1] { @0849 stack[-1] } 0849 80 DUP1 084A 60 PUSH1 0x1f 084C 10 LT 084D 61 PUSH2 0x052c 0850 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052c, if 0x1f < stack[-1] label_0851: // Incoming jump from 0x0850, if not 0x1f < stack[-1] // Inputs[4] // { // @0855 stack[-2] // @0856 storage[stack[-2]] // @0859 stack[-3] // @085B stack[-1] // } 0851 61 PUSH2 0x0100 0854 80 DUP1 0855 83 DUP4 0856 54 SLOAD 0857 04 DIV 0858 02 MUL 0859 83 DUP4 085A 52 MSTORE 085B 91 SWAP2 085C 60 PUSH1 0x20 085E 01 ADD 085F 91 SWAP2 0860 61 PUSH2 0x0557 0863 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @085A memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @085F stack[-1] = stack[-1] // @085F stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0557 label_0864: // Incoming jump from 0x0338 // Inputs[3] // { // @086A msg.sender // @086B stack[-2] // @086C stack[-1] // } 0864 5B JUMPDEST 0865 60 PUSH1 0x00 0867 61 PUSH2 0x07e1 086A 33 CALLER 086B 84 DUP5 086C 84 DUP5 086D 61 PUSH2 0x0653 0870 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0865 stack[0] = 0x00 // @0867 stack[1] = 0x07e1 // @086A stack[2] = msg.sender // @086B stack[3] = stack[-2] // @086C stack[4] = stack[-1] // } // Block ends with call to 0x0653, returns to 0x07E1 label_0871: // Incoming jump from 0x03DD // Inputs[2] // { // @0874 storage[0x08] // @0886 msg.sender // } 0871 5B JUMPDEST 0872 60 PUSH1 0x08 0874 54 SLOAD 0875 60 PUSH1 0x00 0877 90 SWAP1 0878 61 PUSH2 0x0100 087B 90 SWAP1 087C 04 DIV 087D 60 PUSH1 0x01 087F 60 PUSH1 0x01 0881 60 PUSH1 0xa0 0883 1B SHL 0884 03 SUB 0885 16 AND 0886 33 CALLER 0887 14 EQ 0888 61 PUSH2 0x0890 088B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0877 stack[0] = 0x00 } // Block ends with conditional jump to 0x0890, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 label_088C: // Incoming jump from 0x088B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 // Inputs[1] { @088F memory[0x00:0x00] } 088C 60 PUSH1 0x00 088E 80 DUP1 088F FD *REVERT // Stack delta = +0 // Outputs[1] { @088F revert(memory[0x00:0x00]); } // Block terminates label_0890: // Incoming jump from 0x088B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 // Inputs[6] // { // @0891 stack[-3] // @0892 memory[stack[-3]:stack[-3] + 0x20] // @0893 msg.sender // @08A1 memory[0x00:0x40] // @08A2 storage[keccak256(memory[0x00:0x40])] // @08A4 stack[-2] // } 0890 5B JUMPDEST 0891 82 DUP3 0892 51 MLOAD 0893 33 CALLER 0894 60 PUSH1 0x00 0896 90 SWAP1 0897 81 DUP2 0898 52 MSTORE 0899 60 PUSH1 0x02 089B 60 PUSH1 0x20 089D 52 MSTORE 089E 60 PUSH1 0x40 08A0 90 SWAP1 08A1 20 SHA3 08A2 54 SLOAD 08A3 90 SWAP1 08A4 83 DUP4 08A5 02 MUL 08A6 90 SWAP1 08A7 81 DUP2 08A8 11 GT 08A9 15 ISZERO 08AA 61 PUSH2 0x08b2 08AD 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0898 memory[0x00:0x20] = msg.sender // @089D memory[0x20:0x40] = 0x02 // @08A6 stack[0] = stack[-2] * memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x08b2, if !(stack[-2] * memory[stack[-3]:stack[-3] + 0x20] > storage[keccak256(memory[0x00:0x40])]) label_08AE: // Incoming jump from 0x08AD, if not !(stack[-2] * memory[stack[-3]:stack[-3] + 0x20] > storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @08B1 memory[0x00:0x00] } 08AE 60 PUSH1 0x00 08B0 80 DUP1 08B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @08B1 revert(memory[0x00:0x00]); } // Block terminates label_08B2: // Incoming jump from 0x08AD, if !(stack[-2] * memory[stack[-3]:stack[-3] + 0x20] > storage[keccak256(memory[0x00:0x40])]) // Inputs[6] // { // @08B3 msg.sender // @08C1 memory[0x00:0x40] // @08C3 storage[keccak256(memory[0x00:0x40])] // @08C4 stack[-1] // @08CA stack[-4] // @08CB memory[stack[-4]:stack[-4] + 0x20] // } 08B2 5B JUMPDEST 08B3 33 CALLER 08B4 60 PUSH1 0x00 08B6 90 SWAP1 08B7 81 DUP2 08B8 52 MSTORE 08B9 60 PUSH1 0x02 08BB 60 PUSH1 0x20 08BD 52 MSTORE 08BE 60 PUSH1 0x40 08C0 81 DUP2 08C1 20 SHA3 08C2 80 DUP1 08C3 54 SLOAD 08C4 83 DUP4 08C5 90 SWAP1 08C6 03 SUB 08C7 90 SWAP1 08C8 55 SSTORE 08C9 5B JUMPDEST 08CA 84 DUP5 08CB 51 MLOAD 08CC 81 DUP2 08CD 10 LT 08CE 15 ISZERO 08CF 61 PUSH2 0x0956 08D2 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @08B6 stack[0] = 0x00 // @08B8 memory[0x00:0x20] = msg.sender // @08BD memory[0x20:0x40] = 0x02 // @08C8 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] - stack[-1] // } // Block ends with conditional jump to 0x0956, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_08D3: // Incoming jump from 0x08D2, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x08D2, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @08D5 stack[-5] // @08D6 stack[-1] // @08D8 memory[stack[-5]:stack[-5] + 0x20] // } 08D3 60 PUSH1 0x00 08D5 85 DUP6 08D6 82 DUP3 08D7 81 DUP2 08D8 51 MLOAD 08D9 81 DUP2 08DA 10 LT 08DB 61 PUSH2 0x08e0 08DE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08D3 stack[0] = 0x00 // @08D5 stack[1] = stack[-5] // @08D6 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x08e0, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_08DF: // Incoming jump from 0x08DE, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 08DF FE *ASSERT // Stack delta = +0 // Outputs[1] { @08DF assert(); } // Block terminates label_08E0: // Incoming jump from 0x08DE, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[13] // { // @08E3 stack[-1] // @08E6 stack[-2] // @08EC memory[stack[-1] * 0x20 + stack[-2] + 0x20:stack[-1] * 0x20 + stack[-2] + 0x20 + 0x20] // @0904 memory[0x00:0x40] // @0906 storage[keccak256(memory[0x00:0x40])] // @0907 stack[-7] // @0911 memory[0x00:0x40] // @0917 memory[0x40:0x60] // @091C memory[0x40:0x60] // @091E stack[-3] // @0922 msg.sender // @094D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @0951 stack[-4] // } 08E0 5B JUMPDEST 08E1 60 PUSH1 0x20 08E3 90 SWAP1 08E4 81 DUP2 08E5 02 MUL 08E6 91 SWAP2 08E7 90 SWAP1 08E8 91 SWAP2 08E9 01 ADD 08EA 81 DUP2 08EB 01 ADD 08EC 51 MLOAD 08ED 60 PUSH1 0x01 08EF 60 PUSH1 0x01 08F1 60 PUSH1 0xa0 08F3 1B SHL 08F4 03 SUB 08F5 81 DUP2 08F6 16 AND 08F7 60 PUSH1 0x00 08F9 81 DUP2 08FA 81 DUP2 08FB 52 MSTORE 08FC 60 PUSH1 0x02 08FE 84 DUP5 08FF 52 MSTORE 0900 60 PUSH1 0x40 0902 80 DUP1 0903 82 DUP3 0904 20 SHA3 0905 80 DUP1 0906 54 SLOAD 0907 8B DUP12 0908 01 ADD 0909 90 SWAP1 090A 55 SSTORE 090B 81 DUP2 090C 85 DUP6 090D 52 MSTORE 090E 90 SWAP1 090F 81 DUP2 0910 90 SWAP1 0911 20 SHA3 0912 60 PUSH1 0x01 0914 90 SWAP1 0915 55 SSTORE 0916 80 DUP1 0917 51 MLOAD 0918 89 DUP10 0919 81 DUP2 091A 52 MSTORE 091B 90 SWAP1 091C 51 MLOAD 091D 92 SWAP3 091E 94 SWAP5 091F 50 POP 0920 90 SWAP1 0921 92 SWAP3 0922 33 CALLER 0923 92 SWAP3 0924 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0945 92 SWAP3 0946 81 DUP2 0947 90 SWAP1 0948 03 SUB 0949 90 SWAP1 094A 91 SWAP2 094B 01 ADD 094C 90 SWAP1 094D A3 LOG3 094E 50 POP 094F 60 PUSH1 0x01 0951 01 ADD 0952 61 PUSH2 0x08c9 0955 56 *JUMP // Stack delta = -3 // Outputs[8] // { // @08FB memory[0x00:0x20] = memory[stack[-1] * 0x20 + stack[-2] + 0x20:stack[-1] * 0x20 + stack[-2] + 0x20 + 0x20] & (0x01 << 0xa0) - 0x01 // @08FF memory[0x20:0x40] = 0x02 // @090A storage[keccak256(memory[0x00:0x40])] = stack[-7] + storage[keccak256(memory[0x00:0x40])] // @090D memory[0x20:0x40] = 0x00 // @0915 storage[keccak256(memory[0x00:0x40])] = 0x01 // @091A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-7] // @094D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, msg.sender, memory[stack[-1] * 0x20 + stack[-2] + 0x20:stack[-1] * 0x20 + stack[-2] + 0x20 + 0x20] & (0x01 << 0xa0) - 0x01]); // @0951 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x08c9 label_0956: // Incoming jump from 0x08D2, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x08D2, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[2] // { // @095A stack[-6] // @095B stack[-5] // } 0956 5B JUMPDEST 0957 50 POP 0958 60 PUSH1 0x01 095A 94 SWAP5 095B 93 SWAP4 095C 50 POP 095D 50 POP 095E 50 POP 095F 50 POP 0960 56 *JUMP // Stack delta = -5 // Outputs[1] { @095A stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_0961: // Incoming jump from 0x0493 // Inputs[2] // { // @0964 storage[0x08] // @0973 msg.sender // } 0961 5B JUMPDEST 0962 60 PUSH1 0x08 0964 54 SLOAD 0965 61 PUSH2 0x0100 0968 90 SWAP1 0969 04 DIV 096A 60 PUSH1 0x01 096C 60 PUSH1 0x01 096E 60 PUSH1 0xa0 0970 1B SHL 0971 03 SUB 0972 16 AND 0973 33 CALLER 0974 14 EQ 0975 61 PUSH2 0x097d 0978 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x097d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 label_0979: // Incoming jump from 0x0978, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 // Inputs[1] { @097C memory[0x00:0x00] } 0979 60 PUSH1 0x00 097B 80 DUP1 097C FD *REVERT // Stack delta = +0 // Outputs[1] { @097C revert(memory[0x00:0x00]); } // Block terminates label_097D: // Incoming jump from 0x0978, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] / 0x0100 // Inputs[4] // { // @097E stack[-2] // @0988 stack[-1] // @098B memory[0x40:0x60] // @098F memory[stack[-1]:stack[-1] + 0x20] // } 097D 5B JUMPDEST 097E 81 DUP2 097F 60 PUSH1 0x01 0981 60 PUSH1 0x01 0983 60 PUSH1 0xa0 0985 1B SHL 0986 03 SUB 0987 16 AND 0988 81 DUP2 0989 60 PUSH1 0x40 098B 51 MLOAD 098C 80 DUP1 098D 82 DUP3 098E 80 DUP1 098F 51 MLOAD 0990 90 SWAP1 0991 60 PUSH1 0x20 0993 01 ADD 0994 90 SWAP1 0995 80 DUP1 0996 83 DUP4 0997 83 DUP4 0998 5B JUMPDEST 0999 60 PUSH1 0x20 099B 83 DUP4 099C 10 LT 099D 61 PUSH2 0x09b7 09A0 57 *JUMPI // Stack delta = +9 // Outputs[9] // { // @0987 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0988 stack[1] = stack[-1] // @098B stack[2] = memory[0x40:0x60] // @098C stack[3] = memory[0x40:0x60] // @0994 stack[4] = 0x20 + stack[-1] // @0994 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0995 stack[6] = memory[stack[-1]:stack[-1] + 0x20] // @0996 stack[7] = memory[0x40:0x60] // @0997 stack[8] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x09b7, if memory[stack[-1]:stack[-1] + 0x20] < 0x20 label_09A1: // Incoming jump from 0x09A0, if not stack[-3] < 0x20 // Incoming jump from 0x09A0, if not memory[stack[-1]:stack[-1] + 0x20] < 0x20 // Inputs[4] // { // @09A1 stack[-1] // @09A2 memory[stack[-1]:stack[-1] + 0x20] // @09A3 stack[-2] // @09A9 stack[-3] // } 09A1 80 DUP1 09A2 51 MLOAD 09A3 82 DUP3 09A4 52 MSTORE 09A5 60 PUSH1 0x1f 09A7 19 NOT 09A8 90 SWAP1 09A9 92 SWAP3 09AA 01 ADD 09AB 91 SWAP2 09AC 60 PUSH1 0x20 09AE 91 SWAP2 09AF 82 DUP3 09B0 01 ADD 09B1 91 SWAP2 09B2 01 ADD 09B3 61 PUSH2 0x0998 09B6 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @09A4 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @09AB stack[-3] = stack[-3] + ~0x1f // @09B1 stack[-2] = 0x20 + stack[-2] // @09B2 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x0998 label_09B7: // Incoming jump from 0x09A0, if stack[-3] < 0x20 // Incoming jump from 0x09A0, if memory[stack[-1]:stack[-1] + 0x20] < 0x20 // Inputs[15] // { // @09BA stack[-3] // @09C5 stack[-1] // @09C6 memory[stack[-1]:stack[-1] + 0x20] // @09C9 stack[-2] // @09CA memory[stack[-2]:stack[-2] + 0x20] // @09D7 stack[-4] // @09D7 stack[-5] // @09D9 stack[-6] // @09DA stack[-8] // @09E1 memory[0x40:0x60] // @09E6 stack[-9] // @09E7 msg.gas // @09E8 address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @09E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @09EC returndata.length // } 09B7 5B JUMPDEST 09B8 60 PUSH1 0x01 09BA 83 DUP4 09BB 60 PUSH1 0x20 09BD 03 SUB 09BE 61 PUSH2 0x0100 09C1 0A EXP 09C2 03 SUB 09C3 80 DUP1 09C4 19 NOT 09C5 82 DUP3 09C6 51 MLOAD 09C7 16 AND 09C8 81 DUP2 09C9 84 DUP5 09CA 51 MLOAD 09CB 16 AND 09CC 80 DUP1 09CD 82 DUP3 09CE 17 OR 09CF 85 DUP6 09D0 52 MSTORE 09D1 50 POP 09D2 50 POP 09D3 50 POP 09D4 50 POP 09D5 50 POP 09D6 50 POP 09D7 90 SWAP1 09D8 50 POP 09D9 01 ADD 09DA 91 SWAP2 09DB 50 POP 09DC 50 POP 09DD 60 PUSH1 0x00 09DF 60 PUSH1 0x40 09E1 51 MLOAD 09E2 80 DUP1 09E3 83 DUP4 09E4 03 SUB 09E5 81 DUP2 09E6 85 DUP6 09E7 5A GAS 09E8 F4 DELEGATECALL 09E9 91 SWAP2 09EA 50 POP 09EB 50 POP 09EC 3D RETURNDATASIZE 09ED 80 DUP1 09EE 60 PUSH1 0x00 09F0 81 DUP2 09F1 14 EQ 09F2 61 PUSH2 0x0a17 09F5 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @09D0 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @09E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @09E9 stack[-9] = address(stack[-9]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @09EC stack[-8] = returndata.length // @09ED stack[-7] = returndata.length // } // Block ends with conditional jump to 0x0a17, if returndata.length == 0x00 label_09F6: // Incoming jump from 0x09F5, if not returndata.length == 0x00 // Inputs[6] // { // @09F8 memory[0x40:0x60] // @09F9 stack[-2] // @0A00 returndata.length // @0A08 returndata.length // @0A0B returndata.length // @0A12 returndata[0x00:0x00 + returndata.length] // } 09F6 60 PUSH1 0x40 09F8 51 MLOAD 09F9 91 SWAP2 09FA 50 POP 09FB 60 PUSH1 0x1f 09FD 19 NOT 09FE 60 PUSH1 0x3f 0A00 3D RETURNDATASIZE 0A01 01 ADD 0A02 16 AND 0A03 82 DUP3 0A04 01 ADD 0A05 60 PUSH1 0x40 0A07 52 MSTORE 0A08 3D RETURNDATASIZE 0A09 82 DUP3 0A0A 52 MSTORE 0A0B 3D RETURNDATASIZE 0A0C 60 PUSH1 0x00 0A0E 60 PUSH1 0x20 0A10 84 DUP5 0A11 01 ADD 0A12 3E RETURNDATACOPY 0A13 61 PUSH2 0x0a1c 0A16 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @09F9 stack[-2] = memory[0x40:0x60] // @0A07 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0A0A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0A12 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0a1c label_0A17: // Incoming jump from 0x09F5, if returndata.length == 0x00 // Inputs[2] // { // @0A1A stack[-2] // @0A22 stack[-6] // } 0A17 5B JUMPDEST 0A18 60 PUSH1 0x60 0A1A 91 SWAP2 0A1B 50 POP 0A1C 5B JUMPDEST 0A1D 50 POP 0A1E 50 POP 0A1F 50 POP 0A20 50 POP 0A21 50 POP 0A22 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0A23: // Incoming jump from 0x04D0 // Inputs[6] // { // @0A2D stack[-2] // @0A34 memory[0x00:0x40] // @0A38 stack[-1] // @0A3C memory[0x00:0x40] // @0A3D storage[keccak256(memory[0x00:0x40])] // @0A3E stack[-3] // } 0A23 5B JUMPDEST 0A24 60 PUSH1 0x03 0A26 60 PUSH1 0x20 0A28 90 SWAP1 0A29 81 DUP2 0A2A 52 MSTORE 0A2B 60 PUSH1 0x00 0A2D 92 SWAP3 0A2E 83 DUP4 0A2F 52 MSTORE 0A30 60 PUSH1 0x40 0A32 80 DUP1 0A33 84 DUP5 0A34 20 SHA3 0A35 90 SWAP1 0A36 91 SWAP2 0A37 52 MSTORE 0A38 90 SWAP1 0A39 82 DUP3 0A3A 52 MSTORE 0A3B 90 SWAP1 0A3C 20 SHA3 0A3D 54 SLOAD 0A3E 81 DUP2 0A3F 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @0A2A memory[0x20:0x40] = 0x03 // @0A2F memory[0x00:0x20] = stack[-2] // @0A37 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0A3A memory[0x00:0x20] = stack[-1] // @0A3D stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0A40: // Incoming call from 0x077A, returns to 0x077B // Inputs[1] { @0A43 storage[0x08] } 0A40 5B JUMPDEST 0A41 60 PUSH1 0x08 0A43 54 SLOAD 0A44 60 PUSH1 0x00 0A46 90 SWAP1 0A47 60 PUSH1 0xff 0A49 16 AND 0A4A 80 DUP1 0A4B 15 ISZERO 0A4C 61 PUSH2 0x0a62 0A4F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0A46 stack[0] = 0x00 // @0A49 stack[1] = 0xff & storage[0x08] // } // Block ends with conditional jump to 0x0a62, if !(0xff & storage[0x08]) label_0A50: // Incoming jump from 0x0A4F, if not !(0xff & storage[0x08]) // Inputs[2] // { // @0A53 storage[0x09] // @0A5C stack[-4] // } 0A50 50 POP 0A51 60 PUSH1 0x09 0A53 54 SLOAD 0A54 60 PUSH1 0x01 0A56 60 PUSH1 0x01 0A58 60 PUSH1 0xa0 0A5A 1B SHL 0A5B 03 SUB 0A5C 84 DUP5 0A5D 81 DUP2 0A5E 16 AND 0A5F 91 SWAP2 0A60 16 AND 0A61 14 EQ 0A62 5B JUMPDEST 0A63 80 DUP1 0A64 15 ISZERO 0A65 61 PUSH2 0x0a81 0A68 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A61 stack[-1] = storage[0x09] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-4] } // Block ends with conditional jump to 0x0a81, if !(storage[0x09] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-4]) label_0A69: // Incoming jump from 0x0A68, if not !(storage[0x09] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-4]) // Incoming jump from 0x0A68, if not !stack[-1] // Inputs[2] // { // @0A6C storage[0x08] // @0A75 stack[-5] // } 0A69 50 POP 0A6A 60 PUSH1 0x08 0A6C 54 SLOAD 0A6D 60 PUSH1 0x01 0A6F 60 PUSH1 0x01 0A71 60 PUSH1 0xa0 0A73 1B SHL 0A74 03 SUB 0A75 85 DUP6 0A76 81 DUP2 0A77 16 AND 0A78 61 PUSH2 0x0100 0A7B 90 SWAP1 0A7C 92 SWAP3 0A7D 04 DIV 0A7E 16 AND 0A7F 14 EQ 0A80 15 ISZERO 0A81 5B JUMPDEST 0A82 80 DUP1 0A83 15 ISZERO 0A84 61 PUSH2 0x0aa3 0A87 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0A80 stack[-1] = !(storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-5]) } // Block ends with conditional jump to 0x0aa3, if !!(storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-5]) label_0A88: // Incoming jump from 0x0A87, if not !!(storage[0x08] / 0x0100 & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-5]) // Incoming jump from 0x0A87, if not !stack[-1] // Inputs[3] // { // @0A91 stack[-5] // @0AA0 memory[0x00:0x40] // @0AA1 storage[keccak256(memory[0x00:0x40])] // } 0A88 50 POP 0A89 60 PUSH1 0x01 0A8B 60 PUSH1 0x01 0A8D 60 PUSH1 0xa0 0A8F 1B SHL 0A90 03 SUB 0A91 84 DUP5 0A92 16 AND 0A93 60 PUSH1 0x00 0A95 90 SWAP1 0A96 81 DUP2 0A97 52 MSTORE 0A98 60 PUSH1 0x20 0A9A 81 DUP2 0A9B 90 SWAP1 0A9C 52 MSTORE 0A9D 60 PUSH1 0x40 0A9F 90 SWAP1 0AA0 20 SHA3 0AA1 54 SLOAD 0AA2 15 ISZERO 0AA3 5B JUMPDEST 0AA4 15 ISZERO 0AA5 61 PUSH2 0x0b47 0AA8 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0A97 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0A9C memory[0x20:0x40] = 0x00 // } // Block ends with conditional jump to 0x0b47, if !!storage[keccak256(memory[0x00:0x40])] label_0AA9: // Incoming jump from 0x0AA8, if not !!storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0AA8, if not !stack[-1] // Inputs[6] // { // @0AAB storage[0x09] // @0AAF memory[0x40:0x60] // @0ABA address(this) // @0AD4 stack[-2] // @0AD7 memory[0x40:0x60] // @0B08 address(0x0f450ddc280787b49b14b866a6e4e4d279a22fa6).code.length // } 0AA9 60 PUSH1 0x09 0AAB 54 SLOAD 0AAC 60 PUSH1 0x40 0AAE 80 DUP1 0AAF 51 MLOAD 0AB0 63 PUSH4 0x2f8e5179 0AB5 60 PUSH1 0xe2 0AB7 1B SHL 0AB8 81 DUP2 0AB9 52 MSTORE 0ABA 30 ADDRESS 0ABB 60 PUSH1 0x04 0ABD 82 DUP3 0ABE 01 ADD 0ABF 52 MSTORE 0AC0 60 PUSH1 0x01 0AC2 60 PUSH1 0x01 0AC4 60 PUSH1 0xa0 0AC6 1B SHL 0AC7 03 SUB 0AC8 90 SWAP1 0AC9 92 SWAP3 0ACA 16 AND 0ACB 60 PUSH1 0x24 0ACD 83 DUP4 0ACE 01 ADD 0ACF 52 MSTORE 0AD0 60 PUSH1 0x44 0AD2 82 DUP3 0AD3 01 ADD 0AD4 84 DUP5 0AD5 90 SWAP1 0AD6 52 MSTORE 0AD7 51 MLOAD 0AD8 73 PUSH20 0x0f450ddc280787b49b14b866a6e4e4d279a22fa6 0AED 91 SWAP2 0AEE 63 PUSH4 0xbe3945e4 0AF3 91 SWAP2 0AF4 60 PUSH1 0x64 0AF6 80 DUP1 0AF7 83 DUP4 0AF8 01 ADD 0AF9 92 SWAP3 0AFA 60 PUSH1 0x20 0AFC 92 SWAP3 0AFD 91 SWAP2 0AFE 90 SWAP1 0AFF 82 DUP3 0B00 90 SWAP1 0B01 03 SUB 0B02 01 ADD 0B03 81 DUP2 0B04 60 PUSH1 0x00 0B06 87 DUP8 0B07 80 DUP1 0B08 3B EXTCODESIZE 0B09 15 ISZERO 0B0A 80 DUP1 0B0B 15 ISZERO 0B0C 61 PUSH2 0x0b14 0B0F 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @0AB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2f8e5179 << 0xe2 // @0ABF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0ACF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = storage[0x09] & (0x01 << 0xa0) - 0x01 // @0AD6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-2] // @0AED stack[0] = 0x0f450ddc280787b49b14b866a6e4e4d279a22fa6 // @0AF3 stack[1] = 0xbe3945e4 // @0AF9 stack[2] = memory[0x40:0x60] + 0x64 // @0AFC stack[3] = 0x20 // @0AFD stack[4] = memory[0x40:0x60] // @0B02 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @0B03 stack[6] = memory[0x40:0x60] // @0B04 stack[7] = 0x00 // @0B06 stack[8] = 0x0f450ddc280787b49b14b866a6e4e4d279a22fa6 // @0B09 stack[9] = !address(0x0f450ddc280787b49b14b866a6e4e4d279a22fa6).code.length // } // Block ends with conditional jump to 0x0b14, if !!address(0x0f450ddc280787b49b14b866a6e4e4d279a22fa6).code.length label_0B10: // Incoming jump from 0x0B0F, if not !!address(0x0f450ddc280787b49b14b866a6e4e4d279a22fa6).code.length // Inputs[1] { @0B13 memory[0x00:0x00] } 0B10 60 PUSH1 0x00 0B12 80 DUP1 0B13 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B13 revert(memory[0x00:0x00]); } // Block terminates label_0B14: // Incoming jump from 0x0B0F, if !!address(0x0f450ddc280787b49b14b866a6e4e4d279a22fa6).code.length // Inputs[9] // { // @0B16 msg.gas // @0B17 stack[-6] // @0B17 stack[-7] // @0B17 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0B17 stack[-4] // @0B17 memory[stack[-4]:stack[-4] + stack[-5]] // @0B17 stack[-3] // @0B17 stack[-2] // @0B17 stack[-5] // } 0B14 5B JUMPDEST 0B15 50 POP 0B16 5A GAS 0B17 F1 CALL 0B18 15 ISZERO 0B19 80 DUP1 0B1A 15 ISZERO 0B1B 61 PUSH2 0x0b28 0B1E 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0B17 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0B18 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0b28, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0B1F: // Incoming jump from 0x0B1E, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0B1F returndata.length // @0B23 returndata[0x00:0x00 + returndata.length] // @0B24 returndata.length // @0B27 memory[0x00:0x00 + returndata.length] // } 0B1F 3D RETURNDATASIZE 0B20 60 PUSH1 0x00 0B22 80 DUP1 0B23 3E RETURNDATACOPY 0B24 3D RETURNDATASIZE 0B25 60 PUSH1 0x00 0B27 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B23 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0B27 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0B28: // Incoming jump from 0x0B1E, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0B2F memory[0x40:0x60] // @0B30 returndata.length // } 0B28 5B JUMPDEST 0B29 50 POP 0B2A 50 POP 0B2B 50 POP 0B2C 50 POP 0B2D 60 PUSH1 0x40 0B2F 51 MLOAD 0B30 3D RETURNDATASIZE 0B31 60 PUSH1 0x20 0B33 81 DUP2 0B34 10 LT 0B35 15 ISZERO 0B36 61 PUSH2 0x0b3e 0B39 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0B2F stack[-4] = memory[0x40:0x60] // @0B30 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0b3e, if !(returndata.length < 0x20) label_0B3A: // Incoming jump from 0x0B39, if not !(returndata.length < 0x20) // Inputs[1] { @0B3D memory[0x00:0x00] } 0B3A 60 PUSH1 0x00 0B3C 80 DUP1 0B3D FD *REVERT // Stack delta = +0 // Outputs[1] { @0B3D revert(memory[0x00:0x00]); } // Block terminates label_0B3E: // Incoming jump from 0x0B39, if !(returndata.length < 0x20) // Inputs[3] // { // @0B40 stack[-2] // @0B40 memory[stack[-2]:stack[-2] + 0x20] // @0B41 stack[-3] // } 0B3E 5B JUMPDEST 0B3F 50 POP 0B40 51 MLOAD 0B41 90 SWAP1 0B42 50 POP 0B43 61 PUSH2 0x07e1 0B46 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B41 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x07e1 label_0B47: // Incoming jump from 0x0AA8, if !!storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0AA8, if !stack[-1] // Inputs[2] // { // @0B4B stack[-5] // @0B4C stack[-4] // } 0B47 5B JUMPDEST 0B48 50 POP 0B49 60 PUSH1 0x00 0B4B 93 SWAP4 0B4C 92 SWAP3 0B4D 50 POP 0B4E 50 POP 0B4F 50 POP 0B50 56 *JUMP // Stack delta = -4 // Outputs[1] { @0B4B stack[-5] = 0x00 } // Block ends with unconditional jump to stack[-5] 0B51 FE *ASSERT 0B52 A2 LOG2 0B53 65 PUSH6 0x627a7a723158 0B5A 20 SHA3 0B5B 15 ISZERO 0B5C E9 E9 0B5D 39 CODECOPY 0B5E B0 PUSH 0B5F 08 ADDMOD 0B60 A4 LOG4 0B61 39 CODECOPY 0B62 A2 LOG2 0B63 20 SHA3 0B64 38 CODESIZE 0B65 71 PUSH18 0x154290cb73cfb1ad1cd46f715dfa49ea67f6 0B78 EA EA 0B79 7E PUSH31 0x6d64736f6c63430005110032