Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x01a9 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01a9, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x8f32d59b 0026 11 GT 0027 61 PUSH2 0x00f9 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00f9, if 0x8f32d59b > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x8f32d59b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xd6e4fa86 0031 11 GT 0032 61 PUSH2 0x0097 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0097, if 0xd6e4fa86 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xd6e4fa86 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe985e9c5 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xe985e9c5 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe985e9c5 0047 14 EQ 0048 61 PUSH2 0x0934 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0934, if 0xe985e9c5 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf2fde38b 0052 14 EQ 0053 61 PUSH2 0x09b0 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b0, if 0xf2fde38b == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf6a74ed7 005D 14 EQ 005E 61 PUSH2 0x09f4 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09f4, if 0xf6a74ed7 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf6a74ed7 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xfca247ac 0068 14 EQ 0069 61 PUSH2 0x0a38 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a38, if 0xfca247ac == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xfca247ac == stack[-1] 006D 61 PUSH2 0x01a9 0070 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a9 label_0071: // Incoming jump from 0x0040, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xd6e4fa86 0078 14 EQ 0079 61 PUSH2 0x0878 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0878, if 0xd6e4fa86 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xd6e4fa86 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xda8c229e 0083 14 EQ 0084 61 PUSH2 0x08ba 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08ba, if 0xda8c229e == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xda8c229e == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xddf7fcb0 008E 14 EQ 008F 61 PUSH2 0x0916 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0916, if 0xddf7fcb0 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xddf7fcb0 == stack[-1] 0093 61 PUSH2 0x01a9 0096 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a9 label_0097: // Incoming jump from 0x0035, if 0xd6e4fa86 > stack[-1] // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0xa7fc7a07 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0xa7fc7a07 > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0xa7fc7a07 > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0xa7fc7a07 00A9 14 EQ 00AA 61 PUSH2 0x06c5 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c5, if 0xa7fc7a07 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0xa7fc7a07 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0xb88d4fde 00B4 14 EQ 00B5 61 PUSH2 0x0709 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0709, if 0xb88d4fde == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0xc1a287e2 00BF 14 EQ 00C0 61 PUSH2 0x080e 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x080e, if 0xc1a287e2 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0xc1a287e2 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0xc475abff 00CA 14 EQ 00CB 61 PUSH2 0x082c 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x082c, if 0xc475abff == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0xc475abff == stack[-1] 00CF 61 PUSH2 0x01a9 00D2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a9 label_00D3: // Incoming jump from 0x00A2, if 0xa7fc7a07 > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x8f32d59b 00DA 14 EQ 00DB 61 PUSH2 0x060d 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060d, if 0x8f32d59b == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x8f32d59b == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x96e494e8 00E5 14 EQ 00E6 61 PUSH2 0x062f 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062f, if 0x96e494e8 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x96e494e8 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0xa22cb465 00F0 14 EQ 00F1 61 PUSH2 0x0675 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0675, if 0xa22cb465 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0xa22cb465 == stack[-1] 00F5 61 PUSH2 0x01a9 00F8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a9 label_00F9: // Incoming jump from 0x002A, if 0x8f32d59b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00FA stack[-1] } 00F9 5B JUMPDEST 00FA 80 DUP1 00FB 63 PUSH4 0x3f15457f 0100 11 GT 0101 61 PUSH2 0x0166 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0166, if 0x3f15457f > stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x3f15457f > stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x6352211e 010B 11 GT 010C 61 PUSH2 0x0140 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0140, if 0x6352211e > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x6352211e > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x6352211e 0116 14 EQ 0117 61 PUSH2 0x04f3 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f3, if 0x6352211e == stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x6352211e == stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x70a08231 0121 14 EQ 0122 61 PUSH2 0x0561 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0561, if 0x70a08231 == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x70a08231 == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x715018a6 012C 14 EQ 012D 61 PUSH2 0x05b9 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b9, if 0x715018a6 == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x715018a6 == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x8da5cb5b 0137 14 EQ 0138 61 PUSH2 0x05c3 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c3, if 0x8da5cb5b == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x8da5cb5b == stack[-1] 013C 61 PUSH2 0x01a9 013F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a9 label_0140: // Incoming jump from 0x010F, if 0x6352211e > stack[-1] // Inputs[1] { @0141 stack[-1] } 0140 5B JUMPDEST 0141 80 DUP1 0142 63 PUSH4 0x3f15457f 0147 14 EQ 0148 61 PUSH2 0x03f7 014B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f7, if 0x3f15457f == stack[-1] label_014C: // Incoming jump from 0x014B, if not 0x3f15457f == stack[-1] // Inputs[1] { @014C stack[-1] } 014C 80 DUP1 014D 63 PUSH4 0x42842e0e 0152 14 EQ 0153 61 PUSH2 0x0441 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0441, if 0x42842e0e == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x42842e0e == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x4e543b26 015D 14 EQ 015E 61 PUSH2 0x04af 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04af, if 0x4e543b26 == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x4e543b26 == stack[-1] 0162 61 PUSH2 0x01a9 0165 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01a9 label_0166: // Incoming jump from 0x0104, if 0x3f15457f > stack[-1] // Inputs[1] { @0167 stack[-1] } 0166 5B JUMPDEST 0167 80 DUP1 0168 63 PUSH4 0x01ffc9a7 016D 14 EQ 016E 61 PUSH2 0x01ae 0171 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ae, if 0x01ffc9a7 == stack[-1] label_0172: // Incoming jump from 0x0171, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0172 stack[-1] } 0172 80 DUP1 0173 63 PUSH4 0x081812fc 0178 14 EQ 0179 61 PUSH2 0x0213 017C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0213, if 0x081812fc == stack[-1] label_017D: // Incoming jump from 0x017C, if not 0x081812fc == stack[-1] // Inputs[1] { @017D stack[-1] } 017D 80 DUP1 017E 63 PUSH4 0x095ea7b3 0183 14 EQ 0184 61 PUSH2 0x0281 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0281, if 0x095ea7b3 == stack[-1] label_0188: // Incoming jump from 0x0187, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0188 stack[-1] } 0188 80 DUP1 0189 63 PUSH4 0x0e297b45 018E 14 EQ 018F 61 PUSH2 0x02cf 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cf, if 0x0e297b45 == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x0e297b45 == stack[-1] // Inputs[1] { @0193 stack[-1] } 0193 80 DUP1 0194 63 PUSH4 0x23b872dd 0199 14 EQ 019A 61 PUSH2 0x033b 019D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033b, if 0x23b872dd == stack[-1] label_019E: // Incoming jump from 0x019D, if not 0x23b872dd == stack[-1] // Inputs[1] { @019E stack[-1] } 019E 80 DUP1 019F 63 PUSH4 0x28ed4f6c 01A4 14 EQ 01A5 61 PUSH2 0x03a9 01A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a9, if 0x28ed4f6c == stack[-1] label_01A9: // Incoming jump from 0x01A8, if not 0x28ed4f6c == stack[-1] // Incoming jump from 0x00D2 // Incoming jump from 0x0096 // Incoming jump from 0x013F // Incoming jump from 0x00F8 // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0165 // Incoming jump from 0x0070 // Inputs[1] { @01AD memory[0x00:0x00] } 01A9 5B JUMPDEST 01AA 60 PUSH1 0x00 01AC 80 DUP1 01AD FD *REVERT // Stack delta = +0 // Outputs[1] { @01AD revert(memory[0x00:0x00]); } // Block terminates label_01AE: // Incoming jump from 0x0171, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01B5 msg.data.length } 01AE 5B JUMPDEST 01AF 61 PUSH2 0x01f9 01B2 60 PUSH1 0x04 01B4 80 DUP1 01B5 36 CALLDATASIZE 01B6 03 SUB 01B7 60 PUSH1 0x20 01B9 81 DUP2 01BA 10 LT 01BB 15 ISZERO 01BC 61 PUSH2 0x01c4 01BF 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @01AF stack[0] = 0x01f9 // @01B2 stack[1] = 0x04 // @01B6 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01c4, returns to 0x01F9, if !(msg.data.length - 0x04 < 0x20) label_01C0: // Incoming jump from 0x01BF, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @01C3 memory[0x00:0x00] } 01C0 60 PUSH1 0x00 01C2 80 DUP1 01C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C3 revert(memory[0x00:0x00]); } // Block terminates label_01C4: // Incoming call from 0x01BF, returns to 0x01F9, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @01C5 stack[-2] // @01C6 stack[-1] // @01CA msg.data[stack[-2]:stack[-2] + 0x20] // } 01C4 5B JUMPDEST 01C5 81 DUP2 01C6 01 ADD 01C7 90 SWAP1 01C8 80 DUP1 01C9 80 DUP1 01CA 35 CALLDATALOAD 01CB 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 01E8 19 NOT 01E9 16 AND 01EA 90 SWAP1 01EB 60 PUSH1 0x20 01ED 01 ADD 01EE 90 SWAP1 01EF 92 SWAP3 01F0 91 SWAP2 01F1 90 SWAP1 01F2 50 POP 01F3 50 POP 01F4 50 POP 01F5 61 PUSH2 0x0aa4 01F8 56 *JUMP // Stack delta = -1 // Outputs[1] { @01EF stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0aa4 label_01F9: // Incoming return from call to 0x01C4 at 0x01BF // Inputs[4] // { // @01FC memory[0x40:0x60] // @01FE stack[-1] // @020D memory[0x40:0x60] // @0212 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01F9 5B JUMPDEST 01FA 60 PUSH1 0x40 01FC 51 MLOAD 01FD 80 DUP1 01FE 82 DUP3 01FF 15 ISZERO 0200 15 ISZERO 0201 15 ISZERO 0202 15 ISZERO 0203 81 DUP2 0204 52 MSTORE 0205 60 PUSH1 0x20 0207 01 ADD 0208 91 SWAP2 0209 50 POP 020A 50 POP 020B 60 PUSH1 0x40 020D 51 MLOAD 020E 80 DUP1 020F 91 SWAP2 0210 03 SUB 0211 90 SWAP1 0212 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0204 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0212 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0213: // Incoming jump from 0x017C, if 0x081812fc == stack[-1] // Inputs[1] { @021A msg.data.length } 0213 5B JUMPDEST 0214 61 PUSH2 0x023f 0217 60 PUSH1 0x04 0219 80 DUP1 021A 36 CALLDATASIZE 021B 03 SUB 021C 60 PUSH1 0x20 021E 81 DUP2 021F 10 LT 0220 15 ISZERO 0221 61 PUSH2 0x0229 0224 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0214 stack[0] = 0x023f // @0217 stack[1] = 0x04 // @021B stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0229, returns to 0x023F, if !(msg.data.length - 0x04 < 0x20) label_0225: // Incoming jump from 0x0224, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0228 memory[0x00:0x00] } 0225 60 PUSH1 0x00 0227 80 DUP1 0228 FD *REVERT // Stack delta = +0 // Outputs[1] { @0228 revert(memory[0x00:0x00]); } // Block terminates label_0229: // Incoming call from 0x0224, returns to 0x023F, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @022A stack[-2] // @022B stack[-1] // @022F msg.data[stack[-2]:stack[-2] + 0x20] // } 0229 5B JUMPDEST 022A 81 DUP2 022B 01 ADD 022C 90 SWAP1 022D 80 DUP1 022E 80 DUP1 022F 35 CALLDATALOAD 0230 90 SWAP1 0231 60 PUSH1 0x20 0233 01 ADD 0234 90 SWAP1 0235 92 SWAP3 0236 91 SWAP2 0237 90 SWAP1 0238 50 POP 0239 50 POP 023A 50 POP 023B 61 PUSH2 0x0d61 023E 56 *JUMP // Stack delta = -1 // Outputs[1] { @0235 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0d61 label_023F: // Incoming return from call to 0x0229 at 0x0224 // Inputs[4] // { // @0242 memory[0x40:0x60] // @0244 stack[-1] // @027B memory[0x40:0x60] // @0280 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 023F 5B JUMPDEST 0240 60 PUSH1 0x40 0242 51 MLOAD 0243 80 DUP1 0244 82 DUP3 0245 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 025A 16 AND 025B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0270 16 AND 0271 81 DUP2 0272 52 MSTORE 0273 60 PUSH1 0x20 0275 01 ADD 0276 91 SWAP2 0277 50 POP 0278 50 POP 0279 60 PUSH1 0x40 027B 51 MLOAD 027C 80 DUP1 027D 91 SWAP2 027E 03 SUB 027F 90 SWAP1 0280 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0272 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0280 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0281: // Incoming jump from 0x0187, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0288 msg.data.length } 0281 5B JUMPDEST 0282 61 PUSH2 0x02cd 0285 60 PUSH1 0x04 0287 80 DUP1 0288 36 CALLDATASIZE 0289 03 SUB 028A 60 PUSH1 0x40 028C 81 DUP2 028D 10 LT 028E 15 ISZERO 028F 61 PUSH2 0x0297 0292 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0282 stack[0] = 0x02cd // @0285 stack[1] = 0x04 // @0289 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0297, returns to 0x02CD, if !(msg.data.length - 0x04 < 0x40) label_0293: // Incoming jump from 0x0292, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0296 memory[0x00:0x00] } 0293 60 PUSH1 0x00 0295 80 DUP1 0296 FD *REVERT // Stack delta = +0 // Outputs[1] { @0296 revert(memory[0x00:0x00]); } // Block terminates label_0297: // Incoming call from 0x0292, returns to 0x02CD, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0298 stack[-2] // @0299 stack[-1] // @029D msg.data[stack[-2]:stack[-2] + 0x20] // @02BD msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0297 5B JUMPDEST 0298 81 DUP2 0299 01 ADD 029A 90 SWAP1 029B 80 DUP1 029C 80 DUP1 029D 35 CALLDATALOAD 029E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02B3 16 AND 02B4 90 SWAP1 02B5 60 PUSH1 0x20 02B7 01 ADD 02B8 90 SWAP1 02B9 92 SWAP3 02BA 91 SWAP2 02BB 90 SWAP1 02BC 80 DUP1 02BD 35 CALLDATALOAD 02BE 90 SWAP1 02BF 60 PUSH1 0x20 02C1 01 ADD 02C2 90 SWAP1 02C3 92 SWAP3 02C4 91 SWAP2 02C5 90 SWAP1 02C6 50 POP 02C7 50 POP 02C8 50 POP 02C9 61 PUSH2 0x0db0 02CC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02B9 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @02C3 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0db0 label_02CD: // Incoming return from call to 0x0297 at 0x0292 02CD 5B JUMPDEST 02CE 00 *STOP // Stack delta = +0 // Outputs[1] { @02CE stop(); } // Block terminates label_02CF: // Incoming jump from 0x0192, if 0x0e297b45 == stack[-1] // Inputs[1] { @02D6 msg.data.length } 02CF 5B JUMPDEST 02D0 61 PUSH2 0x0325 02D3 60 PUSH1 0x04 02D5 80 DUP1 02D6 36 CALLDATASIZE 02D7 03 SUB 02D8 60 PUSH1 0x60 02DA 81 DUP2 02DB 10 LT 02DC 15 ISZERO 02DD 61 PUSH2 0x02e5 02E0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @02D0 stack[0] = 0x0325 // @02D3 stack[1] = 0x04 // @02D7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02e5, returns to 0x0325, if !(msg.data.length - 0x04 < 0x60) label_02E1: // Incoming jump from 0x02E0, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @02E4 memory[0x00:0x00] } 02E1 60 PUSH1 0x00 02E3 80 DUP1 02E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02E4 revert(memory[0x00:0x00]); } // Block terminates label_02E5: // Incoming call from 0x02E0, returns to 0x0325, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @02E6 stack[-2] // @02E7 stack[-1] // @02EB msg.data[stack[-2]:stack[-2] + 0x20] // @02F5 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0315 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 02E5 5B JUMPDEST 02E6 81 DUP2 02E7 01 ADD 02E8 90 SWAP1 02E9 80 DUP1 02EA 80 DUP1 02EB 35 CALLDATALOAD 02EC 90 SWAP1 02ED 60 PUSH1 0x20 02EF 01 ADD 02F0 90 SWAP1 02F1 92 SWAP3 02F2 91 SWAP2 02F3 90 SWAP1 02F4 80 DUP1 02F5 35 CALLDATALOAD 02F6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 030B 16 AND 030C 90 SWAP1 030D 60 PUSH1 0x20 030F 01 ADD 0310 90 SWAP1 0311 92 SWAP3 0312 91 SWAP2 0313 90 SWAP1 0314 80 DUP1 0315 35 CALLDATALOAD 0316 90 SWAP1 0317 60 PUSH1 0x20 0319 01 ADD 031A 90 SWAP1 031B 92 SWAP3 031C 91 SWAP2 031D 90 SWAP1 031E 50 POP 031F 50 POP 0320 50 POP 0321 61 PUSH2 0x0ef1 0324 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @02F1 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0311 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @031B stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0ef1 label_0325: // Incoming return from call to 0x02E5 at 0x02E0 // Inputs[4] // { // @0328 memory[0x40:0x60] // @032A stack[-1] // @0335 memory[0x40:0x60] // @033A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0325 5B JUMPDEST 0326 60 PUSH1 0x40 0328 51 MLOAD 0329 80 DUP1 032A 82 DUP3 032B 81 DUP2 032C 52 MSTORE 032D 60 PUSH1 0x20 032F 01 ADD 0330 91 SWAP2 0331 50 POP 0332 50 POP 0333 60 PUSH1 0x40 0335 51 MLOAD 0336 80 DUP1 0337 91 SWAP2 0338 03 SUB 0339 90 SWAP1 033A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @032C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @033A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_033B: // Incoming jump from 0x019D, if 0x23b872dd == stack[-1] // Inputs[1] { @0342 msg.data.length } 033B 5B JUMPDEST 033C 61 PUSH2 0x03a7 033F 60 PUSH1 0x04 0341 80 DUP1 0342 36 CALLDATASIZE 0343 03 SUB 0344 60 PUSH1 0x60 0346 81 DUP2 0347 10 LT 0348 15 ISZERO 0349 61 PUSH2 0x0351 034C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @033C stack[0] = 0x03a7 // @033F stack[1] = 0x04 // @0343 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0351, returns to 0x03A7, if !(msg.data.length - 0x04 < 0x60) label_034D: // Incoming jump from 0x034C, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0350 memory[0x00:0x00] } 034D 60 PUSH1 0x00 034F 80 DUP1 0350 FD *REVERT // Stack delta = +0 // Outputs[1] { @0350 revert(memory[0x00:0x00]); } // Block terminates label_0351: // Incoming call from 0x034C, returns to 0x03A7, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0352 stack[-2] // @0353 stack[-1] // @0357 msg.data[stack[-2]:stack[-2] + 0x20] // @0377 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0397 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0351 5B JUMPDEST 0352 81 DUP2 0353 01 ADD 0354 90 SWAP1 0355 80 DUP1 0356 80 DUP1 0357 35 CALLDATALOAD 0358 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 036D 16 AND 036E 90 SWAP1 036F 60 PUSH1 0x20 0371 01 ADD 0372 90 SWAP1 0373 92 SWAP3 0374 91 SWAP2 0375 90 SWAP1 0376 80 DUP1 0377 35 CALLDATALOAD 0378 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 038D 16 AND 038E 90 SWAP1 038F 60 PUSH1 0x20 0391 01 ADD 0392 90 SWAP1 0393 92 SWAP3 0394 91 SWAP2 0395 90 SWAP1 0396 80 DUP1 0397 35 CALLDATALOAD 0398 90 SWAP1 0399 60 PUSH1 0x20 039B 01 ADD 039C 90 SWAP1 039D 92 SWAP3 039E 91 SWAP2 039F 90 SWAP1 03A0 50 POP 03A1 50 POP 03A2 50 POP 03A3 61 PUSH2 0x0f09 03A6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0373 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0393 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @039D stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0f09 label_03A7: // Incoming return from call to 0x0351 at 0x034C 03A7 5B JUMPDEST 03A8 00 *STOP // Stack delta = +0 // Outputs[1] { @03A8 stop(); } // Block terminates label_03A9: // Incoming jump from 0x01A8, if 0x28ed4f6c == stack[-1] // Inputs[1] { @03B0 msg.data.length } 03A9 5B JUMPDEST 03AA 61 PUSH2 0x03f5 03AD 60 PUSH1 0x04 03AF 80 DUP1 03B0 36 CALLDATASIZE 03B1 03 SUB 03B2 60 PUSH1 0x40 03B4 81 DUP2 03B5 10 LT 03B6 15 ISZERO 03B7 61 PUSH2 0x03bf 03BA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @03AA stack[0] = 0x03f5 // @03AD stack[1] = 0x04 // @03B1 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03bf, returns to 0x03F5, if !(msg.data.length - 0x04 < 0x40) label_03BB: // Incoming jump from 0x03BA, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03BE memory[0x00:0x00] } 03BB 60 PUSH1 0x00 03BD 80 DUP1 03BE FD *REVERT // Stack delta = +0 // Outputs[1] { @03BE revert(memory[0x00:0x00]); } // Block terminates label_03BF: // Incoming call from 0x03BA, returns to 0x03F5, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @03C0 stack[-2] // @03C1 stack[-1] // @03C5 msg.data[stack[-2]:stack[-2] + 0x20] // @03CF msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 03BF 5B JUMPDEST 03C0 81 DUP2 03C1 01 ADD 03C2 90 SWAP1 03C3 80 DUP1 03C4 80 DUP1 03C5 35 CALLDATALOAD 03C6 90 SWAP1 03C7 60 PUSH1 0x20 03C9 01 ADD 03CA 90 SWAP1 03CB 92 SWAP3 03CC 91 SWAP2 03CD 90 SWAP1 03CE 80 DUP1 03CF 35 CALLDATALOAD 03D0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03E5 16 AND 03E6 90 SWAP1 03E7 60 PUSH1 0x20 03E9 01 ADD 03EA 90 SWAP1 03EB 92 SWAP3 03EC 91 SWAP2 03ED 90 SWAP1 03EE 50 POP 03EF 50 POP 03F0 50 POP 03F1 61 PUSH2 0x0f2c 03F4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03CB stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @03EB stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0f2c label_03F5: // Incoming return from call to 0x03BF at 0x03BA 03F5 5B JUMPDEST 03F6 00 *STOP // Stack delta = +0 // Outputs[1] { @03F6 stop(); } // Block terminates label_03F7: // Incoming jump from 0x014B, if 0x3f15457f == stack[-1] 03F7 5B JUMPDEST 03F8 61 PUSH2 0x03ff 03FB 61 PUSH2 0x111c 03FE 56 *JUMP // Stack delta = +1 // Outputs[1] { @03F8 stack[0] = 0x03ff } // Block ends with call to 0x111c, returns to 0x03FF label_03FF: // Incoming return from call to 0x111C at 0x03FE // Inputs[4] // { // @0402 memory[0x40:0x60] // @0404 stack[-1] // @043B memory[0x40:0x60] // @0440 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 03FF 5B JUMPDEST 0400 60 PUSH1 0x40 0402 51 MLOAD 0403 80 DUP1 0404 82 DUP3 0405 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 041A 16 AND 041B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0430 16 AND 0431 81 DUP2 0432 52 MSTORE 0433 60 PUSH1 0x20 0435 01 ADD 0436 91 SWAP2 0437 50 POP 0438 50 POP 0439 60 PUSH1 0x40 043B 51 MLOAD 043C 80 DUP1 043D 91 SWAP2 043E 03 SUB 043F 90 SWAP1 0440 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0432 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0440 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0441: // Incoming jump from 0x0156, if 0x42842e0e == stack[-1] // Inputs[1] { @0448 msg.data.length } 0441 5B JUMPDEST 0442 61 PUSH2 0x04ad 0445 60 PUSH1 0x04 0447 80 DUP1 0448 36 CALLDATASIZE 0449 03 SUB 044A 60 PUSH1 0x60 044C 81 DUP2 044D 10 LT 044E 15 ISZERO 044F 61 PUSH2 0x0457 0452 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0442 stack[0] = 0x04ad // @0445 stack[1] = 0x04 // @0449 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0457, returns to 0x04AD, if !(msg.data.length - 0x04 < 0x60) label_0453: // Incoming jump from 0x0452, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0456 memory[0x00:0x00] } 0453 60 PUSH1 0x00 0455 80 DUP1 0456 FD *REVERT // Stack delta = +0 // Outputs[1] { @0456 revert(memory[0x00:0x00]); } // Block terminates label_0457: // Incoming call from 0x0452, returns to 0x04AD, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0458 stack[-2] // @0459 stack[-1] // @045D msg.data[stack[-2]:stack[-2] + 0x20] // @047D msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @049D msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0457 5B JUMPDEST 0458 81 DUP2 0459 01 ADD 045A 90 SWAP1 045B 80 DUP1 045C 80 DUP1 045D 35 CALLDATALOAD 045E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0473 16 AND 0474 90 SWAP1 0475 60 PUSH1 0x20 0477 01 ADD 0478 90 SWAP1 0479 92 SWAP3 047A 91 SWAP2 047B 90 SWAP1 047C 80 DUP1 047D 35 CALLDATALOAD 047E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0493 16 AND 0494 90 SWAP1 0495 60 PUSH1 0x20 0497 01 ADD 0498 90 SWAP1 0499 92 SWAP3 049A 91 SWAP2 049B 90 SWAP1 049C 80 DUP1 049D 35 CALLDATALOAD 049E 90 SWAP1 049F 60 PUSH1 0x20 04A1 01 ADD 04A2 90 SWAP1 04A3 92 SWAP3 04A4 91 SWAP2 04A5 90 SWAP1 04A6 50 POP 04A7 50 POP 04A8 50 POP 04A9 61 PUSH2 0x1142 04AC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0479 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0499 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @04A3 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1142 label_04AD: // Incoming return from call to 0x0457 at 0x0452 04AD 5B JUMPDEST 04AE 00 *STOP // Stack delta = +0 // Outputs[1] { @04AE stop(); } // Block terminates label_04AF: // Incoming jump from 0x0161, if 0x4e543b26 == stack[-1] // Inputs[1] { @04B6 msg.data.length } 04AF 5B JUMPDEST 04B0 61 PUSH2 0x04f1 04B3 60 PUSH1 0x04 04B5 80 DUP1 04B6 36 CALLDATASIZE 04B7 03 SUB 04B8 60 PUSH1 0x20 04BA 81 DUP2 04BB 10 LT 04BC 15 ISZERO 04BD 61 PUSH2 0x04c5 04C0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04B0 stack[0] = 0x04f1 // @04B3 stack[1] = 0x04 // @04B7 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04c5, returns to 0x04F1, if !(msg.data.length - 0x04 < 0x20) label_04C1: // Incoming jump from 0x04C0, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04C4 memory[0x00:0x00] } 04C1 60 PUSH1 0x00 04C3 80 DUP1 04C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C4 revert(memory[0x00:0x00]); } // Block terminates label_04C5: // Incoming call from 0x04C0, returns to 0x04F1, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @04C6 stack[-2] // @04C7 stack[-1] // @04CB msg.data[stack[-2]:stack[-2] + 0x20] // } 04C5 5B JUMPDEST 04C6 81 DUP2 04C7 01 ADD 04C8 90 SWAP1 04C9 80 DUP1 04CA 80 DUP1 04CB 35 CALLDATALOAD 04CC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04E1 16 AND 04E2 90 SWAP1 04E3 60 PUSH1 0x20 04E5 01 ADD 04E6 90 SWAP1 04E7 92 SWAP3 04E8 91 SWAP2 04E9 90 SWAP1 04EA 50 POP 04EB 50 POP 04EC 50 POP 04ED 61 PUSH2 0x1162 04F0 56 *JUMP // Stack delta = -1 // Outputs[1] { @04E7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1162 label_04F1: // Incoming return from call to 0x04C5 at 0x04C0 04F1 5B JUMPDEST 04F2 00 *STOP // Stack delta = +0 // Outputs[1] { @04F2 stop(); } // Block terminates label_04F3: // Incoming jump from 0x011A, if 0x6352211e == stack[-1] // Inputs[1] { @04FA msg.data.length } 04F3 5B JUMPDEST 04F4 61 PUSH2 0x051f 04F7 60 PUSH1 0x04 04F9 80 DUP1 04FA 36 CALLDATASIZE 04FB 03 SUB 04FC 60 PUSH1 0x20 04FE 81 DUP2 04FF 10 LT 0500 15 ISZERO 0501 61 PUSH2 0x0509 0504 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04F4 stack[0] = 0x051f // @04F7 stack[1] = 0x04 // @04FB stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0509, returns to 0x051F, if !(msg.data.length - 0x04 < 0x20) label_0505: // Incoming jump from 0x0504, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0508 memory[0x00:0x00] } 0505 60 PUSH1 0x00 0507 80 DUP1 0508 FD *REVERT // Stack delta = +0 // Outputs[1] { @0508 revert(memory[0x00:0x00]); } // Block terminates label_0509: // Incoming call from 0x0504, returns to 0x051F, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @050A stack[-2] // @050B stack[-1] // @050F msg.data[stack[-2]:stack[-2] + 0x20] // } 0509 5B JUMPDEST 050A 81 DUP2 050B 01 ADD 050C 90 SWAP1 050D 80 DUP1 050E 80 DUP1 050F 35 CALLDATALOAD 0510 90 SWAP1 0511 60 PUSH1 0x20 0513 01 ADD 0514 90 SWAP1 0515 92 SWAP3 0516 91 SWAP2 0517 90 SWAP1 0518 50 POP 0519 50 POP 051A 50 POP 051B 61 PUSH2 0x1239 051E 56 *JUMP // Stack delta = -1 // Outputs[1] { @0515 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1239 label_051F: // Incoming return from call to 0x0509 at 0x0504 // Inputs[4] // { // @0522 memory[0x40:0x60] // @0524 stack[-1] // @055B memory[0x40:0x60] // @0560 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 051F 5B JUMPDEST 0520 60 PUSH1 0x40 0522 51 MLOAD 0523 80 DUP1 0524 82 DUP3 0525 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 053A 16 AND 053B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0550 16 AND 0551 81 DUP2 0552 52 MSTORE 0553 60 PUSH1 0x20 0555 01 ADD 0556 91 SWAP2 0557 50 POP 0558 50 POP 0559 60 PUSH1 0x40 055B 51 MLOAD 055C 80 DUP1 055D 91 SWAP2 055E 03 SUB 055F 90 SWAP1 0560 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0552 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0560 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0561: // Incoming jump from 0x0125, if 0x70a08231 == stack[-1] // Inputs[1] { @0568 msg.data.length } 0561 5B JUMPDEST 0562 61 PUSH2 0x05a3 0565 60 PUSH1 0x04 0567 80 DUP1 0568 36 CALLDATASIZE 0569 03 SUB 056A 60 PUSH1 0x20 056C 81 DUP2 056D 10 LT 056E 15 ISZERO 056F 61 PUSH2 0x0577 0572 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0562 stack[0] = 0x05a3 // @0565 stack[1] = 0x04 // @0569 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0577, returns to 0x05A3, if !(msg.data.length - 0x04 < 0x20) label_0573: // Incoming jump from 0x0572, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0576 memory[0x00:0x00] } 0573 60 PUSH1 0x00 0575 80 DUP1 0576 FD *REVERT // Stack delta = +0 // Outputs[1] { @0576 revert(memory[0x00:0x00]); } // Block terminates label_0577: // Incoming call from 0x0572, returns to 0x05A3, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0578 stack[-2] // @0579 stack[-1] // @057D msg.data[stack[-2]:stack[-2] + 0x20] // } 0577 5B JUMPDEST 0578 81 DUP2 0579 01 ADD 057A 90 SWAP1 057B 80 DUP1 057C 80 DUP1 057D 35 CALLDATALOAD 057E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0593 16 AND 0594 90 SWAP1 0595 60 PUSH1 0x20 0597 01 ADD 0598 90 SWAP1 0599 92 SWAP3 059A 91 SWAP2 059B 90 SWAP1 059C 50 POP 059D 50 POP 059E 50 POP 059F 61 PUSH2 0x126a 05A2 56 *JUMP // Stack delta = -1 // Outputs[1] { @0599 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x126a label_05A3: // Incoming return from call to 0x0577 at 0x0572 // Inputs[4] // { // @05A6 memory[0x40:0x60] // @05A8 stack[-1] // @05B3 memory[0x40:0x60] // @05B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05A3 5B JUMPDEST 05A4 60 PUSH1 0x40 05A6 51 MLOAD 05A7 80 DUP1 05A8 82 DUP3 05A9 81 DUP2 05AA 52 MSTORE 05AB 60 PUSH1 0x20 05AD 01 ADD 05AE 91 SWAP2 05AF 50 POP 05B0 50 POP 05B1 60 PUSH1 0x40 05B3 51 MLOAD 05B4 80 DUP1 05B5 91 SWAP2 05B6 03 SUB 05B7 90 SWAP1 05B8 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @05B8 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_05B9: // Incoming jump from 0x0130, if 0x715018a6 == stack[-1] 05B9 5B JUMPDEST 05BA 61 PUSH2 0x05c1 05BD 61 PUSH2 0x12ec 05C0 56 *JUMP // Stack delta = +1 // Outputs[1] { @05BA stack[0] = 0x05c1 } // Block ends with call to 0x12ec, returns to 0x05C1 label_05C1: // Incoming return from call to 0x12EC at 0x05C0 05C1 5B JUMPDEST 05C2 00 *STOP // Stack delta = +0 // Outputs[1] { @05C2 stop(); } // Block terminates label_05C3: // Incoming jump from 0x013B, if 0x8da5cb5b == stack[-1] 05C3 5B JUMPDEST 05C4 61 PUSH2 0x05cb 05C7 61 PUSH2 0x13be 05CA 56 *JUMP // Stack delta = +1 // Outputs[1] { @05C4 stack[0] = 0x05cb } // Block ends with call to 0x13be, returns to 0x05CB label_05CB: // Incoming return from call to 0x13BE at 0x05CA // Inputs[4] // { // @05CE memory[0x40:0x60] // @05D0 stack[-1] // @0607 memory[0x40:0x60] // @060C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 05CB 5B JUMPDEST 05CC 60 PUSH1 0x40 05CE 51 MLOAD 05CF 80 DUP1 05D0 82 DUP3 05D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05E6 16 AND 05E7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05FC 16 AND 05FD 81 DUP2 05FE 52 MSTORE 05FF 60 PUSH1 0x20 0601 01 ADD 0602 91 SWAP2 0603 50 POP 0604 50 POP 0605 60 PUSH1 0x40 0607 51 MLOAD 0608 80 DUP1 0609 91 SWAP2 060A 03 SUB 060B 90 SWAP1 060C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @05FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @060C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_060D: // Incoming jump from 0x00DE, if 0x8f32d59b == stack[-1] 060D 5B JUMPDEST 060E 61 PUSH2 0x0615 0611 61 PUSH2 0x13e8 0614 56 *JUMP // Stack delta = +1 // Outputs[1] { @060E stack[0] = 0x0615 } // Block ends with call to 0x13e8, returns to 0x0615 label_0615: // Incoming return from call to 0x13E8 at 0x0614 // Inputs[4] // { // @0618 memory[0x40:0x60] // @061A stack[-1] // @0629 memory[0x40:0x60] // @062E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0615 5B JUMPDEST 0616 60 PUSH1 0x40 0618 51 MLOAD 0619 80 DUP1 061A 82 DUP3 061B 15 ISZERO 061C 15 ISZERO 061D 15 ISZERO 061E 15 ISZERO 061F 81 DUP2 0620 52 MSTORE 0621 60 PUSH1 0x20 0623 01 ADD 0624 91 SWAP2 0625 50 POP 0626 50 POP 0627 60 PUSH1 0x40 0629 51 MLOAD 062A 80 DUP1 062B 91 SWAP2 062C 03 SUB 062D 90 SWAP1 062E F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0620 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @062E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_062F: // Incoming jump from 0x00E9, if 0x96e494e8 == stack[-1] // Inputs[1] { @0636 msg.data.length } 062F 5B JUMPDEST 0630 61 PUSH2 0x065b 0633 60 PUSH1 0x04 0635 80 DUP1 0636 36 CALLDATASIZE 0637 03 SUB 0638 60 PUSH1 0x20 063A 81 DUP2 063B 10 LT 063C 15 ISZERO 063D 61 PUSH2 0x0645 0640 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0630 stack[0] = 0x065b // @0633 stack[1] = 0x04 // @0637 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0645, returns to 0x065B, if !(msg.data.length - 0x04 < 0x20) label_0641: // Incoming jump from 0x0640, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0644 memory[0x00:0x00] } 0641 60 PUSH1 0x00 0643 80 DUP1 0644 FD *REVERT // Stack delta = +0 // Outputs[1] { @0644 revert(memory[0x00:0x00]); } // Block terminates label_0645: // Incoming call from 0x0640, returns to 0x065B, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0646 stack[-2] // @0647 stack[-1] // @064B msg.data[stack[-2]:stack[-2] + 0x20] // } 0645 5B JUMPDEST 0646 81 DUP2 0647 01 ADD 0648 90 SWAP1 0649 80 DUP1 064A 80 DUP1 064B 35 CALLDATALOAD 064C 90 SWAP1 064D 60 PUSH1 0x20 064F 01 ADD 0650 90 SWAP1 0651 92 SWAP3 0652 91 SWAP2 0653 90 SWAP1 0654 50 POP 0655 50 POP 0656 50 POP 0657 61 PUSH2 0x1440 065A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0651 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1440 label_065B: // Incoming return from call to 0x0645 at 0x0640 // Inputs[4] // { // @065E memory[0x40:0x60] // @0660 stack[-1] // @066F memory[0x40:0x60] // @0674 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 065B 5B JUMPDEST 065C 60 PUSH1 0x40 065E 51 MLOAD 065F 80 DUP1 0660 82 DUP3 0661 15 ISZERO 0662 15 ISZERO 0663 15 ISZERO 0664 15 ISZERO 0665 81 DUP2 0666 52 MSTORE 0667 60 PUSH1 0x20 0669 01 ADD 066A 91 SWAP2 066B 50 POP 066C 50 POP 066D 60 PUSH1 0x40 066F 51 MLOAD 0670 80 DUP1 0671 91 SWAP2 0672 03 SUB 0673 90 SWAP1 0674 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0666 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0674 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0675: // Incoming jump from 0x00F4, if 0xa22cb465 == stack[-1] // Inputs[1] { @067C msg.data.length } 0675 5B JUMPDEST 0676 61 PUSH2 0x06c3 0679 60 PUSH1 0x04 067B 80 DUP1 067C 36 CALLDATASIZE 067D 03 SUB 067E 60 PUSH1 0x40 0680 81 DUP2 0681 10 LT 0682 15 ISZERO 0683 61 PUSH2 0x068b 0686 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0676 stack[0] = 0x06c3 // @0679 stack[1] = 0x04 // @067D stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x068b, returns to 0x06C3, if !(msg.data.length - 0x04 < 0x40) label_0687: // Incoming jump from 0x0686, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @068A memory[0x00:0x00] } 0687 60 PUSH1 0x00 0689 80 DUP1 068A FD *REVERT // Stack delta = +0 // Outputs[1] { @068A revert(memory[0x00:0x00]); } // Block terminates label_068B: // Incoming call from 0x0686, returns to 0x06C3, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @068C stack[-2] // @068D stack[-1] // @0691 msg.data[stack[-2]:stack[-2] + 0x20] // @06B1 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 068B 5B JUMPDEST 068C 81 DUP2 068D 01 ADD 068E 90 SWAP1 068F 80 DUP1 0690 80 DUP1 0691 35 CALLDATALOAD 0692 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06A7 16 AND 06A8 90 SWAP1 06A9 60 PUSH1 0x20 06AB 01 ADD 06AC 90 SWAP1 06AD 92 SWAP3 06AE 91 SWAP2 06AF 90 SWAP1 06B0 80 DUP1 06B1 35 CALLDATALOAD 06B2 15 ISZERO 06B3 15 ISZERO 06B4 90 SWAP1 06B5 60 PUSH1 0x20 06B7 01 ADD 06B8 90 SWAP1 06B9 92 SWAP3 06BA 91 SWAP2 06BB 90 SWAP1 06BC 50 POP 06BD 50 POP 06BE 50 POP 06BF 61 PUSH2 0x1464 06C2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @06AD stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @06B9 stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1464 label_06C3: // Incoming return from call to 0x068B at 0x0686 06C3 5B JUMPDEST 06C4 00 *STOP // Stack delta = +0 // Outputs[1] { @06C4 stop(); } // Block terminates label_06C5: // Incoming jump from 0x00AD, if 0xa7fc7a07 == stack[-1] // Inputs[1] { @06CC msg.data.length } 06C5 5B JUMPDEST 06C6 61 PUSH2 0x0707 06C9 60 PUSH1 0x04 06CB 80 DUP1 06CC 36 CALLDATASIZE 06CD 03 SUB 06CE 60 PUSH1 0x20 06D0 81 DUP2 06D1 10 LT 06D2 15 ISZERO 06D3 61 PUSH2 0x06db 06D6 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06C6 stack[0] = 0x0707 // @06C9 stack[1] = 0x04 // @06CD stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06db, returns to 0x0707, if !(msg.data.length - 0x04 < 0x20) label_06D7: // Incoming jump from 0x06D6, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06DA memory[0x00:0x00] } 06D7 60 PUSH1 0x00 06D9 80 DUP1 06DA FD *REVERT // Stack delta = +0 // Outputs[1] { @06DA revert(memory[0x00:0x00]); } // Block terminates label_06DB: // Incoming call from 0x06D6, returns to 0x0707, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @06DC stack[-2] // @06DD stack[-1] // @06E1 msg.data[stack[-2]:stack[-2] + 0x20] // } 06DB 5B JUMPDEST 06DC 81 DUP2 06DD 01 ADD 06DE 90 SWAP1 06DF 80 DUP1 06E0 80 DUP1 06E1 35 CALLDATALOAD 06E2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06F7 16 AND 06F8 90 SWAP1 06F9 60 PUSH1 0x20 06FB 01 ADD 06FC 90 SWAP1 06FD 92 SWAP3 06FE 91 SWAP2 06FF 90 SWAP1 0700 50 POP 0701 50 POP 0702 50 POP 0703 61 PUSH2 0x159e 0706 56 *JUMP // Stack delta = -1 // Outputs[1] { @06FD stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x159e label_0707: // Incoming return from call to 0x06DB at 0x06D6 0707 5B JUMPDEST 0708 00 *STOP // Stack delta = +0 // Outputs[1] { @0708 stop(); } // Block terminates label_0709: // Incoming jump from 0x00B8, if 0xb88d4fde == stack[-1] // Inputs[1] { @0710 msg.data.length } 0709 5B JUMPDEST 070A 61 PUSH2 0x080c 070D 60 PUSH1 0x04 070F 80 DUP1 0710 36 CALLDATASIZE 0711 03 SUB 0712 60 PUSH1 0x80 0714 81 DUP2 0715 10 LT 0716 15 ISZERO 0717 61 PUSH2 0x071f 071A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @070A stack[0] = 0x080c // @070D stack[1] = 0x04 // @0711 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x071f, returns to 0x080C, if !(msg.data.length - 0x04 < 0x80) label_071B: // Incoming jump from 0x071A, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @071E memory[0x00:0x00] } 071B 60 PUSH1 0x00 071D 80 DUP1 071E FD *REVERT // Stack delta = +0 // Outputs[1] { @071E revert(memory[0x00:0x00]); } // Block terminates label_071F: // Incoming call from 0x071A, returns to 0x080C, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @0720 stack[-2] // @0721 stack[-1] // @0725 msg.data[stack[-2]:stack[-2] + 0x20] // @0745 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0765 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @076F msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // } 071F 5B JUMPDEST 0720 81 DUP2 0721 01 ADD 0722 90 SWAP1 0723 80 DUP1 0724 80 DUP1 0725 35 CALLDATALOAD 0726 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 073B 16 AND 073C 90 SWAP1 073D 60 PUSH1 0x20 073F 01 ADD 0740 90 SWAP1 0741 92 SWAP3 0742 91 SWAP2 0743 90 SWAP1 0744 80 DUP1 0745 35 CALLDATALOAD 0746 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 075B 16 AND 075C 90 SWAP1 075D 60 PUSH1 0x20 075F 01 ADD 0760 90 SWAP1 0761 92 SWAP3 0762 91 SWAP2 0763 90 SWAP1 0764 80 DUP1 0765 35 CALLDATALOAD 0766 90 SWAP1 0767 60 PUSH1 0x20 0769 01 ADD 076A 90 SWAP1 076B 92 SWAP3 076C 91 SWAP2 076D 90 SWAP1 076E 80 DUP1 076F 35 CALLDATALOAD 0770 90 SWAP1 0771 60 PUSH1 0x20 0773 01 ADD 0774 90 SWAP1 0775 64 PUSH5 0x0100000000 077B 81 DUP2 077C 11 GT 077D 15 ISZERO 077E 61 PUSH2 0x0786 0781 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0741 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0761 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @076B stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @076C stack[1] = stack[-2] + stack[-1] // @076D stack[2] = stack[-2] // @0774 stack[4] = msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // @0774 stack[3] = 0x20 + 0x20 + 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0786, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) label_0782: // Incoming jump from 0x0781, if not !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0785 memory[0x00:0x00] } 0782 60 PUSH1 0x00 0784 80 DUP1 0785 FD *REVERT // Stack delta = +0 // Outputs[1] { @0785 revert(memory[0x00:0x00]); } // Block terminates label_0786: // Incoming jump from 0x0781, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0787 stack[-3] // @0788 stack[-1] // @0789 stack[-4] // } 0786 5B JUMPDEST 0787 82 DUP3 0788 01 ADD 0789 83 DUP4 078A 60 PUSH1 0x20 078C 82 DUP3 078D 01 ADD 078E 11 GT 078F 15 ISZERO 0790 61 PUSH2 0x0798 0793 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0788 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0798, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0794: // Incoming jump from 0x0793, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0797 memory[0x00:0x00] } 0794 60 PUSH1 0x00 0796 80 DUP1 0797 FD *REVERT // Stack delta = +0 // Outputs[1] { @0797 revert(memory[0x00:0x00]); } // Block terminates label_0798: // Incoming jump from 0x0793, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0799 stack[-1] // @079A msg.data[stack[-1]:stack[-1] + 0x20] // @079F stack[-2] // @07A0 stack[-4] // } 0798 5B JUMPDEST 0799 80 DUP1 079A 35 CALLDATALOAD 079B 90 SWAP1 079C 60 PUSH1 0x20 079E 01 ADD 079F 91 SWAP2 07A0 84 DUP5 07A1 60 PUSH1 0x01 07A3 83 DUP4 07A4 02 MUL 07A5 84 DUP5 07A6 01 ADD 07A7 11 GT 07A8 64 PUSH5 0x0100000000 07AE 83 DUP4 07AF 11 GT 07B0 17 OR 07B1 15 ISZERO 07B2 61 PUSH2 0x07ba 07B5 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @079B stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @079F stack[0] = stack[-2] // @079F stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x07ba, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_07B6: // Incoming jump from 0x07B5, 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] { @07B9 memory[0x00:0x00] } 07B6 60 PUSH1 0x00 07B8 80 DUP1 07B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B9 revert(memory[0x00:0x00]); } // Block terminates label_07BA: // Incoming jump from 0x07B5, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @07BB stack[-1] // @07BB stack[-3] // @07BC stack[-2] // @07CD memory[0x40:0x60] // @07E4 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0800 stack[-4] // @0801 stack[-5] // } 07BA 5B JUMPDEST 07BB 91 SWAP2 07BC 90 SWAP1 07BD 80 DUP1 07BE 80 DUP1 07BF 60 PUSH1 0x1f 07C1 01 ADD 07C2 60 PUSH1 0x20 07C4 80 DUP1 07C5 91 SWAP2 07C6 04 DIV 07C7 02 MUL 07C8 60 PUSH1 0x20 07CA 01 ADD 07CB 60 PUSH1 0x40 07CD 51 MLOAD 07CE 90 SWAP1 07CF 81 DUP2 07D0 01 ADD 07D1 60 PUSH1 0x40 07D3 52 MSTORE 07D4 80 DUP1 07D5 93 SWAP4 07D6 92 SWAP3 07D7 91 SWAP2 07D8 90 SWAP1 07D9 81 DUP2 07DA 81 DUP2 07DB 52 MSTORE 07DC 60 PUSH1 0x20 07DE 01 ADD 07DF 83 DUP4 07E0 83 DUP4 07E1 80 DUP1 07E2 82 DUP3 07E3 84 DUP5 07E4 37 CALLDATACOPY 07E5 60 PUSH1 0x00 07E7 81 DUP2 07E8 84 DUP5 07E9 01 ADD 07EA 52 MSTORE 07EB 60 PUSH1 0x1f 07ED 19 NOT 07EE 60 PUSH1 0x1f 07F0 82 DUP3 07F1 01 ADD 07F2 16 AND 07F3 90 SWAP1 07F4 50 POP 07F5 80 DUP1 07F6 83 DUP4 07F7 01 ADD 07F8 92 SWAP3 07F9 50 POP 07FA 50 POP 07FB 50 POP 07FC 50 POP 07FD 50 POP 07FE 50 POP 07FF 50 POP 0800 91 SWAP2 0801 92 SWAP3 0802 91 SWAP2 0803 92 SWAP3 0804 90 SWAP1 0805 50 POP 0806 50 POP 0807 50 POP 0808 61 PUSH2 0x164d 080B 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @07D3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @07DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @07E4 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @07EA memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0803 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x164d label_080C: // Incoming return from call to 0x071F at 0x071A 080C 5B JUMPDEST 080D 00 *STOP // Stack delta = +0 // Outputs[1] { @080D stop(); } // Block terminates label_080E: // Incoming jump from 0x00C3, if 0xc1a287e2 == stack[-1] 080E 5B JUMPDEST 080F 61 PUSH2 0x0816 0812 61 PUSH2 0x1673 0815 56 *JUMP // Stack delta = +1 // Outputs[1] { @080F stack[0] = 0x0816 } // Block ends with call to 0x1673, returns to 0x0816 label_0816: // Incoming return from call to 0x1673 at 0x0815 // Inputs[4] // { // @0819 memory[0x40:0x60] // @081B stack[-1] // @0826 memory[0x40:0x60] // @082B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0816 5B JUMPDEST 0817 60 PUSH1 0x40 0819 51 MLOAD 081A 80 DUP1 081B 82 DUP3 081C 81 DUP2 081D 52 MSTORE 081E 60 PUSH1 0x20 0820 01 ADD 0821 91 SWAP2 0822 50 POP 0823 50 POP 0824 60 PUSH1 0x40 0826 51 MLOAD 0827 80 DUP1 0828 91 SWAP2 0829 03 SUB 082A 90 SWAP1 082B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @081D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @082B return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_082C: // Incoming jump from 0x00CE, if 0xc475abff == stack[-1] // Inputs[1] { @0833 msg.data.length } 082C 5B JUMPDEST 082D 61 PUSH2 0x0862 0830 60 PUSH1 0x04 0832 80 DUP1 0833 36 CALLDATASIZE 0834 03 SUB 0835 60 PUSH1 0x40 0837 81 DUP2 0838 10 LT 0839 15 ISZERO 083A 61 PUSH2 0x0842 083D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @082D stack[0] = 0x0862 // @0830 stack[1] = 0x04 // @0834 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0842, returns to 0x0862, if !(msg.data.length - 0x04 < 0x40) label_083E: // Incoming jump from 0x083D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0841 memory[0x00:0x00] } 083E 60 PUSH1 0x00 0840 80 DUP1 0841 FD *REVERT // Stack delta = +0 // Outputs[1] { @0841 revert(memory[0x00:0x00]); } // Block terminates label_0842: // Incoming call from 0x083D, returns to 0x0862, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0843 stack[-2] // @0844 stack[-1] // @0848 msg.data[stack[-2]:stack[-2] + 0x20] // @0852 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0842 5B JUMPDEST 0843 81 DUP2 0844 01 ADD 0845 90 SWAP1 0846 80 DUP1 0847 80 DUP1 0848 35 CALLDATALOAD 0849 90 SWAP1 084A 60 PUSH1 0x20 084C 01 ADD 084D 90 SWAP1 084E 92 SWAP3 084F 91 SWAP2 0850 90 SWAP1 0851 80 DUP1 0852 35 CALLDATALOAD 0853 90 SWAP1 0854 60 PUSH1 0x20 0856 01 ADD 0857 90 SWAP1 0858 92 SWAP3 0859 91 SWAP2 085A 90 SWAP1 085B 50 POP 085C 50 POP 085D 50 POP 085E 61 PUSH2 0x167a 0861 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @084E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0858 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x167a label_0862: // Incoming return from call to 0x0842 at 0x083D // Inputs[4] // { // @0865 memory[0x40:0x60] // @0867 stack[-1] // @0872 memory[0x40:0x60] // @0877 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0862 5B JUMPDEST 0863 60 PUSH1 0x40 0865 51 MLOAD 0866 80 DUP1 0867 82 DUP3 0868 81 DUP2 0869 52 MSTORE 086A 60 PUSH1 0x20 086C 01 ADD 086D 91 SWAP2 086E 50 POP 086F 50 POP 0870 60 PUSH1 0x40 0872 51 MLOAD 0873 80 DUP1 0874 91 SWAP2 0875 03 SUB 0876 90 SWAP1 0877 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0869 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0877 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0878: // Incoming jump from 0x007C, if 0xd6e4fa86 == stack[-1] // Inputs[1] { @087F msg.data.length } 0878 5B JUMPDEST 0879 61 PUSH2 0x08a4 087C 60 PUSH1 0x04 087E 80 DUP1 087F 36 CALLDATASIZE 0880 03 SUB 0881 60 PUSH1 0x20 0883 81 DUP2 0884 10 LT 0885 15 ISZERO 0886 61 PUSH2 0x088e 0889 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0879 stack[0] = 0x08a4 // @087C stack[1] = 0x04 // @0880 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x088e, returns to 0x08A4, if !(msg.data.length - 0x04 < 0x20) label_088A: // Incoming jump from 0x0889, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @088D memory[0x00:0x00] } 088A 60 PUSH1 0x00 088C 80 DUP1 088D FD *REVERT // Stack delta = +0 // Outputs[1] { @088D revert(memory[0x00:0x00]); } // Block terminates label_088E: // Incoming call from 0x0889, returns to 0x08A4, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @088F stack[-2] // @0890 stack[-1] // @0894 msg.data[stack[-2]:stack[-2] + 0x20] // } 088E 5B JUMPDEST 088F 81 DUP2 0890 01 ADD 0891 90 SWAP1 0892 80 DUP1 0893 80 DUP1 0894 35 CALLDATALOAD 0895 90 SWAP1 0896 60 PUSH1 0x20 0898 01 ADD 0899 90 SWAP1 089A 92 SWAP3 089B 91 SWAP2 089C 90 SWAP1 089D 50 POP 089E 50 POP 089F 50 POP 08A0 61 PUSH2 0x1891 08A3 56 *JUMP // Stack delta = -1 // Outputs[1] { @089A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1891 label_08A4: // Incoming return from call to 0x088E at 0x0889 // Inputs[4] // { // @08A7 memory[0x40:0x60] // @08A9 stack[-1] // @08B4 memory[0x40:0x60] // @08B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08A4 5B JUMPDEST 08A5 60 PUSH1 0x40 08A7 51 MLOAD 08A8 80 DUP1 08A9 82 DUP3 08AA 81 DUP2 08AB 52 MSTORE 08AC 60 PUSH1 0x20 08AE 01 ADD 08AF 91 SWAP2 08B0 50 POP 08B1 50 POP 08B2 60 PUSH1 0x40 08B4 51 MLOAD 08B5 80 DUP1 08B6 91 SWAP2 08B7 03 SUB 08B8 90 SWAP1 08B9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @08AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @08B9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_08BA: // Incoming jump from 0x0087, if 0xda8c229e == stack[-1] // Inputs[1] { @08C1 msg.data.length } 08BA 5B JUMPDEST 08BB 61 PUSH2 0x08fc 08BE 60 PUSH1 0x04 08C0 80 DUP1 08C1 36 CALLDATASIZE 08C2 03 SUB 08C3 60 PUSH1 0x20 08C5 81 DUP2 08C6 10 LT 08C7 15 ISZERO 08C8 61 PUSH2 0x08d0 08CB 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08BB stack[0] = 0x08fc // @08BE stack[1] = 0x04 // @08C2 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08d0, returns to 0x08FC, if !(msg.data.length - 0x04 < 0x20) label_08CC: // Incoming jump from 0x08CB, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @08CF memory[0x00:0x00] } 08CC 60 PUSH1 0x00 08CE 80 DUP1 08CF FD *REVERT // Stack delta = +0 // Outputs[1] { @08CF revert(memory[0x00:0x00]); } // Block terminates label_08D0: // Incoming call from 0x08CB, returns to 0x08FC, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @08D1 stack[-2] // @08D2 stack[-1] // @08D6 msg.data[stack[-2]:stack[-2] + 0x20] // } 08D0 5B JUMPDEST 08D1 81 DUP2 08D2 01 ADD 08D3 90 SWAP1 08D4 80 DUP1 08D5 80 DUP1 08D6 35 CALLDATALOAD 08D7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08EC 16 AND 08ED 90 SWAP1 08EE 60 PUSH1 0x20 08F0 01 ADD 08F1 90 SWAP1 08F2 92 SWAP3 08F3 91 SWAP2 08F4 90 SWAP1 08F5 50 POP 08F6 50 POP 08F7 50 POP 08F8 61 PUSH2 0x18ae 08FB 56 *JUMP // Stack delta = -1 // Outputs[1] { @08F2 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x18ae label_08FC: // Incoming return from call to 0x08D0 at 0x08CB // Inputs[4] // { // @08FF memory[0x40:0x60] // @0901 stack[-1] // @0910 memory[0x40:0x60] // @0915 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08FC 5B JUMPDEST 08FD 60 PUSH1 0x40 08FF 51 MLOAD 0900 80 DUP1 0901 82 DUP3 0902 15 ISZERO 0903 15 ISZERO 0904 15 ISZERO 0905 15 ISZERO 0906 81 DUP2 0907 52 MSTORE 0908 60 PUSH1 0x20 090A 01 ADD 090B 91 SWAP2 090C 50 POP 090D 50 POP 090E 60 PUSH1 0x40 0910 51 MLOAD 0911 80 DUP1 0912 91 SWAP2 0913 03 SUB 0914 90 SWAP1 0915 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0907 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @0915 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0916: // Incoming jump from 0x0092, if 0xddf7fcb0 == stack[-1] 0916 5B JUMPDEST 0917 61 PUSH2 0x091e 091A 61 PUSH2 0x18ce 091D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0917 stack[0] = 0x091e } // Block ends with call to 0x18ce, returns to 0x091E label_091E: // Incoming return from call to 0x18CE at 0x091D // Inputs[4] // { // @0921 memory[0x40:0x60] // @0923 stack[-1] // @092E memory[0x40:0x60] // @0933 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 091E 5B JUMPDEST 091F 60 PUSH1 0x40 0921 51 MLOAD 0922 80 DUP1 0923 82 DUP3 0924 81 DUP2 0925 52 MSTORE 0926 60 PUSH1 0x20 0928 01 ADD 0929 91 SWAP2 092A 50 POP 092B 50 POP 092C 60 PUSH1 0x40 092E 51 MLOAD 092F 80 DUP1 0930 91 SWAP2 0931 03 SUB 0932 90 SWAP1 0933 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0925 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0933 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0934: // Incoming jump from 0x004B, if 0xe985e9c5 == stack[-1] // Inputs[1] { @093B msg.data.length } 0934 5B JUMPDEST 0935 61 PUSH2 0x0996 0938 60 PUSH1 0x04 093A 80 DUP1 093B 36 CALLDATASIZE 093C 03 SUB 093D 60 PUSH1 0x40 093F 81 DUP2 0940 10 LT 0941 15 ISZERO 0942 61 PUSH2 0x094a 0945 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0935 stack[0] = 0x0996 // @0938 stack[1] = 0x04 // @093C stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x094a, returns to 0x0996, if !(msg.data.length - 0x04 < 0x40) label_0946: // Incoming jump from 0x0945, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0949 memory[0x00:0x00] } 0946 60 PUSH1 0x00 0948 80 DUP1 0949 FD *REVERT // Stack delta = +0 // Outputs[1] { @0949 revert(memory[0x00:0x00]); } // Block terminates label_094A: // Incoming call from 0x0945, returns to 0x0996, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @094B stack[-2] // @094C stack[-1] // @0950 msg.data[stack[-2]:stack[-2] + 0x20] // @0970 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 094A 5B JUMPDEST 094B 81 DUP2 094C 01 ADD 094D 90 SWAP1 094E 80 DUP1 094F 80 DUP1 0950 35 CALLDATALOAD 0951 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0966 16 AND 0967 90 SWAP1 0968 60 PUSH1 0x20 096A 01 ADD 096B 90 SWAP1 096C 92 SWAP3 096D 91 SWAP2 096E 90 SWAP1 096F 80 DUP1 0970 35 CALLDATALOAD 0971 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0986 16 AND 0987 90 SWAP1 0988 60 PUSH1 0x20 098A 01 ADD 098B 90 SWAP1 098C 92 SWAP3 098D 91 SWAP2 098E 90 SWAP1 098F 50 POP 0990 50 POP 0991 50 POP 0992 61 PUSH2 0x18d4 0995 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @096C stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @098C stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x18d4 label_0996: // Incoming return from call to 0x094A at 0x0945 // Inputs[4] // { // @0999 memory[0x40:0x60] // @099B stack[-1] // @09AA memory[0x40:0x60] // @09AF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0996 5B JUMPDEST 0997 60 PUSH1 0x40 0999 51 MLOAD 099A 80 DUP1 099B 82 DUP3 099C 15 ISZERO 099D 15 ISZERO 099E 15 ISZERO 099F 15 ISZERO 09A0 81 DUP2 09A1 52 MSTORE 09A2 60 PUSH1 0x20 09A4 01 ADD 09A5 91 SWAP2 09A6 50 POP 09A7 50 POP 09A8 60 PUSH1 0x40 09AA 51 MLOAD 09AB 80 DUP1 09AC 91 SWAP2 09AD 03 SUB 09AE 90 SWAP1 09AF F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @09A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @09AF return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_09B0: // Incoming jump from 0x0056, if 0xf2fde38b == stack[-1] // Inputs[1] { @09B7 msg.data.length } 09B0 5B JUMPDEST 09B1 61 PUSH2 0x09f2 09B4 60 PUSH1 0x04 09B6 80 DUP1 09B7 36 CALLDATASIZE 09B8 03 SUB 09B9 60 PUSH1 0x20 09BB 81 DUP2 09BC 10 LT 09BD 15 ISZERO 09BE 61 PUSH2 0x09c6 09C1 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @09B1 stack[0] = 0x09f2 // @09B4 stack[1] = 0x04 // @09B8 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x09c6, returns to 0x09F2, if !(msg.data.length - 0x04 < 0x20) label_09C2: // Incoming jump from 0x09C1, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @09C5 memory[0x00:0x00] } 09C2 60 PUSH1 0x00 09C4 80 DUP1 09C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @09C5 revert(memory[0x00:0x00]); } // Block terminates label_09C6: // Incoming call from 0x09C1, returns to 0x09F2, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @09C7 stack[-2] // @09C8 stack[-1] // @09CC msg.data[stack[-2]:stack[-2] + 0x20] // } 09C6 5B JUMPDEST 09C7 81 DUP2 09C8 01 ADD 09C9 90 SWAP1 09CA 80 DUP1 09CB 80 DUP1 09CC 35 CALLDATALOAD 09CD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09E2 16 AND 09E3 90 SWAP1 09E4 60 PUSH1 0x20 09E6 01 ADD 09E7 90 SWAP1 09E8 92 SWAP3 09E9 91 SWAP2 09EA 90 SWAP1 09EB 50 POP 09EC 50 POP 09ED 50 POP 09EE 61 PUSH2 0x1968 09F1 56 *JUMP // Stack delta = -1 // Outputs[1] { @09E8 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1968 label_09F2: // Incoming return from call to 0x09C6 at 0x09C1 09F2 5B JUMPDEST 09F3 00 *STOP // Stack delta = +0 // Outputs[1] { @09F3 stop(); } // Block terminates label_09F4: // Incoming jump from 0x0061, if 0xf6a74ed7 == stack[-1] // Inputs[1] { @09FB msg.data.length } 09F4 5B JUMPDEST 09F5 61 PUSH2 0x0a36 09F8 60 PUSH1 0x04 09FA 80 DUP1 09FB 36 CALLDATASIZE 09FC 03 SUB 09FD 60 PUSH1 0x20 09FF 81 DUP2 0A00 10 LT 0A01 15 ISZERO 0A02 61 PUSH2 0x0a0a 0A05 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @09F5 stack[0] = 0x0a36 // @09F8 stack[1] = 0x04 // @09FC stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a0a, returns to 0x0A36, if !(msg.data.length - 0x04 < 0x20) label_0A06: // Incoming jump from 0x0A05, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0A09 memory[0x00:0x00] } 0A06 60 PUSH1 0x00 0A08 80 DUP1 0A09 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A09 revert(memory[0x00:0x00]); } // Block terminates label_0A0A: // Incoming call from 0x0A05, returns to 0x0A36, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0A0B stack[-2] // @0A0C stack[-1] // @0A10 msg.data[stack[-2]:stack[-2] + 0x20] // } 0A0A 5B JUMPDEST 0A0B 81 DUP2 0A0C 01 ADD 0A0D 90 SWAP1 0A0E 80 DUP1 0A0F 80 DUP1 0A10 35 CALLDATALOAD 0A11 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A26 16 AND 0A27 90 SWAP1 0A28 60 PUSH1 0x20 0A2A 01 ADD 0A2B 90 SWAP1 0A2C 92 SWAP3 0A2D 91 SWAP2 0A2E 90 SWAP1 0A2F 50 POP 0A30 50 POP 0A31 50 POP 0A32 61 PUSH2 0x1985 0A35 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A2C stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1985 label_0A36: // Incoming return from call to 0x0A0A at 0x0A05 0A36 5B JUMPDEST 0A37 00 *STOP // Stack delta = +0 // Outputs[1] { @0A37 stop(); } // Block terminates label_0A38: // Incoming jump from 0x006C, if 0xfca247ac == stack[-1] // Inputs[1] { @0A3F msg.data.length } 0A38 5B JUMPDEST 0A39 61 PUSH2 0x0a8e 0A3C 60 PUSH1 0x04 0A3E 80 DUP1 0A3F 36 CALLDATASIZE 0A40 03 SUB 0A41 60 PUSH1 0x60 0A43 81 DUP2 0A44 10 LT 0A45 15 ISZERO 0A46 61 PUSH2 0x0a4e 0A49 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A39 stack[0] = 0x0a8e // @0A3C stack[1] = 0x04 // @0A40 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a4e, returns to 0x0A8E, if !(msg.data.length - 0x04 < 0x60) label_0A4A: // Incoming jump from 0x0A49, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0A4D memory[0x00:0x00] } 0A4A 60 PUSH1 0x00 0A4C 80 DUP1 0A4D FD *REVERT // Stack delta = +0 // Outputs[1] { @0A4D revert(memory[0x00:0x00]); } // Block terminates label_0A4E: // Incoming call from 0x0A49, returns to 0x0A8E, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0A4F stack[-2] // @0A50 stack[-1] // @0A54 msg.data[stack[-2]:stack[-2] + 0x20] // @0A5E msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0A7E msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0A4E 5B JUMPDEST 0A4F 81 DUP2 0A50 01 ADD 0A51 90 SWAP1 0A52 80 DUP1 0A53 80 DUP1 0A54 35 CALLDATALOAD 0A55 90 SWAP1 0A56 60 PUSH1 0x20 0A58 01 ADD 0A59 90 SWAP1 0A5A 92 SWAP3 0A5B 91 SWAP2 0A5C 90 SWAP1 0A5D 80 DUP1 0A5E 35 CALLDATALOAD 0A5F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A74 16 AND 0A75 90 SWAP1 0A76 60 PUSH1 0x20 0A78 01 ADD 0A79 90 SWAP1 0A7A 92 SWAP3 0A7B 91 SWAP2 0A7C 90 SWAP1 0A7D 80 DUP1 0A7E 35 CALLDATALOAD 0A7F 90 SWAP1 0A80 60 PUSH1 0x20 0A82 01 ADD 0A83 90 SWAP1 0A84 92 SWAP3 0A85 91 SWAP2 0A86 90 SWAP1 0A87 50 POP 0A88 50 POP 0A89 50 POP 0A8A 61 PUSH2 0x1a34 0A8D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0A5A stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @0A7A stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0A84 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1a34 label_0A8E: // Incoming return from call to 0x0A4E at 0x0A49 // Inputs[4] // { // @0A91 memory[0x40:0x60] // @0A93 stack[-1] // @0A9E memory[0x40:0x60] // @0AA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A8E 5B JUMPDEST 0A8F 60 PUSH1 0x40 0A91 51 MLOAD 0A92 80 DUP1 0A93 82 DUP3 0A94 81 DUP2 0A95 52 MSTORE 0A96 60 PUSH1 0x20 0A98 01 ADD 0A99 91 SWAP2 0A9A 50 POP 0A9B 50 POP 0A9C 60 PUSH1 0x40 0A9E 51 MLOAD 0A9F 80 DUP1 0AA0 91 SWAP2 0AA1 03 SUB 0AA2 90 SWAP1 0AA3 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A95 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0AA3 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0AA4: // Incoming jump from 0x01F8 // Inputs[4] // { // @0AA9 memory[0x40:0x60] // @0AD7 memory[0x40:0x60] // @0ADC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x19 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0AFC stack[-1] // } 0AA4 5B JUMPDEST 0AA5 60 PUSH1 0x00 0AA7 60 PUSH1 0x40 0AA9 51 MLOAD 0AAA 80 DUP1 0AAB 80 DUP1 0AAC 7F PUSH32 0x737570706f727473496e74657266616365286279746573342900000000000000 0ACD 81 DUP2 0ACE 52 MSTORE 0ACF 50 POP 0AD0 60 PUSH1 0x19 0AD2 01 ADD 0AD3 90 SWAP1 0AD4 50 POP 0AD5 60 PUSH1 0x40 0AD7 51 MLOAD 0AD8 80 DUP1 0AD9 91 SWAP2 0ADA 03 SUB 0ADB 90 SWAP1 0ADC 20 SHA3 0ADD 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0AFA 19 NOT 0AFB 16 AND 0AFC 82 DUP3 0AFD 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0B1A 19 NOT 0B1B 16 AND 0B1C 14 EQ 0B1D 80 DUP1 0B1E 61 PUSH2 0x0cdd 0B21 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0AA5 stack[0] = 0x00 // @0ACE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x737570706f727473496e74657266616365286279746573342900000000000000 // @0B1C stack[1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x19 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0cdd, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x19 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_0B22: // Incoming jump from 0x0B21, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x19 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[28] // { // @0B25 memory[0x40:0x60] // @0B36 memory[0x40:0x60] // @0B3B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x2f + memory[0x40:0x60]) - memory[0x40:0x60]] // @0B3E memory[0x40:0x60] // @0B4F memory[0x40:0x60] // @0B54 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x29 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0B57 memory[0x40:0x60] // @0B68 memory[0x40:0x60] // @0B6D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x25 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0B70 memory[0x40:0x60] // @0B81 memory[0x40:0x60] // @0B86 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x21 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0B89 memory[0x40:0x60] // @0BB7 memory[0x40:0x60] // @0BBC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x1f + memory[0x40:0x60]) - memory[0x40:0x60]] // @0BBF memory[0x40:0x60] // @0BED memory[0x40:0x60] // @0BF2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x14 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0BF5 memory[0x40:0x60] // @0C23 memory[0x40:0x60] // @0C28 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x18 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0C2B memory[0x40:0x60] // @0C59 memory[0x40:0x60] // @0C5E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x10 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0C61 memory[0x40:0x60] // @0C8F memory[0x40:0x60] // @0C94 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x12 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0CBC stack[-3] // } 0B22 50 POP 0B23 60 PUSH1 0x40 0B25 51 MLOAD 0B26 80 DUP1 0B27 80 DUP1 0B28 61 PUSH2 0x28aa 0B2B 60 PUSH1 0x2f 0B2D 91 SWAP2 0B2E 39 CODECOPY 0B2F 60 PUSH1 0x2f 0B31 01 ADD 0B32 90 SWAP1 0B33 50 POP 0B34 60 PUSH1 0x40 0B36 51 MLOAD 0B37 80 DUP1 0B38 91 SWAP2 0B39 03 SUB 0B3A 90 SWAP1 0B3B 20 SHA3 0B3C 60 PUSH1 0x40 0B3E 51 MLOAD 0B3F 80 DUP1 0B40 80 DUP1 0B41 61 PUSH2 0x2881 0B44 60 PUSH1 0x29 0B46 91 SWAP2 0B47 39 CODECOPY 0B48 60 PUSH1 0x29 0B4A 01 ADD 0B4B 90 SWAP1 0B4C 50 POP 0B4D 60 PUSH1 0x40 0B4F 51 MLOAD 0B50 80 DUP1 0B51 91 SWAP2 0B52 03 SUB 0B53 90 SWAP1 0B54 20 SHA3 0B55 60 PUSH1 0x40 0B57 51 MLOAD 0B58 80 DUP1 0B59 80 DUP1 0B5A 61 PUSH2 0x285c 0B5D 60 PUSH1 0x25 0B5F 91 SWAP2 0B60 39 CODECOPY 0B61 60 PUSH1 0x25 0B63 01 ADD 0B64 90 SWAP1 0B65 50 POP 0B66 60 PUSH1 0x40 0B68 51 MLOAD 0B69 80 DUP1 0B6A 91 SWAP2 0B6B 03 SUB 0B6C 90 SWAP1 0B6D 20 SHA3 0B6E 60 PUSH1 0x40 0B70 51 MLOAD 0B71 80 DUP1 0B72 80 DUP1 0B73 61 PUSH2 0x28d9 0B76 60 PUSH1 0x21 0B78 91 SWAP2 0B79 39 CODECOPY 0B7A 60 PUSH1 0x21 0B7C 01 ADD 0B7D 90 SWAP1 0B7E 50 POP 0B7F 60 PUSH1 0x40 0B81 51 MLOAD 0B82 80 DUP1 0B83 91 SWAP2 0B84 03 SUB 0B85 90 SWAP1 0B86 20 SHA3 0B87 60 PUSH1 0x40 0B89 51 MLOAD 0B8A 80 DUP1 0B8B 80 DUP1 0B8C 7F PUSH32 0x736574417070726f76616c466f72416c6c28616464726573732c626f6f6c2900 0BAD 81 DUP2 0BAE 52 MSTORE 0BAF 50 POP 0BB0 60 PUSH1 0x1f 0BB2 01 ADD 0BB3 90 SWAP1 0BB4 50 POP 0BB5 60 PUSH1 0x40 0BB7 51 MLOAD 0BB8 80 DUP1 0BB9 91 SWAP2 0BBA 03 SUB 0BBB 90 SWAP1 0BBC 20 SHA3 0BBD 60 PUSH1 0x40 0BBF 51 MLOAD 0BC0 80 DUP1 0BC1 80 DUP1 0BC2 7F PUSH32 0x676574417070726f7665642875696e7432353629000000000000000000000000 0BE3 81 DUP2 0BE4 52 MSTORE 0BE5 50 POP 0BE6 60 PUSH1 0x14 0BE8 01 ADD 0BE9 90 SWAP1 0BEA 50 POP 0BEB 60 PUSH1 0x40 0BED 51 MLOAD 0BEE 80 DUP1 0BEF 91 SWAP2 0BF0 03 SUB 0BF1 90 SWAP1 0BF2 20 SHA3 0BF3 60 PUSH1 0x40 0BF5 51 MLOAD 0BF6 80 DUP1 0BF7 80 DUP1 0BF8 7F PUSH32 0x617070726f766528616464726573732c75696e74323536290000000000000000 0C19 81 DUP2 0C1A 52 MSTORE 0C1B 50 POP 0C1C 60 PUSH1 0x18 0C1E 01 ADD 0C1F 90 SWAP1 0C20 50 POP 0C21 60 PUSH1 0x40 0C23 51 MLOAD 0C24 80 DUP1 0C25 91 SWAP2 0C26 03 SUB 0C27 90 SWAP1 0C28 20 SHA3 0C29 60 PUSH1 0x40 0C2B 51 MLOAD 0C2C 80 DUP1 0C2D 80 DUP1 0C2E 7F PUSH32 0x6f776e65724f662875696e743235362900000000000000000000000000000000 0C4F 81 DUP2 0C50 52 MSTORE 0C51 50 POP 0C52 60 PUSH1 0x10 0C54 01 ADD 0C55 90 SWAP1 0C56 50 POP 0C57 60 PUSH1 0x40 0C59 51 MLOAD 0C5A 80 DUP1 0C5B 91 SWAP2 0C5C 03 SUB 0C5D 90 SWAP1 0C5E 20 SHA3 0C5F 60 PUSH1 0x40 0C61 51 MLOAD 0C62 80 DUP1 0C63 80 DUP1 0C64 7F PUSH32 0x62616c616e63654f662861646472657373290000000000000000000000000000 0C85 81 DUP2 0C86 52 MSTORE 0C87 50 POP 0C88 60 PUSH1 0x12 0C8A 01 ADD 0C8B 90 SWAP1 0C8C 50 POP 0C8D 60 PUSH1 0x40 0C8F 51 MLOAD 0C90 80 DUP1 0C91 91 SWAP2 0C92 03 SUB 0C93 90 SWAP1 0C94 20 SHA3 0C95 18 XOR 0C96 18 XOR 0C97 18 XOR 0C98 18 XOR 0C99 18 XOR 0C9A 18 XOR 0C9B 18 XOR 0C9C 18 XOR 0C9D 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0CBA 19 NOT 0CBB 16 AND 0CBC 82 DUP3 0CBD 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0CDA 19 NOT 0CDB 16 AND 0CDC 14 EQ 0CDD 5B JUMPDEST 0CDE 80 DUP1 0CDF 61 PUSH2 0x0d5a 0CE2 57 *JUMPI // Stack delta = +0 // Outputs[10] // { // @0B2E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x2f] = code[0x28aa:0x28d9] // @0B47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x29] = code[0x2881:0x28aa] // @0B60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x25] = code[0x285c:0x2881] // @0B79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x21] = code[0x28d9:0x28fa] // @0BAE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x736574417070726f76616c466f72416c6c28616464726573732c626f6f6c2900 // @0BE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x676574417070726f7665642875696e7432353629000000000000000000000000 // @0C1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x617070726f766528616464726573732c75696e74323536290000000000000000 // @0C50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f776e65724f662875696e743235362900000000000000000000000000000000 // @0C86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x62616c616e63654f662861646472657373290000000000000000000000000000 // @0CDC stack[-1] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x12 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x10 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x18 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x14 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x1f + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x21 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x25 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x29 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x2f + memory[0x40:0x60]) - memory[0x40:0x60]])) // } // Block ends with conditional jump to 0x0d5a, if ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x12 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x10 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x18 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x14 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x1f + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x21 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x25 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x29 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x2f + memory[0x40:0x60]) - memory[0x40:0x60]])) label_0CE3: // Incoming jump from 0x0CE2, if not ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x12 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x10 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x18 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x14 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x1f + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x21 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x25 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x29 + memory[0x40:0x60]) - memory[0x40:0x60]]) ~ keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x2f + memory[0x40:0x60]) - memory[0x40:0x60]])) // Incoming jump from 0x0CE2, if not stack[-1] // Inputs[6] // { // @0CE6 memory[0x40:0x60] // @0D14 memory[0x40:0x60] // @0D19 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x18 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0D39 stack[-3] // @0D5B stack[-2] // @0D5D stack[-4] // } 0CE3 50 POP 0CE4 60 PUSH1 0x40 0CE6 51 MLOAD 0CE7 80 DUP1 0CE8 80 DUP1 0CE9 7F PUSH32 0x7265636c61696d2875696e743235362c61646472657373290000000000000000 0D0A 81 DUP2 0D0B 52 MSTORE 0D0C 50 POP 0D0D 60 PUSH1 0x18 0D0F 01 ADD 0D10 90 SWAP1 0D11 50 POP 0D12 60 PUSH1 0x40 0D14 51 MLOAD 0D15 80 DUP1 0D16 91 SWAP2 0D17 03 SUB 0D18 90 SWAP1 0D19 20 SHA3 0D1A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0D37 19 NOT 0D38 16 AND 0D39 82 DUP3 0D3A 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0D57 19 NOT 0D58 16 AND 0D59 14 EQ 0D5A 5B JUMPDEST 0D5B 90 SWAP1 0D5C 50 POP 0D5D 91 SWAP2 0D5E 90 SWAP1 0D5F 50 POP 0D60 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0D0B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x7265636c61696d2875696e743235362c61646472657373290000000000000000 // @0D5D stack[-4] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x18 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with unconditional jump to stack[-4] label_0D61: // Incoming call from 0x1E1C, returns to 0x1E1D // Incoming jump from 0x023E // Inputs[1] { @0D67 stack[-1] } 0D61 5B JUMPDEST 0D62 60 PUSH1 0x00 0D64 61 PUSH2 0x0d6c 0D67 82 DUP3 0D68 61 PUSH2 0x1a4c 0D6B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D62 stack[0] = 0x00 // @0D64 stack[1] = 0x0d6c // @0D67 stack[2] = stack[-1] // } // Block ends with call to 0x1a4c, returns to 0x0D6C label_0D6C: // Incoming return from call to 0x1A4C at 0x0D6B // Inputs[1] { @0D70 stack[-1] } 0D6C 5B JUMPDEST 0D6D 61 PUSH2 0x0d75 0D70 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d75, if stack[-1] label_0D71: // Incoming jump from 0x0D70, if not stack[-1] // Inputs[1] { @0D74 memory[0x00:0x00] } 0D71 60 PUSH1 0x00 0D73 80 DUP1 0D74 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D74 revert(memory[0x00:0x00]); } // Block terminates label_0D75: // Incoming jump from 0x0D70, if stack[-1] // Inputs[5] // { // @0D7A stack[-2] // @0D88 memory[0x00:0x40] // @0D8C storage[keccak256(memory[0x00:0x40])] // @0DAA stack[-1] // @0DAC stack[-3] // } 0D75 5B JUMPDEST 0D76 60 PUSH1 0x06 0D78 60 PUSH1 0x00 0D7A 83 DUP4 0D7B 81 DUP2 0D7C 52 MSTORE 0D7D 60 PUSH1 0x20 0D7F 01 ADD 0D80 90 SWAP1 0D81 81 DUP2 0D82 52 MSTORE 0D83 60 PUSH1 0x20 0D85 01 ADD 0D86 60 PUSH1 0x00 0D88 20 SHA3 0D89 60 PUSH1 0x00 0D8B 90 SWAP1 0D8C 54 SLOAD 0D8D 90 SWAP1 0D8E 61 PUSH2 0x0100 0D91 0A EXP 0D92 90 SWAP1 0D93 04 DIV 0D94 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DA9 16 AND 0DAA 90 SWAP1 0DAB 50 POP 0DAC 91 SWAP2 0DAD 90 SWAP1 0DAE 50 POP 0DAF 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0D7C memory[0x00:0x20] = stack[-2] // @0D82 memory[0x20:0x40] = 0x06 // @0DAC stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_0DB0: // Incoming jump from 0x02CC // Inputs[1] { @0DB6 stack[-1] } 0DB0 5B JUMPDEST 0DB1 60 PUSH1 0x00 0DB3 61 PUSH2 0x0dbb 0DB6 82 DUP3 0DB7 61 PUSH2 0x1239 0DBA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DB1 stack[0] = 0x00 // @0DB3 stack[1] = 0x0dbb // @0DB6 stack[2] = stack[-1] // } // Block ends with call to 0x1239, returns to 0x0DBB label_0DBB: // Incoming return from call to 0x1239 at 0x0DBA // Inputs[3] // { // @0DBC stack[-2] // @0DBC stack[-1] // @0DD5 stack[-4] // } 0DBB 5B JUMPDEST 0DBC 90 SWAP1 0DBD 50 POP 0DBE 80 DUP1 0DBF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DD4 16 AND 0DD5 83 DUP4 0DD6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DEB 16 AND 0DEC 14 EQ 0DED 15 ISZERO 0DEE 61 PUSH2 0x0df6 0DF1 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0DBC stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0df6, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_0DF2: // Incoming jump from 0x0DF1, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @0DF5 memory[0x00:0x00] } 0DF2 60 PUSH1 0x00 0DF4 80 DUP1 0DF5 FD *REVERT // Stack delta = +0 // Outputs[1] { @0DF5 revert(memory[0x00:0x00]); } // Block terminates label_0DF6: // Incoming jump from 0x0DF1, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[2] // { // @0DF7 stack[-1] // @0E0E msg.sender // } 0DF6 5B JUMPDEST 0DF7 80 DUP1 0DF8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E0D 16 AND 0E0E 33 CALLER 0E0F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E24 16 AND 0E25 14 EQ 0E26 80 DUP1 0E27 61 PUSH2 0x0e36 0E2A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E25 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] } // Block ends with conditional jump to 0x0e36, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_0E2B: // Incoming jump from 0x0E2A, if not 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @0E2F stack[-2] // @0E30 msg.sender // } 0E2B 50 POP 0E2C 61 PUSH2 0x0e35 0E2F 81 DUP2 0E30 33 CALLER 0E31 61 PUSH2 0x18d4 0E34 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E2C stack[-1] = 0x0e35 // @0E2F stack[0] = stack[-2] // @0E30 stack[1] = msg.sender // } // Block ends with call to 0x18d4, returns to 0x0E35 label_0E35: // Incoming return from call to 0x18D4 at 0x0E34 0E35 5B JUMPDEST // Stack delta = +0 // Block continues label_0E36: // Incoming jump from 0x0E35 // Incoming jump from 0x0E2A, if 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[1] { @0E3A stack[-1] } 0E36 5B JUMPDEST 0E37 61 PUSH2 0x0e3f 0E3A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e3f, if stack[-1] label_0E3B: // Incoming jump from 0x0E3A, if not stack[-1] // Inputs[1] { @0E3E memory[0x00:0x00] } 0E3B 60 PUSH1 0x00 0E3D 80 DUP1 0E3E FD *REVERT // Stack delta = +0 // Outputs[1] { @0E3E revert(memory[0x00:0x00]); } // Block terminates label_0E3F: // Incoming jump from 0x0E3A, if stack[-1] // Inputs[9] // { // @0E40 stack[-3] // @0E45 stack[-2] // @0E53 memory[0x00:0x40] // @0E5B storage[keccak256(memory[0x00:0x40])] // @0EAA stack[-1] // @0EE4 memory[0x40:0x60] // @0EE7 memory[0x40:0x60] // @0EEC memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0EF0 stack[-4] // } 0E3F 5B JUMPDEST 0E40 82 DUP3 0E41 60 PUSH1 0x06 0E43 60 PUSH1 0x00 0E45 84 DUP5 0E46 81 DUP2 0E47 52 MSTORE 0E48 60 PUSH1 0x20 0E4A 01 ADD 0E4B 90 SWAP1 0E4C 81 DUP2 0E4D 52 MSTORE 0E4E 60 PUSH1 0x20 0E50 01 ADD 0E51 60 PUSH1 0x00 0E53 20 SHA3 0E54 60 PUSH1 0x00 0E56 61 PUSH2 0x0100 0E59 0A EXP 0E5A 81 DUP2 0E5B 54 SLOAD 0E5C 81 DUP2 0E5D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E72 02 MUL 0E73 19 NOT 0E74 16 AND 0E75 90 SWAP1 0E76 83 DUP4 0E77 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E8C 16 AND 0E8D 02 MUL 0E8E 17 OR 0E8F 90 SWAP1 0E90 55 SSTORE 0E91 50 POP 0E92 81 DUP2 0E93 83 DUP4 0E94 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EA9 16 AND 0EAA 82 DUP3 0EAB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EC0 16 AND 0EC1 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0EE2 60 PUSH1 0x40 0EE4 51 MLOAD 0EE5 60 PUSH1 0x40 0EE7 51 MLOAD 0EE8 80 DUP1 0EE9 91 SWAP2 0EEA 03 SUB 0EEB 90 SWAP1 0EEC A4 LOG4 0EED 50 POP 0EEE 50 POP 0EEF 50 POP 0EF0 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0E47 memory[0x00:0x20] = stack[-2] // @0E4D memory[0x20:0x40] = 0x06 // @0E90 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @0EEC log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_0EF1: // Incoming jump from 0x0324 // Inputs[3] // { // @0EF7 stack[-3] // @0EF8 stack[-2] // @0EF9 stack[-1] // } 0EF1 5B JUMPDEST 0EF2 60 PUSH1 0x00 0EF4 61 PUSH2 0x0f00 0EF7 84 DUP5 0EF8 84 DUP5 0EF9 84 DUP5 0EFA 60 PUSH1 0x00 0EFC 61 PUSH2 0x1abe 0EFF 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0EF2 stack[0] = 0x00 // @0EF4 stack[1] = 0x0f00 // @0EF7 stack[2] = stack[-3] // @0EF8 stack[3] = stack[-2] // @0EF9 stack[4] = stack[-1] // @0EFA stack[5] = 0x00 // } // Block ends with call to 0x1abe, returns to 0x0F00 label_0F00: // Incoming return from call to 0x1ABE at 0x0EFF // Inputs[4] // { // @0F01 stack[-2] // @0F01 stack[-1] // @0F03 stack[-6] // @0F04 stack[-5] // } 0F00 5B JUMPDEST 0F01 90 SWAP1 0F02 50 POP 0F03 93 SWAP4 0F04 92 SWAP3 0F05 50 POP 0F06 50 POP 0F07 50 POP 0F08 56 *JUMP // Stack delta = -5 // Outputs[1] { @0F03 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0F09: // Incoming call from 0x1657, returns to 0x1658 // Incoming jump from 0x03A6 // Inputs[2] // { // @0F0D msg.sender // @0F0E stack[-1] // } 0F09 5B JUMPDEST 0F0A 61 PUSH2 0x0f13 0F0D 33 CALLER 0F0E 82 DUP3 0F0F 61 PUSH2 0x1dba 0F12 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F0A stack[0] = 0x0f13 // @0F0D stack[1] = msg.sender // @0F0E stack[2] = stack[-1] // } // Block ends with call to 0x1dba, returns to 0x0F13 label_0F13: // Incoming return from call to 0x1DBA at 0x0F12 // Inputs[1] { @0F17 stack[-1] } 0F13 5B JUMPDEST 0F14 61 PUSH2 0x0f1c 0F17 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f1c, if stack[-1] label_0F18: // Incoming jump from 0x0F17, if not stack[-1] // Inputs[1] { @0F1B memory[0x00:0x00] } 0F18 60 PUSH1 0x00 0F1A 80 DUP1 0F1B FD *REVERT // Stack delta = +0 // Outputs[1] { @0F1B revert(memory[0x00:0x00]); } // Block terminates label_0F1C: // Incoming jump from 0x0F17, if stack[-1] // Inputs[3] // { // @0F20 stack[-3] // @0F21 stack[-2] // @0F22 stack[-1] // } 0F1C 5B JUMPDEST 0F1D 61 PUSH2 0x0f27 0F20 83 DUP4 0F21 83 DUP4 0F22 83 DUP4 0F23 61 PUSH2 0x1e4f 0F26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F1D stack[0] = 0x0f27 // @0F20 stack[1] = stack[-3] // @0F21 stack[2] = stack[-2] // @0F22 stack[3] = stack[-1] // } // Block ends with call to 0x1e4f, returns to 0x0F27 label_0F27: // Incoming return from call to 0x1E4F at 0x0F26 // Inputs[1] { @0F2B stack[-4] } 0F27 5B JUMPDEST 0F28 50 POP 0F29 50 POP 0F2A 50 POP 0F2B 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0F2C: // Incoming jump from 0x03F4 // Inputs[6] // { // @0F2D address(this) // @0F49 storage[0x02] // @0F84 storage[0x03] // @0F87 memory[0x40:0x60] // @0FA5 memory[0x40:0x60] // @0FAC address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } 0F2C 5B JUMPDEST 0F2D 30 ADDRESS 0F2E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F43 16 AND 0F44 60 PUSH1 0x02 0F46 60 PUSH1 0x00 0F48 90 SWAP1 0F49 54 SLOAD 0F4A 90 SWAP1 0F4B 61 PUSH2 0x0100 0F4E 0A EXP 0F4F 90 SWAP1 0F50 04 DIV 0F51 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F66 16 AND 0F67 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F7C 16 AND 0F7D 63 PUSH4 0x02571be3 0F82 60 PUSH1 0x03 0F84 54 SLOAD 0F85 60 PUSH1 0x40 0F87 51 MLOAD 0F88 82 DUP3 0F89 63 PUSH4 0xffffffff 0F8E 16 AND 0F8F 60 PUSH1 0xe0 0F91 1B SHL 0F92 81 DUP2 0F93 52 MSTORE 0F94 60 PUSH1 0x04 0F96 01 ADD 0F97 80 DUP1 0F98 82 DUP3 0F99 81 DUP2 0F9A 52 MSTORE 0F9B 60 PUSH1 0x20 0F9D 01 ADD 0F9E 91 SWAP2 0F9F 50 POP 0FA0 50 POP 0FA1 60 PUSH1 0x20 0FA3 60 PUSH1 0x40 0FA5 51 MLOAD 0FA6 80 DUP1 0FA7 83 DUP4 0FA8 03 SUB 0FA9 81 DUP2 0FAA 86 DUP7 0FAB 80 DUP1 0FAC 3B EXTCODESIZE 0FAD 15 ISZERO 0FAE 80 DUP1 0FAF 15 ISZERO 0FB0 61 PUSH2 0x0fb8 0FB3 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0F43 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @0F7C stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @0F7D stack[2] = 0x02571be3 // @0F93 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x02571be3) << 0xe0 // @0F9A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = storage[0x03] // @0F9E stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @0FA1 stack[4] = 0x20 // @0FA5 stack[5] = memory[0x40:0x60] // @0FA8 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0FA9 stack[7] = memory[0x40:0x60] // @0FAA stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @0FAD stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x0fb8, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length label_0FB4: // Incoming jump from 0x0FB3, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[1] { @0FB7 memory[0x00:0x00] } 0FB4 60 PUSH1 0x00 0FB6 80 DUP1 0FB7 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FB7 revert(memory[0x00:0x00]); } // Block terminates label_0FB8: // Incoming jump from 0x0FB3, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @0FBA msg.gas // @0FBB stack[-4] // @0FBB address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0FBB stack[-2] // @0FBB stack[-3] // @0FBB memory[stack[-3]:stack[-3] + stack[-4]] // @0FBB stack[-6] // @0FBB stack[-5] // } 0FB8 5B JUMPDEST 0FB9 50 POP 0FBA 5A GAS 0FBB FA STATICCALL 0FBC 15 ISZERO 0FBD 80 DUP1 0FBE 15 ISZERO 0FBF 61 PUSH2 0x0fcc 0FC2 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0FBB memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0FBC stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0fcc, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0FC3: // Incoming jump from 0x0FC2, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0FC3 returndata.length // @0FC7 returndata[0x00:0x00 + returndata.length] // @0FC8 returndata.length // @0FCB memory[0x00:0x00 + returndata.length] // } 0FC3 3D RETURNDATASIZE 0FC4 60 PUSH1 0x00 0FC6 80 DUP1 0FC7 3E RETURNDATACOPY 0FC8 3D RETURNDATASIZE 0FC9 60 PUSH1 0x00 0FCB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FC7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0FCB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0FCC: // Incoming jump from 0x0FC2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0FD3 memory[0x40:0x60] // @0FD4 returndata.length // } 0FCC 5B JUMPDEST 0FCD 50 POP 0FCE 50 POP 0FCF 50 POP 0FD0 50 POP 0FD1 60 PUSH1 0x40 0FD3 51 MLOAD 0FD4 3D RETURNDATASIZE 0FD5 60 PUSH1 0x20 0FD7 81 DUP2 0FD8 10 LT 0FD9 15 ISZERO 0FDA 61 PUSH2 0x0fe2 0FDD 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0FD3 stack[-4] = memory[0x40:0x60] // @0FD4 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0fe2, if !(returndata.length < 0x20) label_0FDE: // Incoming jump from 0x0FDD, if not !(returndata.length < 0x20) // Inputs[1] { @0FE1 memory[0x00:0x00] } 0FDE 60 PUSH1 0x00 0FE0 80 DUP1 0FE1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FE1 revert(memory[0x00:0x00]); } // Block terminates label_0FE2: // Incoming jump from 0x0FDD, if !(returndata.length < 0x20) // Inputs[4] // { // @0FE3 stack[-2] // @0FE4 stack[-1] // @0FE8 memory[stack[-2]:stack[-2] + 0x20] // @100A stack[-3] // } 0FE2 5B JUMPDEST 0FE3 81 DUP2 0FE4 01 ADD 0FE5 90 SWAP1 0FE6 80 DUP1 0FE7 80 DUP1 0FE8 51 MLOAD 0FE9 90 SWAP1 0FEA 60 PUSH1 0x20 0FEC 01 ADD 0FED 90 SWAP1 0FEE 92 SWAP3 0FEF 91 SWAP2 0FF0 90 SWAP1 0FF1 50 POP 0FF2 50 POP 0FF3 50 POP 0FF4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1009 16 AND 100A 14 EQ 100B 61 PUSH2 0x1013 100E 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x1013, if 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] label_100F: // Incoming jump from 0x100E, if not 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[1] { @1012 memory[0x00:0x00] } 100F 60 PUSH1 0x00 1011 80 DUP1 1012 FD *REVERT // Stack delta = +0 // Outputs[1] { @1012 revert(memory[0x00:0x00]); } // Block terminates label_1013: // Incoming jump from 0x100E, if 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[2] // { // @1017 msg.sender // @1018 stack[-2] // } 1013 5B JUMPDEST 1014 61 PUSH2 0x101d 1017 33 CALLER 1018 83 DUP4 1019 61 PUSH2 0x1dba 101C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1014 stack[0] = 0x101d // @1017 stack[1] = msg.sender // @1018 stack[2] = stack[-2] // } // Block ends with call to 0x1dba, returns to 0x101D label_101D: // Incoming return from call to 0x1DBA at 0x101C // Inputs[1] { @1021 stack[-1] } 101D 5B JUMPDEST 101E 61 PUSH2 0x1026 1021 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1026, if stack[-1] label_1022: // Incoming jump from 0x1021, if not stack[-1] // Inputs[1] { @1025 memory[0x00:0x00] } 1022 60 PUSH1 0x00 1024 80 DUP1 1025 FD *REVERT // Stack delta = +0 // Outputs[1] { @1025 revert(memory[0x00:0x00]); } // Block terminates label_1026: // Incoming jump from 0x1021, if stack[-1] // Inputs[7] // { // @102C storage[0x02] // @1067 storage[0x03] // @1068 stack[-2] // @106C stack[-1] // @106F memory[0x40:0x60] // @10C7 memory[0x40:0x60] // @10D0 address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } 1026 5B JUMPDEST 1027 60 PUSH1 0x02 1029 60 PUSH1 0x00 102B 90 SWAP1 102C 54 SLOAD 102D 90 SWAP1 102E 61 PUSH2 0x0100 1031 0A EXP 1032 90 SWAP1 1033 04 DIV 1034 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1049 16 AND 104A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 105F 16 AND 1060 63 PUSH4 0x06ab5923 1065 60 PUSH1 0x03 1067 54 SLOAD 1068 84 DUP5 1069 60 PUSH1 0x00 106B 1B SHL 106C 84 DUP5 106D 60 PUSH1 0x40 106F 51 MLOAD 1070 84 DUP5 1071 63 PUSH4 0xffffffff 1076 16 AND 1077 60 PUSH1 0xe0 1079 1B SHL 107A 81 DUP2 107B 52 MSTORE 107C 60 PUSH1 0x04 107E 01 ADD 107F 80 DUP1 1080 84 DUP5 1081 81 DUP2 1082 52 MSTORE 1083 60 PUSH1 0x20 1085 01 ADD 1086 83 DUP4 1087 81 DUP2 1088 52 MSTORE 1089 60 PUSH1 0x20 108B 01 ADD 108C 82 DUP3 108D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10A2 16 AND 10A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10B8 16 AND 10B9 81 DUP2 10BA 52 MSTORE 10BB 60 PUSH1 0x20 10BD 01 ADD 10BE 93 SWAP4 10BF 50 POP 10C0 50 POP 10C1 50 POP 10C2 50 POP 10C3 60 PUSH1 0x20 10C5 60 PUSH1 0x40 10C7 51 MLOAD 10C8 80 DUP1 10C9 83 DUP4 10CA 03 SUB 10CB 81 DUP2 10CC 60 PUSH1 0x00 10CE 87 DUP8 10CF 80 DUP1 10D0 3B EXTCODESIZE 10D1 15 ISZERO 10D2 80 DUP1 10D3 15 ISZERO 10D4 61 PUSH2 0x10dc 10D7 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @105F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @1060 stack[1] = 0x06ab5923 // @107B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x06ab5923) << 0xe0 // @1082 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = storage[0x03] // @1088 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-2] << 0x00 // @10BA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @10BE stack[2] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @10C3 stack[3] = 0x20 // @10C7 stack[4] = memory[0x40:0x60] // @10CA stack[5] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @10CB stack[6] = memory[0x40:0x60] // @10CC stack[7] = 0x00 // @10CE stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @10D1 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x10dc, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length label_10D8: // Incoming jump from 0x10D7, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[1] { @10DB memory[0x00:0x00] } 10D8 60 PUSH1 0x00 10DA 80 DUP1 10DB FD *REVERT // Stack delta = +0 // Outputs[1] { @10DB revert(memory[0x00:0x00]); } // Block terminates label_10DC: // Incoming jump from 0x10D7, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[9] // { // @10DE msg.gas // @10DF stack[-5] // @10DF address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @10DF memory[stack[-4]:stack[-4] + stack[-5]] // @10DF stack[-3] // @10DF stack[-4] // @10DF stack[-7] // @10DF stack[-6] // @10DF stack[-2] // } 10DC 5B JUMPDEST 10DD 50 POP 10DE 5A GAS 10DF F1 CALL 10E0 15 ISZERO 10E1 80 DUP1 10E2 15 ISZERO 10E3 61 PUSH2 0x10f0 10E6 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @10DF memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @10E0 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 0x10f0, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_10E7: // Incoming jump from 0x10E6, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @10E7 returndata.length // @10EB returndata[0x00:0x00 + returndata.length] // @10EC returndata.length // @10EF memory[0x00:0x00 + returndata.length] // } 10E7 3D RETURNDATASIZE 10E8 60 PUSH1 0x00 10EA 80 DUP1 10EB 3E RETURNDATACOPY 10EC 3D RETURNDATASIZE 10ED 60 PUSH1 0x00 10EF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10EB memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @10EF revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_10F0: // Incoming jump from 0x10E6, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @10F7 memory[0x40:0x60] // @10F8 returndata.length // } 10F0 5B JUMPDEST 10F1 50 POP 10F2 50 POP 10F3 50 POP 10F4 50 POP 10F5 60 PUSH1 0x40 10F7 51 MLOAD 10F8 3D RETURNDATASIZE 10F9 60 PUSH1 0x20 10FB 81 DUP2 10FC 10 LT 10FD 15 ISZERO 10FE 61 PUSH2 0x1106 1101 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @10F7 stack[-4] = memory[0x40:0x60] // @10F8 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1106, if !(returndata.length < 0x20) label_1102: // Incoming jump from 0x1101, if not !(returndata.length < 0x20) // Inputs[1] { @1105 memory[0x00:0x00] } 1102 60 PUSH1 0x00 1104 80 DUP1 1105 FD *REVERT // Stack delta = +0 // Outputs[1] { @1105 revert(memory[0x00:0x00]); } // Block terminates label_1106: // Incoming jump from 0x1101, if !(returndata.length < 0x20) // Inputs[4] // { // @1107 stack[-2] // @1108 stack[-1] // @110C memory[stack[-2]:stack[-2] + 0x20] // @111B stack[-5] // } 1106 5B JUMPDEST 1107 81 DUP2 1108 01 ADD 1109 90 SWAP1 110A 80 DUP1 110B 80 DUP1 110C 51 MLOAD 110D 90 SWAP1 110E 60 PUSH1 0x20 1110 01 ADD 1111 90 SWAP1 1112 92 SWAP3 1113 91 SWAP2 1114 90 SWAP1 1115 50 POP 1116 50 POP 1117 50 POP 1118 50 POP 1119 50 POP 111A 50 POP 111B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_111C: // Incoming call from 0x03FE, returns to 0x03FF // Inputs[2] // { // @1122 storage[0x02] // @1140 stack[-1] // } 111C 5B JUMPDEST 111D 60 PUSH1 0x02 111F 60 PUSH1 0x00 1121 90 SWAP1 1122 54 SLOAD 1123 90 SWAP1 1124 61 PUSH2 0x0100 1127 0A EXP 1128 90 SWAP1 1129 04 DIV 112A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 113F 16 AND 1140 81 DUP2 1141 56 *JUMP // Stack delta = +1 // Outputs[1] { @113F stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_1142: // Incoming jump from 0x04AC // Inputs[4] // { // @1146 stack[-3] // @1147 stack[-2] // @1148 stack[-1] // @114B memory[0x40:0x60] // } 1142 5B JUMPDEST 1143 61 PUSH2 0x115d 1146 83 DUP4 1147 83 DUP4 1148 83 DUP4 1149 60 PUSH1 0x40 114B 51 MLOAD 114C 80 DUP1 114D 60 PUSH1 0x20 114F 01 ADD 1150 60 PUSH1 0x40 1152 52 MSTORE 1153 80 DUP1 1154 60 PUSH1 0x00 1156 81 DUP2 1157 52 MSTORE 1158 50 POP 1159 61 PUSH2 0x164d 115C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1143 stack[0] = 0x115d // @1146 stack[1] = stack[-3] // @1147 stack[2] = stack[-2] // @1148 stack[3] = stack[-1] // @114B stack[4] = memory[0x40:0x60] // @1152 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1157 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x164d, returns to 0x115D label_115D: // Incoming return from call to 0x164D at 0x115C // Inputs[1] { @1161 stack[-4] } 115D 5B JUMPDEST 115E 50 POP 115F 50 POP 1160 50 POP 1161 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1162: // Incoming jump from 0x04F0 1162 5B JUMPDEST 1163 61 PUSH2 0x116a 1166 61 PUSH2 0x13e8 1169 56 *JUMP // Stack delta = +1 // Outputs[1] { @1163 stack[0] = 0x116a } // Block ends with call to 0x13e8, returns to 0x116A label_116A: // Incoming return from call to 0x13E8 at 0x1169 // Inputs[1] { @116E stack[-1] } 116A 5B JUMPDEST 116B 61 PUSH2 0x1173 116E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1173, if stack[-1] label_116F: // Incoming jump from 0x116E, if not stack[-1] // Inputs[1] { @1172 memory[0x00:0x00] } 116F 60 PUSH1 0x00 1171 80 DUP1 1172 FD *REVERT // Stack delta = +0 // Outputs[1] { @1172 revert(memory[0x00:0x00]); } // Block terminates label_1173: // Incoming jump from 0x116E, if stack[-1] // Inputs[6] // { // @1179 storage[0x02] // @11B4 storage[0x03] // @11B5 stack[-1] // @11B8 memory[0x40:0x60] // @1209 memory[0x40:0x60] // @1212 address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } 1173 5B JUMPDEST 1174 60 PUSH1 0x02 1176 60 PUSH1 0x00 1178 90 SWAP1 1179 54 SLOAD 117A 90 SWAP1 117B 61 PUSH2 0x0100 117E 0A EXP 117F 90 SWAP1 1180 04 DIV 1181 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1196 16 AND 1197 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11AC 16 AND 11AD 63 PUSH4 0x1896f70a 11B2 60 PUSH1 0x03 11B4 54 SLOAD 11B5 83 DUP4 11B6 60 PUSH1 0x40 11B8 51 MLOAD 11B9 83 DUP4 11BA 63 PUSH4 0xffffffff 11BF 16 AND 11C0 60 PUSH1 0xe0 11C2 1B SHL 11C3 81 DUP2 11C4 52 MSTORE 11C5 60 PUSH1 0x04 11C7 01 ADD 11C8 80 DUP1 11C9 83 DUP4 11CA 81 DUP2 11CB 52 MSTORE 11CC 60 PUSH1 0x20 11CE 01 ADD 11CF 82 DUP3 11D0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11E5 16 AND 11E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11FB 16 AND 11FC 81 DUP2 11FD 52 MSTORE 11FE 60 PUSH1 0x20 1200 01 ADD 1201 92 SWAP3 1202 50 POP 1203 50 POP 1204 50 POP 1205 60 PUSH1 0x00 1207 60 PUSH1 0x40 1209 51 MLOAD 120A 80 DUP1 120B 83 DUP4 120C 03 SUB 120D 81 DUP2 120E 60 PUSH1 0x00 1210 87 DUP8 1211 80 DUP1 1212 3B EXTCODESIZE 1213 15 ISZERO 1214 80 DUP1 1215 15 ISZERO 1216 61 PUSH2 0x121e 1219 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @11AC stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @11AD stack[1] = 0x1896f70a // @11C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x1896f70a) << 0xe0 // @11CB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = storage[0x03] // @11FD memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1201 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1205 stack[3] = 0x00 // @1209 stack[4] = memory[0x40:0x60] // @120C stack[5] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @120D stack[6] = memory[0x40:0x60] // @120E stack[7] = 0x00 // @1210 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @1213 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x121e, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length label_121A: // Incoming jump from 0x1219, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[1] { @121D memory[0x00:0x00] } 121A 60 PUSH1 0x00 121C 80 DUP1 121D FD *REVERT // Stack delta = +0 // Outputs[1] { @121D revert(memory[0x00:0x00]); } // Block terminates label_121E: // Incoming jump from 0x1219, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[9] // { // @1220 msg.gas // @1221 stack[-5] // @1221 stack[-3] // @1221 memory[stack[-4]:stack[-4] + stack[-5]] // @1221 stack[-2] // @1221 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1221 stack[-4] // @1221 stack[-7] // @1221 stack[-6] // } 121E 5B JUMPDEST 121F 50 POP 1220 5A GAS 1221 F1 CALL 1222 15 ISZERO 1223 80 DUP1 1224 15 ISZERO 1225 61 PUSH2 0x1232 1228 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1221 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1222 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 0x1232, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1229: // Incoming jump from 0x1228, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1229 returndata.length // @122D returndata[0x00:0x00 + returndata.length] // @122E returndata.length // @1231 memory[0x00:0x00 + returndata.length] // } 1229 3D RETURNDATASIZE 122A 60 PUSH1 0x00 122C 80 DUP1 122D 3E RETURNDATACOPY 122E 3D RETURNDATASIZE 122F 60 PUSH1 0x00 1231 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @122D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1231 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1232: // Incoming jump from 0x1228, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1238 stack[-6] } 1232 5B JUMPDEST 1233 50 POP 1234 50 POP 1235 50 POP 1236 50 POP 1237 50 POP 1238 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_1239: // Incoming call from 0x26E8, returns to 0x26E9 // Incoming call from 0x1E6E, returns to 0x1E6F // Incoming call from 0x1DC5, returns to 0x1DC6 // Incoming call from 0x241A, returns to 0x241B // Incoming call from 0x0DBA, returns to 0x0DBB // Incoming jump from 0x051E // Inputs[4] // { // @123C block.timestamp // @1241 stack[-1] // @124F memory[0x00:0x40] // @1250 storage[keccak256(memory[0x00:0x40])] // } 1239 5B JUMPDEST 123A 60 PUSH1 0x00 123C 42 TIMESTAMP 123D 60 PUSH1 0x09 123F 60 PUSH1 0x00 1241 84 DUP5 1242 81 DUP2 1243 52 MSTORE 1244 60 PUSH1 0x20 1246 01 ADD 1247 90 SWAP1 1248 81 DUP2 1249 52 MSTORE 124A 60 PUSH1 0x20 124C 01 ADD 124D 60 PUSH1 0x00 124F 20 SHA3 1250 54 SLOAD 1251 11 GT 1252 61 PUSH2 0x125a 1255 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @123A stack[0] = 0x00 // @1243 memory[0x00:0x20] = stack[-1] // @1249 memory[0x20:0x40] = 0x09 // } // Block ends with conditional jump to 0x125a, if storage[keccak256(memory[0x00:0x40])] > block.timestamp label_1256: // Incoming jump from 0x1255, if not storage[keccak256(memory[0x00:0x40])] > block.timestamp // Inputs[1] { @1259 memory[0x00:0x00] } 1256 60 PUSH1 0x00 1258 80 DUP1 1259 FD *REVERT // Stack delta = +0 // Outputs[1] { @1259 revert(memory[0x00:0x00]); } // Block terminates label_125A: // Incoming jump from 0x1255, if storage[keccak256(memory[0x00:0x40])] > block.timestamp // Inputs[1] { @125E stack[-2] } 125A 5B JUMPDEST 125B 61 PUSH2 0x1263 125E 82 DUP3 125F 61 PUSH2 0x20b0 1262 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @125B stack[0] = 0x1263 // @125E stack[1] = stack[-2] // } // Block ends with call to 0x20b0, returns to 0x1263 label_1263: // Incoming return from call to 0x20B0 at 0x1262 // Inputs[4] // { // @1264 stack[-1] // @1264 stack[-2] // @1266 stack[-4] // @1267 stack[-3] // } 1263 5B JUMPDEST 1264 90 SWAP1 1265 50 POP 1266 91 SWAP2 1267 90 SWAP1 1268 50 POP 1269 56 *JUMP // Stack delta = -3 // Outputs[1] { @1266 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_126A: // Incoming jump from 0x05A2 // Inputs[1] { @1284 stack[-1] } 126A 5B JUMPDEST 126B 60 PUSH1 0x00 126D 80 DUP1 126E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1283 16 AND 1284 82 DUP3 1285 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 129A 16 AND 129B 14 EQ 129C 15 ISZERO 129D 61 PUSH2 0x12a5 12A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @126B stack[0] = 0x00 } // Block ends with conditional jump to 0x12a5, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_12A1: // Incoming jump from 0x12A0, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @12A4 memory[0x00:0x00] } 12A1 60 PUSH1 0x00 12A3 80 DUP1 12A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @12A4 revert(memory[0x00:0x00]); } // Block terminates label_12A5: // Incoming jump from 0x12A0, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[5] // { // @12AA stack[-2] // @12E4 memory[0x00:0x40] // @12E5 storage[keccak256(memory[0x00:0x40])] // @12E6 stack[-1] // @12E8 stack[-3] // } 12A5 5B JUMPDEST 12A6 60 PUSH1 0x07 12A8 60 PUSH1 0x00 12AA 83 DUP4 12AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12C0 16 AND 12C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12D6 16 AND 12D7 81 DUP2 12D8 52 MSTORE 12D9 60 PUSH1 0x20 12DB 01 ADD 12DC 90 SWAP1 12DD 81 DUP2 12DE 52 MSTORE 12DF 60 PUSH1 0x20 12E1 01 ADD 12E2 60 PUSH1 0x00 12E4 20 SHA3 12E5 54 SLOAD 12E6 90 SWAP1 12E7 50 POP 12E8 91 SWAP2 12E9 90 SWAP1 12EA 50 POP 12EB 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @12D8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @12DE memory[0x20:0x40] = 0x07 // @12E8 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_12EC: // Incoming call from 0x05C0, returns to 0x05C1 12EC 5B JUMPDEST 12ED 61 PUSH2 0x12f4 12F0 61 PUSH2 0x13e8 12F3 56 *JUMP // Stack delta = +1 // Outputs[1] { @12ED stack[0] = 0x12f4 } // Block ends with call to 0x13e8, returns to 0x12F4 label_12F4: // Incoming return from call to 0x13E8 at 0x12F3 // Inputs[1] { @12F8 stack[-1] } 12F4 5B JUMPDEST 12F5 61 PUSH2 0x12fd 12F8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12fd, if stack[-1] label_12F9: // Incoming jump from 0x12F8, if not stack[-1] // Inputs[1] { @12FC memory[0x00:0x00] } 12F9 60 PUSH1 0x00 12FB 80 DUP1 12FC FD *REVERT // Stack delta = +0 // Outputs[1] { @12FC revert(memory[0x00:0x00]); } // Block terminates label_12FD: // Incoming jump from 0x12F8, if stack[-1] // Inputs[6] // { // @131B storage[0x01] // @1372 memory[0x40:0x60] // @1375 memory[0x40:0x60] // @137A memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1386 storage[0x01] // @13BD stack[-1] // } 12FD 5B JUMPDEST 12FE 60 PUSH1 0x00 1300 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1315 16 AND 1316 60 PUSH1 0x01 1318 60 PUSH1 0x00 131A 90 SWAP1 131B 54 SLOAD 131C 90 SWAP1 131D 61 PUSH2 0x0100 1320 0A EXP 1321 90 SWAP1 1322 04 DIV 1323 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1338 16 AND 1339 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 134E 16 AND 134F 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1370 60 PUSH1 0x40 1372 51 MLOAD 1373 60 PUSH1 0x40 1375 51 MLOAD 1376 80 DUP1 1377 91 SWAP2 1378 03 SUB 1379 90 SWAP1 137A A3 LOG3 137B 60 PUSH1 0x00 137D 60 PUSH1 0x01 137F 60 PUSH1 0x00 1381 61 PUSH2 0x0100 1384 0A EXP 1385 81 DUP2 1386 54 SLOAD 1387 81 DUP2 1388 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 139D 02 MUL 139E 19 NOT 139F 16 AND 13A0 90 SWAP1 13A1 83 DUP4 13A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13B7 16 AND 13B8 02 MUL 13B9 17 OR 13BA 90 SWAP1 13BB 55 SSTORE 13BC 50 POP 13BD 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @137A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // @13BB storage[0x01] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x01]) // } // Block ends with unconditional jump to stack[-1] label_13BE: // Incoming call from 0x05CA, returns to 0x05CB // Inputs[2] // { // @13C6 storage[0x01] // @13E6 stack[-1] // } 13BE 5B JUMPDEST 13BF 60 PUSH1 0x00 13C1 60 PUSH1 0x01 13C3 60 PUSH1 0x00 13C5 90 SWAP1 13C6 54 SLOAD 13C7 90 SWAP1 13C8 61 PUSH2 0x0100 13CB 0A EXP 13CC 90 SWAP1 13CD 04 DIV 13CE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13E3 16 AND 13E4 90 SWAP1 13E5 50 POP 13E6 90 SWAP1 13E7 56 *JUMP // Stack delta = +0 // Outputs[1] { @13E6 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_13E8: // Incoming call from 0x15A5, returns to 0x15A6 // Incoming call from 0x198C, returns to 0x198D // Incoming call from 0x0614, returns to 0x0615 // Incoming call from 0x12F3, returns to 0x12F4 // Incoming call from 0x196F, returns to 0x1970 // Incoming call from 0x1169, returns to 0x116A // Inputs[3] // { // @13F0 storage[0x01] // @1424 msg.sender // @143E stack[-1] // } 13E8 5B JUMPDEST 13E9 60 PUSH1 0x00 13EB 60 PUSH1 0x01 13ED 60 PUSH1 0x00 13EF 90 SWAP1 13F0 54 SLOAD 13F1 90 SWAP1 13F2 61 PUSH2 0x0100 13F5 0A EXP 13F6 90 SWAP1 13F7 04 DIV 13F8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 140D 16 AND 140E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1423 16 AND 1424 33 CALLER 1425 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 143A 16 AND 143B 14 EQ 143C 90 SWAP1 143D 50 POP 143E 90 SWAP1 143F 56 *JUMP // Stack delta = +0 // Outputs[1] { @143E stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x01] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_1440: // Incoming jump from 0x065A // Incoming call from 0x1C05, returns to 0x1C06 // Inputs[5] // { // @1443 block.timestamp // @144C stack[-1] // @145A memory[0x00:0x40] // @145B storage[keccak256(memory[0x00:0x40])] // @1460 stack[-2] // } 1440 5B JUMPDEST 1441 60 PUSH1 0x00 1443 42 TIMESTAMP 1444 62 PUSH3 0x76a700 1448 60 PUSH1 0x09 144A 60 PUSH1 0x00 144C 85 DUP6 144D 81 DUP2 144E 52 MSTORE 144F 60 PUSH1 0x20 1451 01 ADD 1452 90 SWAP1 1453 81 DUP2 1454 52 MSTORE 1455 60 PUSH1 0x20 1457 01 ADD 1458 60 PUSH1 0x00 145A 20 SHA3 145B 54 SLOAD 145C 01 ADD 145D 10 LT 145E 90 SWAP1 145F 50 POP 1460 91 SWAP2 1461 90 SWAP1 1462 50 POP 1463 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @144E memory[0x00:0x20] = stack[-1] // @1454 memory[0x20:0x40] = 0x09 // @1460 stack[-2] = storage[keccak256(memory[0x00:0x40])] + 0x76a700 < block.timestamp // } // Block ends with unconditional jump to stack[-2] label_1464: // Incoming jump from 0x06C2 // Inputs[2] // { // @1465 msg.sender // @147C stack[-2] // } 1464 5B JUMPDEST 1465 33 CALLER 1466 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 147B 16 AND 147C 82 DUP3 147D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1492 16 AND 1493 14 EQ 1494 15 ISZERO 1495 61 PUSH2 0x149d 1498 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x149d, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) label_1499: // Incoming jump from 0x1498, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[1] { @149C memory[0x00:0x00] } 1499 60 PUSH1 0x00 149B 80 DUP1 149C FD *REVERT // Stack delta = +0 // Outputs[1] { @149C revert(memory[0x00:0x00]); } // Block terminates label_149D: // Incoming jump from 0x1498, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & msg.sender) // Inputs[11] // { // @149E stack[-1] // @14A3 msg.sender // @14DD memory[0x00:0x40] // @14E0 stack[-2] // @151A memory[0x00:0x40] // @1522 storage[keccak256(memory[0x00:0x40])] // @1549 msg.sender // @1584 memory[0x40:0x60] // @1595 memory[0x40:0x60] // @159A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @159D stack[-3] // } 149D 5B JUMPDEST 149E 80 DUP1 149F 60 PUSH1 0x08 14A1 60 PUSH1 0x00 14A3 33 CALLER 14A4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14B9 16 AND 14BA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14CF 16 AND 14D0 81 DUP2 14D1 52 MSTORE 14D2 60 PUSH1 0x20 14D4 01 ADD 14D5 90 SWAP1 14D6 81 DUP2 14D7 52 MSTORE 14D8 60 PUSH1 0x20 14DA 01 ADD 14DB 60 PUSH1 0x00 14DD 20 SHA3 14DE 60 PUSH1 0x00 14E0 84 DUP5 14E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14F6 16 AND 14F7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 150C 16 AND 150D 81 DUP2 150E 52 MSTORE 150F 60 PUSH1 0x20 1511 01 ADD 1512 90 SWAP1 1513 81 DUP2 1514 52 MSTORE 1515 60 PUSH1 0x20 1517 01 ADD 1518 60 PUSH1 0x00 151A 20 SHA3 151B 60 PUSH1 0x00 151D 61 PUSH2 0x0100 1520 0A EXP 1521 81 DUP2 1522 54 SLOAD 1523 81 DUP2 1524 60 PUSH1 0xff 1526 02 MUL 1527 19 NOT 1528 16 AND 1529 90 SWAP1 152A 83 DUP4 152B 15 ISZERO 152C 15 ISZERO 152D 02 MUL 152E 17 OR 152F 90 SWAP1 1530 55 SSTORE 1531 50 POP 1532 81 DUP2 1533 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1548 16 AND 1549 33 CALLER 154A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 155F 16 AND 1560 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1581 83 DUP4 1582 60 PUSH1 0x40 1584 51 MLOAD 1585 80 DUP1 1586 82 DUP3 1587 15 ISZERO 1588 15 ISZERO 1589 15 ISZERO 158A 15 ISZERO 158B 81 DUP2 158C 52 MSTORE 158D 60 PUSH1 0x20 158F 01 ADD 1590 91 SWAP2 1591 50 POP 1592 50 POP 1593 60 PUSH1 0x40 1595 51 MLOAD 1596 80 DUP1 1597 91 SWAP2 1598 03 SUB 1599 90 SWAP1 159A A3 LOG3 159B 50 POP 159C 50 POP 159D 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @14D1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @14D7 memory[0x20:0x40] = 0x08 // @150E memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1514 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1530 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @158C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!!!stack[-1] // @159A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-3] label_159E: // Incoming jump from 0x0706 159E 5B JUMPDEST 159F 61 PUSH2 0x15a6 15A2 61 PUSH2 0x13e8 15A5 56 *JUMP // Stack delta = +1 // Outputs[1] { @159F stack[0] = 0x15a6 } // Block ends with call to 0x13e8, returns to 0x15A6 label_15A6: // Incoming return from call to 0x13E8 at 0x15A5 // Inputs[1] { @15AA stack[-1] } 15A6 5B JUMPDEST 15A7 61 PUSH2 0x15af 15AA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15af, if stack[-1] label_15AB: // Incoming jump from 0x15AA, if not stack[-1] // Inputs[1] { @15AE memory[0x00:0x00] } 15AB 60 PUSH1 0x00 15AD 80 DUP1 15AE FD *REVERT // Stack delta = +0 // Outputs[1] { @15AE revert(memory[0x00:0x00]); } // Block terminates label_15AF: // Incoming jump from 0x15AA, if stack[-1] // Inputs[7] // { // @15B6 stack[-1] // @15F0 memory[0x00:0x40] // @15F8 storage[keccak256(memory[0x00:0x40])] // @1642 memory[0x40:0x60] // @1645 memory[0x40:0x60] // @164A memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @164C stack[-2] // } 15AF 5B JUMPDEST 15B0 60 PUSH1 0x01 15B2 60 PUSH1 0x04 15B4 60 PUSH1 0x00 15B6 83 DUP4 15B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15CC 16 AND 15CD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15E2 16 AND 15E3 81 DUP2 15E4 52 MSTORE 15E5 60 PUSH1 0x20 15E7 01 ADD 15E8 90 SWAP1 15E9 81 DUP2 15EA 52 MSTORE 15EB 60 PUSH1 0x20 15ED 01 ADD 15EE 60 PUSH1 0x00 15F0 20 SHA3 15F1 60 PUSH1 0x00 15F3 61 PUSH2 0x0100 15F6 0A EXP 15F7 81 DUP2 15F8 54 SLOAD 15F9 81 DUP2 15FA 60 PUSH1 0xff 15FC 02 MUL 15FD 19 NOT 15FE 16 AND 15FF 90 SWAP1 1600 83 DUP4 1601 15 ISZERO 1602 15 ISZERO 1603 02 MUL 1604 17 OR 1605 90 SWAP1 1606 55 SSTORE 1607 50 POP 1608 80 DUP1 1609 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 161E 16 AND 161F 7F PUSH32 0x0a8bb31534c0ed46f380cb867bd5c803a189ced9a764e30b3a4991a9901d7474 1640 60 PUSH1 0x40 1642 51 MLOAD 1643 60 PUSH1 0x40 1645 51 MLOAD 1646 80 DUP1 1647 91 SWAP2 1648 03 SUB 1649 90 SWAP1 164A A2 LOG2 164B 50 POP 164C 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @15E4 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @15EA memory[0x20:0x40] = 0x04 // @1606 storage[keccak256(memory[0x00:0x40])] = !!0x01 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @164A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x0a8bb31534c0ed46f380cb867bd5c803a189ced9a764e30b3a4991a9901d7474, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-2] label_164D: // Incoming call from 0x115C, returns to 0x115D // Incoming jump from 0x080B // Inputs[3] // { // @1651 stack[-4] // @1652 stack[-3] // @1653 stack[-2] // } 164D 5B JUMPDEST 164E 61 PUSH2 0x1658 1651 84 DUP5 1652 84 DUP5 1653 84 DUP5 1654 61 PUSH2 0x0f09 1657 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @164E stack[0] = 0x1658 // @1651 stack[1] = stack[-4] // @1652 stack[2] = stack[-3] // @1653 stack[3] = stack[-2] // } // Block ends with call to 0x0f09, returns to 0x1658 label_1658: // Incoming return from call to 0x0F09 at 0x1657 // Inputs[4] // { // @165C stack[-4] // @165D stack[-3] // @165E stack[-2] // @165F stack[-1] // } 1658 5B JUMPDEST 1659 61 PUSH2 0x1664 165C 84 DUP5 165D 84 DUP5 165E 84 DUP5 165F 84 DUP5 1660 61 PUSH2 0x212c 1663 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1659 stack[0] = 0x1664 // @165C stack[1] = stack[-4] // @165D stack[2] = stack[-3] // @165E stack[3] = stack[-2] // @165F stack[4] = stack[-1] // } // Block ends with call to 0x212c, returns to 0x1664 label_1664: // Incoming return from call to 0x212C at 0x1663 // Inputs[1] { @1668 stack[-1] } 1664 5B JUMPDEST 1665 61 PUSH2 0x166d 1668 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x166d, if stack[-1] label_1669: // Incoming jump from 0x1668, if not stack[-1] // Inputs[1] { @166C memory[0x00:0x00] } 1669 60 PUSH1 0x00 166B 80 DUP1 166C FD *REVERT // Stack delta = +0 // Outputs[1] { @166C revert(memory[0x00:0x00]); } // Block terminates label_166D: // Incoming jump from 0x1668, if stack[-1] // Inputs[1] { @1672 stack[-5] } 166D 5B JUMPDEST 166E 50 POP 166F 50 POP 1670 50 POP 1671 50 POP 1672 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1673: // Incoming call from 0x0815, returns to 0x0816 // Inputs[1] { @1678 stack[-1] } 1673 5B JUMPDEST 1674 62 PUSH3 0x76a700 1678 81 DUP2 1679 56 *JUMP // Stack delta = +1 // Outputs[1] { @1674 stack[0] = 0x76a700 } // Block ends with unconditional jump to stack[-1] label_167A: // Incoming jump from 0x0861 // Inputs[6] // { // @167D address(this) // @1699 storage[0x02] // @16D4 storage[0x03] // @16D7 memory[0x40:0x60] // @16F5 memory[0x40:0x60] // @16FC address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } 167A 5B JUMPDEST 167B 60 PUSH1 0x00 167D 30 ADDRESS 167E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1693 16 AND 1694 60 PUSH1 0x02 1696 60 PUSH1 0x00 1698 90 SWAP1 1699 54 SLOAD 169A 90 SWAP1 169B 61 PUSH2 0x0100 169E 0A EXP 169F 90 SWAP1 16A0 04 DIV 16A1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16B6 16 AND 16B7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16CC 16 AND 16CD 63 PUSH4 0x02571be3 16D2 60 PUSH1 0x03 16D4 54 SLOAD 16D5 60 PUSH1 0x40 16D7 51 MLOAD 16D8 82 DUP3 16D9 63 PUSH4 0xffffffff 16DE 16 AND 16DF 60 PUSH1 0xe0 16E1 1B SHL 16E2 81 DUP2 16E3 52 MSTORE 16E4 60 PUSH1 0x04 16E6 01 ADD 16E7 80 DUP1 16E8 82 DUP3 16E9 81 DUP2 16EA 52 MSTORE 16EB 60 PUSH1 0x20 16ED 01 ADD 16EE 91 SWAP2 16EF 50 POP 16F0 50 POP 16F1 60 PUSH1 0x20 16F3 60 PUSH1 0x40 16F5 51 MLOAD 16F6 80 DUP1 16F7 83 DUP4 16F8 03 SUB 16F9 81 DUP2 16FA 86 DUP7 16FB 80 DUP1 16FC 3B EXTCODESIZE 16FD 15 ISZERO 16FE 80 DUP1 16FF 15 ISZERO 1700 61 PUSH2 0x1708 1703 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @167B stack[0] = 0x00 // @1693 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @16CC stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @16CD stack[3] = 0x02571be3 // @16E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x02571be3) << 0xe0 // @16EA memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = storage[0x03] // @16EE stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @16F1 stack[5] = 0x20 // @16F5 stack[6] = memory[0x40:0x60] // @16F8 stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @16F9 stack[8] = memory[0x40:0x60] // @16FA stack[9] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @16FD stack[10] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x1708, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length label_1704: // Incoming jump from 0x1703, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[1] { @1707 memory[0x00:0x00] } 1704 60 PUSH1 0x00 1706 80 DUP1 1707 FD *REVERT // Stack delta = +0 // Outputs[1] { @1707 revert(memory[0x00:0x00]); } // Block terminates label_1708: // Incoming jump from 0x1703, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @170A msg.gas // @170B stack[-2] // @170B stack[-4] // @170B memory[stack[-3]:stack[-3] + stack[-4]] // @170B stack[-6] // @170B stack[-3] // @170B address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @170B stack[-5] // } 1708 5B JUMPDEST 1709 50 POP 170A 5A GAS 170B FA STATICCALL 170C 15 ISZERO 170D 80 DUP1 170E 15 ISZERO 170F 61 PUSH2 0x171c 1712 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @170B memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @170C stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x171c, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1713: // Incoming jump from 0x1712, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1713 returndata.length // @1717 returndata[0x00:0x00 + returndata.length] // @1718 returndata.length // @171B memory[0x00:0x00 + returndata.length] // } 1713 3D RETURNDATASIZE 1714 60 PUSH1 0x00 1716 80 DUP1 1717 3E RETURNDATACOPY 1718 3D RETURNDATASIZE 1719 60 PUSH1 0x00 171B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1717 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @171B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_171C: // Incoming jump from 0x1712, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1723 memory[0x40:0x60] // @1724 returndata.length // } 171C 5B JUMPDEST 171D 50 POP 171E 50 POP 171F 50 POP 1720 50 POP 1721 60 PUSH1 0x40 1723 51 MLOAD 1724 3D RETURNDATASIZE 1725 60 PUSH1 0x20 1727 81 DUP2 1728 10 LT 1729 15 ISZERO 172A 61 PUSH2 0x1732 172D 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1723 stack[-4] = memory[0x40:0x60] // @1724 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1732, if !(returndata.length < 0x20) label_172E: // Incoming jump from 0x172D, if not !(returndata.length < 0x20) // Inputs[1] { @1731 memory[0x00:0x00] } 172E 60 PUSH1 0x00 1730 80 DUP1 1731 FD *REVERT // Stack delta = +0 // Outputs[1] { @1731 revert(memory[0x00:0x00]); } // Block terminates label_1732: // Incoming jump from 0x172D, if !(returndata.length < 0x20) // Inputs[4] // { // @1733 stack[-2] // @1734 stack[-1] // @1738 memory[stack[-2]:stack[-2] + 0x20] // @175A stack[-3] // } 1732 5B JUMPDEST 1733 81 DUP2 1734 01 ADD 1735 90 SWAP1 1736 80 DUP1 1737 80 DUP1 1738 51 MLOAD 1739 90 SWAP1 173A 60 PUSH1 0x20 173C 01 ADD 173D 90 SWAP1 173E 92 SWAP3 173F 91 SWAP2 1740 90 SWAP1 1741 50 POP 1742 50 POP 1743 50 POP 1744 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1759 16 AND 175A 14 EQ 175B 61 PUSH2 0x1763 175E 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x1763, if 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] label_175F: // Incoming jump from 0x175E, if not 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[1] { @1762 memory[0x00:0x00] } 175F 60 PUSH1 0x00 1761 80 DUP1 1762 FD *REVERT // Stack delta = +0 // Outputs[1] { @1762 revert(memory[0x00:0x00]); } // Block terminates label_1763: // Incoming jump from 0x175E, if 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[3] // { // @1768 msg.sender // @17A2 memory[0x00:0x40] // @17A6 storage[keccak256(memory[0x00:0x40])] // } 1763 5B JUMPDEST 1764 60 PUSH1 0x04 1766 60 PUSH1 0x00 1768 33 CALLER 1769 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 177E 16 AND 177F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1794 16 AND 1795 81 DUP2 1796 52 MSTORE 1797 60 PUSH1 0x20 1799 01 ADD 179A 90 SWAP1 179B 81 DUP2 179C 52 MSTORE 179D 60 PUSH1 0x20 179F 01 ADD 17A0 60 PUSH1 0x00 17A2 20 SHA3 17A3 60 PUSH1 0x00 17A5 90 SWAP1 17A6 54 SLOAD 17A7 90 SWAP1 17A8 61 PUSH2 0x0100 17AB 0A EXP 17AC 90 SWAP1 17AD 04 DIV 17AE 60 PUSH1 0xff 17B0 16 AND 17B1 61 PUSH2 0x17b9 17B4 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1796 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @179C memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x17b9, if 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 label_17B5: // Incoming jump from 0x17B4, if not 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // Inputs[1] { @17B8 memory[0x00:0x00] } 17B5 60 PUSH1 0x00 17B7 80 DUP1 17B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @17B8 revert(memory[0x00:0x00]); } // Block terminates label_17B9: // Incoming jump from 0x17B4, if 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // Inputs[4] // { // @17BA block.timestamp // @17C3 stack[-3] // @17D1 memory[0x00:0x40] // @17D2 storage[keccak256(memory[0x00:0x40])] // } 17B9 5B JUMPDEST 17BA 42 TIMESTAMP 17BB 62 PUSH3 0x76a700 17BF 60 PUSH1 0x09 17C1 60 PUSH1 0x00 17C3 86 DUP7 17C4 81 DUP2 17C5 52 MSTORE 17C6 60 PUSH1 0x20 17C8 01 ADD 17C9 90 SWAP1 17CA 81 DUP2 17CB 52 MSTORE 17CC 60 PUSH1 0x20 17CE 01 ADD 17CF 60 PUSH1 0x00 17D1 20 SHA3 17D2 54 SLOAD 17D3 01 ADD 17D4 10 LT 17D5 15 ISZERO 17D6 61 PUSH2 0x17de 17D9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @17C5 memory[0x00:0x20] = stack[-3] // @17CB memory[0x20:0x40] = 0x09 // } // Block ends with conditional jump to 0x17de, if !(storage[keccak256(memory[0x00:0x40])] + 0x76a700 < block.timestamp) label_17DA: // Incoming jump from 0x17D9, if not !(storage[keccak256(memory[0x00:0x40])] + 0x76a700 < block.timestamp) // Inputs[1] { @17DD memory[0x00:0x00] } 17DA 60 PUSH1 0x00 17DC 80 DUP1 17DD FD *REVERT // Stack delta = +0 // Outputs[1] { @17DD revert(memory[0x00:0x00]); } // Block terminates label_17DE: // Incoming jump from 0x17D9, if !(storage[keccak256(memory[0x00:0x40])] + 0x76a700 < block.timestamp) // Inputs[4] // { // @17E3 stack[-2] // @17EE stack[-3] // @17FC memory[0x00:0x40] // @17FD storage[keccak256(memory[0x00:0x40])] // } 17DE 5B JUMPDEST 17DF 62 PUSH3 0x76a700 17E3 82 DUP3 17E4 01 ADD 17E5 62 PUSH3 0x76a700 17E9 83 DUP4 17EA 60 PUSH1 0x09 17EC 60 PUSH1 0x00 17EE 87 DUP8 17EF 81 DUP2 17F0 52 MSTORE 17F1 60 PUSH1 0x20 17F3 01 ADD 17F4 90 SWAP1 17F5 81 DUP2 17F6 52 MSTORE 17F7 60 PUSH1 0x20 17F9 01 ADD 17FA 60 PUSH1 0x00 17FC 20 SHA3 17FD 54 SLOAD 17FE 01 ADD 17FF 01 ADD 1800 11 GT 1801 61 PUSH2 0x1809 1804 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @17F0 memory[0x00:0x20] = stack[-3] // @17F6 memory[0x20:0x40] = 0x09 // } // Block ends with conditional jump to 0x1809, if storage[keccak256(memory[0x00:0x40])] + stack[-2] + 0x76a700 > stack[-2] + 0x76a700 label_1805: // Incoming jump from 0x1804, if not storage[keccak256(memory[0x00:0x40])] + stack[-2] + 0x76a700 > stack[-2] + 0x76a700 // Inputs[1] { @1808 memory[0x00:0x00] } 1805 60 PUSH1 0x00 1807 80 DUP1 1808 FD *REVERT // Stack delta = +0 // Outputs[1] { @1808 revert(memory[0x00:0x00]); } // Block terminates label_1809: // Incoming jump from 0x1804, if storage[keccak256(memory[0x00:0x40])] + stack[-2] + 0x76a700 > stack[-2] + 0x76a700 // Inputs[13] // { // @180A stack[-2] // @180F stack[-3] // @181D memory[0x00:0x40] // @1822 storage[keccak256(memory[0x00:0x40])] // @185F memory[0x00:0x40] // @1860 storage[keccak256(memory[0x00:0x40])] // @1863 memory[0x40:0x60] // @1870 memory[0x40:0x60] // @1875 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1888 memory[0x00:0x40] // @1889 storage[keccak256(memory[0x00:0x40])] // @188A stack[-1] // @188C stack[-4] // } 1809 5B JUMPDEST 180A 81 DUP2 180B 60 PUSH1 0x09 180D 60 PUSH1 0x00 180F 85 DUP6 1810 81 DUP2 1811 52 MSTORE 1812 60 PUSH1 0x20 1814 01 ADD 1815 90 SWAP1 1816 81 DUP2 1817 52 MSTORE 1818 60 PUSH1 0x20 181A 01 ADD 181B 60 PUSH1 0x00 181D 20 SHA3 181E 60 PUSH1 0x00 1820 82 DUP3 1821 82 DUP3 1822 54 SLOAD 1823 01 ADD 1824 92 SWAP3 1825 50 POP 1826 50 POP 1827 81 DUP2 1828 90 SWAP1 1829 55 SSTORE 182A 50 POP 182B 82 DUP3 182C 7F PUSH32 0x9b87a00e30f1ac65d898f070f8a3488fe60517182d0a2098e1b4b93a54aa9bd6 184D 60 PUSH1 0x09 184F 60 PUSH1 0x00 1851 86 DUP7 1852 81 DUP2 1853 52 MSTORE 1854 60 PUSH1 0x20 1856 01 ADD 1857 90 SWAP1 1858 81 DUP2 1859 52 MSTORE 185A 60 PUSH1 0x20 185C 01 ADD 185D 60 PUSH1 0x00 185F 20 SHA3 1860 54 SLOAD 1861 60 PUSH1 0x40 1863 51 MLOAD 1864 80 DUP1 1865 82 DUP3 1866 81 DUP2 1867 52 MSTORE 1868 60 PUSH1 0x20 186A 01 ADD 186B 91 SWAP2 186C 50 POP 186D 50 POP 186E 60 PUSH1 0x40 1870 51 MLOAD 1871 80 DUP1 1872 91 SWAP2 1873 03 SUB 1874 90 SWAP1 1875 A2 LOG2 1876 60 PUSH1 0x09 1878 60 PUSH1 0x00 187A 84 DUP5 187B 81 DUP2 187C 52 MSTORE 187D 60 PUSH1 0x20 187F 01 ADD 1880 90 SWAP1 1881 81 DUP2 1882 52 MSTORE 1883 60 PUSH1 0x20 1885 01 ADD 1886 60 PUSH1 0x00 1888 20 SHA3 1889 54 SLOAD 188A 90 SWAP1 188B 50 POP 188C 92 SWAP3 188D 91 SWAP2 188E 50 POP 188F 50 POP 1890 56 *JUMP // Stack delta = -3 // Outputs[10] // { // @1811 memory[0x00:0x20] = stack[-3] // @1817 memory[0x20:0x40] = 0x09 // @1829 storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] + stack[-2] // @1853 memory[0x00:0x20] = stack[-3] // @1859 memory[0x20:0x40] = 0x09 // @1867 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] // @1875 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x9b87a00e30f1ac65d898f070f8a3488fe60517182d0a2098e1b4b93a54aa9bd6, stack[-3]]); // @187C memory[0x00:0x20] = stack[-3] // @1882 memory[0x20:0x40] = 0x09 // @188C stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_1891: // Incoming jump from 0x08A3 // Inputs[4] // { // @1898 stack[-1] // @18A6 memory[0x00:0x40] // @18A7 storage[keccak256(memory[0x00:0x40])] // @18AA stack[-2] // } 1891 5B JUMPDEST 1892 60 PUSH1 0x00 1894 60 PUSH1 0x09 1896 60 PUSH1 0x00 1898 83 DUP4 1899 81 DUP2 189A 52 MSTORE 189B 60 PUSH1 0x20 189D 01 ADD 189E 90 SWAP1 189F 81 DUP2 18A0 52 MSTORE 18A1 60 PUSH1 0x20 18A3 01 ADD 18A4 60 PUSH1 0x00 18A6 20 SHA3 18A7 54 SLOAD 18A8 90 SWAP1 18A9 50 POP 18AA 91 SWAP2 18AB 90 SWAP1 18AC 50 POP 18AD 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @189A memory[0x00:0x20] = stack[-1] // @18A0 memory[0x20:0x40] = 0x09 // @18AA stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_18AE: // Incoming jump from 0x08FB // Inputs[4] // { // @18B4 stack[-1] // @18BC memory[0x00:0x40] // @18C1 storage[keccak256(memory[0x00:0x40])] // @18CC stack[-2] // } 18AE 5B JUMPDEST 18AF 60 PUSH1 0x04 18B1 60 PUSH1 0x20 18B3 52 MSTORE 18B4 80 DUP1 18B5 60 PUSH1 0x00 18B7 52 MSTORE 18B8 60 PUSH1 0x40 18BA 60 PUSH1 0x00 18BC 20 SHA3 18BD 60 PUSH1 0x00 18BF 91 SWAP2 18C0 50 POP 18C1 54 SLOAD 18C2 90 SWAP1 18C3 61 PUSH2 0x0100 18C6 0A EXP 18C7 90 SWAP1 18C8 04 DIV 18C9 60 PUSH1 0xff 18CB 16 AND 18CC 81 DUP2 18CD 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @18B3 memory[0x20:0x40] = 0x04 // @18B7 memory[0x00:0x20] = stack[-1] // @18CB stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_18CE: // Incoming call from 0x091D, returns to 0x091E // Inputs[2] // { // @18D1 storage[0x03] // @18D2 stack[-1] // } 18CE 5B JUMPDEST 18CF 60 PUSH1 0x03 18D1 54 SLOAD 18D2 81 DUP2 18D3 56 *JUMP // Stack delta = +1 // Outputs[1] { @18D1 stack[0] = storage[0x03] } // Block ends with unconditional jump to stack[-1] label_18D4: // Incoming call from 0x1E44, returns to 0x1E45 // Incoming jump from 0x0995 // Incoming call from 0x0E34, returns to 0x0E35 // Inputs[6] // { // @18DB stack[-2] // @1915 memory[0x00:0x40] // @1918 stack[-1] // @1952 memory[0x00:0x40] // @1956 storage[keccak256(memory[0x00:0x40])] // @1963 stack[-3] // } 18D4 5B JUMPDEST 18D5 60 PUSH1 0x00 18D7 60 PUSH1 0x08 18D9 60 PUSH1 0x00 18DB 84 DUP5 18DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18F1 16 AND 18F2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1907 16 AND 1908 81 DUP2 1909 52 MSTORE 190A 60 PUSH1 0x20 190C 01 ADD 190D 90 SWAP1 190E 81 DUP2 190F 52 MSTORE 1910 60 PUSH1 0x20 1912 01 ADD 1913 60 PUSH1 0x00 1915 20 SHA3 1916 60 PUSH1 0x00 1918 83 DUP4 1919 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 192E 16 AND 192F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1944 16 AND 1945 81 DUP2 1946 52 MSTORE 1947 60 PUSH1 0x20 1949 01 ADD 194A 90 SWAP1 194B 81 DUP2 194C 52 MSTORE 194D 60 PUSH1 0x20 194F 01 ADD 1950 60 PUSH1 0x00 1952 20 SHA3 1953 60 PUSH1 0x00 1955 90 SWAP1 1956 54 SLOAD 1957 90 SWAP1 1958 61 PUSH2 0x0100 195B 0A EXP 195C 90 SWAP1 195D 04 DIV 195E 60 PUSH1 0xff 1960 16 AND 1961 90 SWAP1 1962 50 POP 1963 92 SWAP3 1964 91 SWAP2 1965 50 POP 1966 50 POP 1967 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @1909 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @190F memory[0x20:0x40] = 0x08 // @1946 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @194C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1963 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_1968: // Incoming jump from 0x09F1 1968 5B JUMPDEST 1969 61 PUSH2 0x1970 196C 61 PUSH2 0x13e8 196F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1969 stack[0] = 0x1970 } // Block ends with call to 0x13e8, returns to 0x1970 label_1970: // Incoming return from call to 0x13E8 at 0x196F // Inputs[1] { @1974 stack[-1] } 1970 5B JUMPDEST 1971 61 PUSH2 0x1979 1974 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1979, if stack[-1] label_1975: // Incoming jump from 0x1974, if not stack[-1] // Inputs[1] { @1978 memory[0x00:0x00] } 1975 60 PUSH1 0x00 1977 80 DUP1 1978 FD *REVERT // Stack delta = +0 // Outputs[1] { @1978 revert(memory[0x00:0x00]); } // Block terminates label_1979: // Incoming jump from 0x1974, if stack[-1] // Inputs[1] { @197D stack[-1] } 1979 5B JUMPDEST 197A 61 PUSH2 0x1982 197D 81 DUP2 197E 61 PUSH2 0x2315 1981 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @197A stack[0] = 0x1982 // @197D stack[1] = stack[-1] // } // Block ends with call to 0x2315, returns to 0x1982 label_1982: // Incoming return from call to 0x2315 at 0x1981 // Inputs[1] { @1984 stack[-2] } 1982 5B JUMPDEST 1983 50 POP 1984 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1985: // Incoming jump from 0x0A35 1985 5B JUMPDEST 1986 61 PUSH2 0x198d 1989 61 PUSH2 0x13e8 198C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1986 stack[0] = 0x198d } // Block ends with call to 0x13e8, returns to 0x198D label_198D: // Incoming return from call to 0x13E8 at 0x198C // Inputs[1] { @1991 stack[-1] } 198D 5B JUMPDEST 198E 61 PUSH2 0x1996 1991 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1996, if stack[-1] label_1992: // Incoming jump from 0x1991, if not stack[-1] // Inputs[1] { @1995 memory[0x00:0x00] } 1992 60 PUSH1 0x00 1994 80 DUP1 1995 FD *REVERT // Stack delta = +0 // Outputs[1] { @1995 revert(memory[0x00:0x00]); } // Block terminates label_1996: // Incoming jump from 0x1991, if stack[-1] // Inputs[7] // { // @199D stack[-1] // @19D7 memory[0x00:0x40] // @19DF storage[keccak256(memory[0x00:0x40])] // @1A29 memory[0x40:0x60] // @1A2C memory[0x40:0x60] // @1A31 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1A33 stack[-2] // } 1996 5B JUMPDEST 1997 60 PUSH1 0x00 1999 60 PUSH1 0x04 199B 60 PUSH1 0x00 199D 83 DUP4 199E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19B3 16 AND 19B4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19C9 16 AND 19CA 81 DUP2 19CB 52 MSTORE 19CC 60 PUSH1 0x20 19CE 01 ADD 19CF 90 SWAP1 19D0 81 DUP2 19D1 52 MSTORE 19D2 60 PUSH1 0x20 19D4 01 ADD 19D5 60 PUSH1 0x00 19D7 20 SHA3 19D8 60 PUSH1 0x00 19DA 61 PUSH2 0x0100 19DD 0A EXP 19DE 81 DUP2 19DF 54 SLOAD 19E0 81 DUP2 19E1 60 PUSH1 0xff 19E3 02 MUL 19E4 19 NOT 19E5 16 AND 19E6 90 SWAP1 19E7 83 DUP4 19E8 15 ISZERO 19E9 15 ISZERO 19EA 02 MUL 19EB 17 OR 19EC 90 SWAP1 19ED 55 SSTORE 19EE 50 POP 19EF 80 DUP1 19F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A05 16 AND 1A06 7F PUSH32 0x33d83959be2573f5453b12eb9d43b3499bc57d96bd2f067ba44803c859e81113 1A27 60 PUSH1 0x40 1A29 51 MLOAD 1A2A 60 PUSH1 0x40 1A2C 51 MLOAD 1A2D 80 DUP1 1A2E 91 SWAP2 1A2F 03 SUB 1A30 90 SWAP1 1A31 A2 LOG2 1A32 50 POP 1A33 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @19CB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @19D1 memory[0x20:0x40] = 0x04 // @19ED storage[keccak256(memory[0x00:0x40])] = !!0x00 * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1A31 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x33d83959be2573f5453b12eb9d43b3499bc57d96bd2f067ba44803c859e81113, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-2] label_1A34: // Incoming jump from 0x0A8D // Inputs[3] // { // @1A3A stack[-3] // @1A3B stack[-2] // @1A3C stack[-1] // } 1A34 5B JUMPDEST 1A35 60 PUSH1 0x00 1A37 61 PUSH2 0x1a43 1A3A 84 DUP5 1A3B 84 DUP5 1A3C 84 DUP5 1A3D 60 PUSH1 0x01 1A3F 61 PUSH2 0x1abe 1A42 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1A35 stack[0] = 0x00 // @1A37 stack[1] = 0x1a43 // @1A3A stack[2] = stack[-3] // @1A3B stack[3] = stack[-2] // @1A3C stack[4] = stack[-1] // @1A3D stack[5] = 0x01 // } // Block ends with call to 0x1abe, returns to 0x1A43 label_1A43: // Incoming return from call to 0x1ABE at 0x1A42 // Inputs[4] // { // @1A44 stack[-2] // @1A44 stack[-1] // @1A46 stack[-6] // @1A47 stack[-5] // } 1A43 5B JUMPDEST 1A44 90 SWAP1 1A45 50 POP 1A46 93 SWAP4 1A47 92 SWAP3 1A48 50 POP 1A49 50 POP 1A4A 50 POP 1A4B 56 *JUMP // Stack delta = -5 // Outputs[1] { @1A46 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1A4C: // Incoming call from 0x2466, returns to 0x2467 // Incoming call from 0x0D6B, returns to 0x0D6C // Incoming call from 0x1C49, returns to 0x1C4A // Inputs[4] // { // @1A54 stack[-1] // @1A62 memory[0x00:0x40] // @1A66 storage[keccak256(memory[0x00:0x40])] // @1ABA stack[-2] // } 1A4C 5B JUMPDEST 1A4D 60 PUSH1 0x00 1A4F 80 DUP1 1A50 60 PUSH1 0x05 1A52 60 PUSH1 0x00 1A54 84 DUP5 1A55 81 DUP2 1A56 52 MSTORE 1A57 60 PUSH1 0x20 1A59 01 ADD 1A5A 90 SWAP1 1A5B 81 DUP2 1A5C 52 MSTORE 1A5D 60 PUSH1 0x20 1A5F 01 ADD 1A60 60 PUSH1 0x00 1A62 20 SHA3 1A63 60 PUSH1 0x00 1A65 90 SWAP1 1A66 54 SLOAD 1A67 90 SWAP1 1A68 61 PUSH2 0x0100 1A6B 0A EXP 1A6C 90 SWAP1 1A6D 04 DIV 1A6E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A83 16 AND 1A84 90 SWAP1 1A85 50 POP 1A86 60 PUSH1 0x00 1A88 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A9D 16 AND 1A9E 81 DUP2 1A9F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AB4 16 AND 1AB5 14 EQ 1AB6 15 ISZERO 1AB7 91 SWAP2 1AB8 50 POP 1AB9 50 POP 1ABA 91 SWAP2 1ABB 90 SWAP1 1ABC 50 POP 1ABD 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1A56 memory[0x00:0x20] = stack[-1] // @1A5C memory[0x20:0x40] = 0x05 // @1ABA stack[-2] = !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // } // Block ends with unconditional jump to stack[-2] label_1ABE: // Incoming call from 0x1A42, returns to 0x1A43 // Incoming call from 0x0EFF, returns to 0x0F00 // Inputs[6] // { // @1AC1 address(this) // @1ADD storage[0x02] // @1B18 storage[0x03] // @1B1B memory[0x40:0x60] // @1B39 memory[0x40:0x60] // @1B40 address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } 1ABE 5B JUMPDEST 1ABF 60 PUSH1 0x00 1AC1 30 ADDRESS 1AC2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AD7 16 AND 1AD8 60 PUSH1 0x02 1ADA 60 PUSH1 0x00 1ADC 90 SWAP1 1ADD 54 SLOAD 1ADE 90 SWAP1 1ADF 61 PUSH2 0x0100 1AE2 0A EXP 1AE3 90 SWAP1 1AE4 04 DIV 1AE5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AFA 16 AND 1AFB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B10 16 AND 1B11 63 PUSH4 0x02571be3 1B16 60 PUSH1 0x03 1B18 54 SLOAD 1B19 60 PUSH1 0x40 1B1B 51 MLOAD 1B1C 82 DUP3 1B1D 63 PUSH4 0xffffffff 1B22 16 AND 1B23 60 PUSH1 0xe0 1B25 1B SHL 1B26 81 DUP2 1B27 52 MSTORE 1B28 60 PUSH1 0x04 1B2A 01 ADD 1B2B 80 DUP1 1B2C 82 DUP3 1B2D 81 DUP2 1B2E 52 MSTORE 1B2F 60 PUSH1 0x20 1B31 01 ADD 1B32 91 SWAP2 1B33 50 POP 1B34 50 POP 1B35 60 PUSH1 0x20 1B37 60 PUSH1 0x40 1B39 51 MLOAD 1B3A 80 DUP1 1B3B 83 DUP4 1B3C 03 SUB 1B3D 81 DUP2 1B3E 86 DUP7 1B3F 80 DUP1 1B40 3B EXTCODESIZE 1B41 15 ISZERO 1B42 80 DUP1 1B43 15 ISZERO 1B44 61 PUSH2 0x1b4c 1B47 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @1ABF stack[0] = 0x00 // @1AD7 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @1B10 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @1B11 stack[3] = 0x02571be3 // @1B27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x02571be3) << 0xe0 // @1B2E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = storage[0x03] // @1B32 stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @1B35 stack[5] = 0x20 // @1B39 stack[6] = memory[0x40:0x60] // @1B3C stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1B3D stack[8] = memory[0x40:0x60] // @1B3E stack[9] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @1B41 stack[10] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x1b4c, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length label_1B48: // Incoming jump from 0x1B47, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[1] { @1B4B memory[0x00:0x00] } 1B48 60 PUSH1 0x00 1B4A 80 DUP1 1B4B FD *REVERT // Stack delta = +0 // Outputs[1] { @1B4B revert(memory[0x00:0x00]); } // Block terminates label_1B4C: // Incoming jump from 0x1B47, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[8] // { // @1B4E msg.gas // @1B4F stack[-3] // @1B4F stack[-2] // @1B4F stack[-4] // @1B4F memory[stack[-3]:stack[-3] + stack[-4]] // @1B4F stack[-5] // @1B4F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1B4F stack[-6] // } 1B4C 5B JUMPDEST 1B4D 50 POP 1B4E 5A GAS 1B4F FA STATICCALL 1B50 15 ISZERO 1B51 80 DUP1 1B52 15 ISZERO 1B53 61 PUSH2 0x1b60 1B56 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1B4F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1B50 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1b60, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1B57: // Incoming jump from 0x1B56, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1B57 returndata.length // @1B5B returndata[0x00:0x00 + returndata.length] // @1B5C returndata.length // @1B5F memory[0x00:0x00 + returndata.length] // } 1B57 3D RETURNDATASIZE 1B58 60 PUSH1 0x00 1B5A 80 DUP1 1B5B 3E RETURNDATACOPY 1B5C 3D RETURNDATASIZE 1B5D 60 PUSH1 0x00 1B5F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B5B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1B5F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1B60: // Incoming jump from 0x1B56, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1B67 memory[0x40:0x60] // @1B68 returndata.length // } 1B60 5B JUMPDEST 1B61 50 POP 1B62 50 POP 1B63 50 POP 1B64 50 POP 1B65 60 PUSH1 0x40 1B67 51 MLOAD 1B68 3D RETURNDATASIZE 1B69 60 PUSH1 0x20 1B6B 81 DUP2 1B6C 10 LT 1B6D 15 ISZERO 1B6E 61 PUSH2 0x1b76 1B71 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1B67 stack[-4] = memory[0x40:0x60] // @1B68 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1b76, if !(returndata.length < 0x20) label_1B72: // Incoming jump from 0x1B71, if not !(returndata.length < 0x20) // Inputs[1] { @1B75 memory[0x00:0x00] } 1B72 60 PUSH1 0x00 1B74 80 DUP1 1B75 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B75 revert(memory[0x00:0x00]); } // Block terminates label_1B76: // Incoming jump from 0x1B71, if !(returndata.length < 0x20) // Inputs[4] // { // @1B77 stack[-2] // @1B78 stack[-1] // @1B7C memory[stack[-2]:stack[-2] + 0x20] // @1B9E stack[-3] // } 1B76 5B JUMPDEST 1B77 81 DUP2 1B78 01 ADD 1B79 90 SWAP1 1B7A 80 DUP1 1B7B 80 DUP1 1B7C 51 MLOAD 1B7D 90 SWAP1 1B7E 60 PUSH1 0x20 1B80 01 ADD 1B81 90 SWAP1 1B82 92 SWAP3 1B83 91 SWAP2 1B84 90 SWAP1 1B85 50 POP 1B86 50 POP 1B87 50 POP 1B88 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B9D 16 AND 1B9E 14 EQ 1B9F 61 PUSH2 0x1ba7 1BA2 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x1ba7, if 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] label_1BA3: // Incoming jump from 0x1BA2, if not 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[1] { @1BA6 memory[0x00:0x00] } 1BA3 60 PUSH1 0x00 1BA5 80 DUP1 1BA6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BA6 revert(memory[0x00:0x00]); } // Block terminates label_1BA7: // Incoming jump from 0x1BA2, if 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[3] // { // @1BAC msg.sender // @1BE6 memory[0x00:0x40] // @1BEA storage[keccak256(memory[0x00:0x40])] // } 1BA7 5B JUMPDEST 1BA8 60 PUSH1 0x04 1BAA 60 PUSH1 0x00 1BAC 33 CALLER 1BAD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BC2 16 AND 1BC3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BD8 16 AND 1BD9 81 DUP2 1BDA 52 MSTORE 1BDB 60 PUSH1 0x20 1BDD 01 ADD 1BDE 90 SWAP1 1BDF 81 DUP2 1BE0 52 MSTORE 1BE1 60 PUSH1 0x20 1BE3 01 ADD 1BE4 60 PUSH1 0x00 1BE6 20 SHA3 1BE7 60 PUSH1 0x00 1BE9 90 SWAP1 1BEA 54 SLOAD 1BEB 90 SWAP1 1BEC 61 PUSH2 0x0100 1BEF 0A EXP 1BF0 90 SWAP1 1BF1 04 DIV 1BF2 60 PUSH1 0xff 1BF4 16 AND 1BF5 61 PUSH2 0x1bfd 1BF8 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BDA memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @1BE0 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x1bfd, if 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 label_1BF9: // Incoming jump from 0x1BF8, if not 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // Inputs[1] { @1BFC memory[0x00:0x00] } 1BF9 60 PUSH1 0x00 1BFB 80 DUP1 1BFC FD *REVERT // Stack delta = +0 // Outputs[1] { @1BFC revert(memory[0x00:0x00]); } // Block terminates label_1BFD: // Incoming jump from 0x1BF8, if 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // Inputs[1] { @1C01 stack[-5] } 1BFD 5B JUMPDEST 1BFE 61 PUSH2 0x1c06 1C01 85 DUP6 1C02 61 PUSH2 0x1440 1C05 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BFE stack[0] = 0x1c06 // @1C01 stack[1] = stack[-5] // } // Block ends with call to 0x1440, returns to 0x1C06 label_1C06: // Incoming return from call to 0x1440 at 0x1C05 // Inputs[1] { @1C0A stack[-1] } 1C06 5B JUMPDEST 1C07 61 PUSH2 0x1c0f 1C0A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c0f, if stack[-1] label_1C0B: // Incoming jump from 0x1C0A, if not stack[-1] // Inputs[1] { @1C0E memory[0x00:0x00] } 1C0B 60 PUSH1 0x00 1C0D 80 DUP1 1C0E FD *REVERT // Stack delta = +0 // Outputs[1] { @1C0E revert(memory[0x00:0x00]); } // Block terminates label_1C0F: // Incoming jump from 0x1C0A, if stack[-1] // Inputs[3] // { // @1C14 block.timestamp // @1C1A stack[-3] // @1C1B block.timestamp // } 1C0F 5B JUMPDEST 1C10 62 PUSH3 0x76a700 1C14 42 TIMESTAMP 1C15 01 ADD 1C16 62 PUSH3 0x76a700 1C1A 84 DUP5 1C1B 42 TIMESTAMP 1C1C 01 ADD 1C1D 01 ADD 1C1E 11 GT 1C1F 61 PUSH2 0x1c27 1C22 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c27, if block.timestamp + stack[-3] + 0x76a700 > block.timestamp + 0x76a700 label_1C23: // Incoming jump from 0x1C22, if not block.timestamp + stack[-3] + 0x76a700 > block.timestamp + 0x76a700 // Inputs[1] { @1C26 memory[0x00:0x00] } 1C23 60 PUSH1 0x00 1C25 80 DUP1 1C26 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C26 revert(memory[0x00:0x00]); } // Block terminates label_1C27: // Incoming jump from 0x1C22, if block.timestamp + stack[-3] + 0x76a700 > block.timestamp + 0x76a700 // Inputs[4] // { // @1C28 stack[-3] // @1C29 block.timestamp // @1C2F stack[-5] // @1C3D memory[0x00:0x40] // } 1C27 5B JUMPDEST 1C28 82 DUP3 1C29 42 TIMESTAMP 1C2A 01 ADD 1C2B 60 PUSH1 0x09 1C2D 60 PUSH1 0x00 1C2F 87 DUP8 1C30 81 DUP2 1C31 52 MSTORE 1C32 60 PUSH1 0x20 1C34 01 ADD 1C35 90 SWAP1 1C36 81 DUP2 1C37 52 MSTORE 1C38 60 PUSH1 0x20 1C3A 01 ADD 1C3B 60 PUSH1 0x00 1C3D 20 SHA3 1C3E 81 DUP2 1C3F 90 SWAP1 1C40 55 SSTORE 1C41 50 POP 1C42 61 PUSH2 0x1c4a 1C45 85 DUP6 1C46 61 PUSH2 0x1a4c 1C49 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @1C31 memory[0x00:0x20] = stack[-5] // @1C37 memory[0x20:0x40] = 0x09 // @1C40 storage[keccak256(memory[0x00:0x40])] = block.timestamp + stack[-3] // @1C42 stack[0] = 0x1c4a // @1C45 stack[1] = stack[-5] // } // Block ends with call to 0x1a4c, returns to 0x1C4A label_1C4A: // Incoming return from call to 0x1A4C at 0x1C49 // Inputs[1] { @1C4B stack[-1] } 1C4A 5B JUMPDEST 1C4B 15 ISZERO 1C4C 61 PUSH2 0x1c59 1C4F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1c59, if !stack[-1] label_1C50: // Incoming jump from 0x1C4F, if not !stack[-1] // Inputs[1] { @1C53 stack[-5] } 1C50 61 PUSH2 0x1c58 1C53 85 DUP6 1C54 61 PUSH2 0x240f 1C57 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C50 stack[0] = 0x1c58 // @1C53 stack[1] = stack[-5] // } // Block ends with call to 0x240f, returns to 0x1C58 label_1C58: // Incoming return from call to 0x240F at 0x1C57 1C58 5B JUMPDEST // Stack delta = +0 // Block continues label_1C59: // Incoming jump from 0x1C58 // Incoming jump from 0x1C4F, if !stack[-1] // Inputs[2] // { // @1C5D stack[-4] // @1C5E stack[-5] // } 1C59 5B JUMPDEST 1C5A 61 PUSH2 0x1c63 1C5D 84 DUP5 1C5E 86 DUP7 1C5F 61 PUSH2 0x2424 1C62 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C5A stack[0] = 0x1c63 // @1C5D stack[1] = stack[-4] // @1C5E stack[2] = stack[-5] // } // Block ends with call to 0x2424, returns to 0x1C63 label_1C63: // Incoming return from call to 0x2424 at 0x1C62 // Inputs[1] { @1C64 stack[-2] } 1C63 5B JUMPDEST 1C64 81 DUP2 1C65 15 ISZERO 1C66 61 PUSH2 0x1d5c 1C69 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d5c, if !stack[-2] label_1C6A: // Incoming jump from 0x1C69, if not !stack[-2] // Inputs[7] // { // @1C6F storage[0x02] // @1CAA storage[0x03] // @1CAB stack[-5] // @1CAF stack[-4] // @1CB2 memory[0x40:0x60] // @1D0A memory[0x40:0x60] // @1D13 address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } 1C6A 60 PUSH1 0x02 1C6C 60 PUSH1 0x00 1C6E 90 SWAP1 1C6F 54 SLOAD 1C70 90 SWAP1 1C71 61 PUSH2 0x0100 1C74 0A EXP 1C75 90 SWAP1 1C76 04 DIV 1C77 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C8C 16 AND 1C8D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CA2 16 AND 1CA3 63 PUSH4 0x06ab5923 1CA8 60 PUSH1 0x03 1CAA 54 SLOAD 1CAB 87 DUP8 1CAC 60 PUSH1 0x00 1CAE 1B SHL 1CAF 87 DUP8 1CB0 60 PUSH1 0x40 1CB2 51 MLOAD 1CB3 84 DUP5 1CB4 63 PUSH4 0xffffffff 1CB9 16 AND 1CBA 60 PUSH1 0xe0 1CBC 1B SHL 1CBD 81 DUP2 1CBE 52 MSTORE 1CBF 60 PUSH1 0x04 1CC1 01 ADD 1CC2 80 DUP1 1CC3 84 DUP5 1CC4 81 DUP2 1CC5 52 MSTORE 1CC6 60 PUSH1 0x20 1CC8 01 ADD 1CC9 83 DUP4 1CCA 81 DUP2 1CCB 52 MSTORE 1CCC 60 PUSH1 0x20 1CCE 01 ADD 1CCF 82 DUP3 1CD0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CE5 16 AND 1CE6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CFB 16 AND 1CFC 81 DUP2 1CFD 52 MSTORE 1CFE 60 PUSH1 0x20 1D00 01 ADD 1D01 93 SWAP4 1D02 50 POP 1D03 50 POP 1D04 50 POP 1D05 50 POP 1D06 60 PUSH1 0x20 1D08 60 PUSH1 0x40 1D0A 51 MLOAD 1D0B 80 DUP1 1D0C 83 DUP4 1D0D 03 SUB 1D0E 81 DUP2 1D0F 60 PUSH1 0x00 1D11 87 DUP8 1D12 80 DUP1 1D13 3B EXTCODESIZE 1D14 15 ISZERO 1D15 80 DUP1 1D16 15 ISZERO 1D17 61 PUSH2 0x1d1f 1D1A 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @1CA2 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @1CA3 stack[1] = 0x06ab5923 // @1CBE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x06ab5923) << 0xe0 // @1CC5 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = storage[0x03] // @1CCB memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-5] << 0x00 // @1CFD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1D01 stack[2] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1D06 stack[3] = 0x20 // @1D0A stack[4] = memory[0x40:0x60] // @1D0D stack[5] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1D0E stack[6] = memory[0x40:0x60] // @1D0F stack[7] = 0x00 // @1D11 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00 // @1D14 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // } // Block ends with conditional jump to 0x1d1f, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length label_1D1B: // Incoming jump from 0x1D1A, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[1] { @1D1E memory[0x00:0x00] } 1D1B 60 PUSH1 0x00 1D1D 80 DUP1 1D1E FD *REVERT // Stack delta = +0 // Outputs[1] { @1D1E revert(memory[0x00:0x00]); } // Block terminates label_1D1F: // Incoming jump from 0x1D1A, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[0x02] / 0x0100 ** 0x00).code.length // Inputs[9] // { // @1D21 msg.gas // @1D22 stack[-5] // @1D22 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1D22 stack[-4] // @1D22 stack[-2] // @1D22 stack[-7] // @1D22 stack[-3] // @1D22 stack[-6] // @1D22 memory[stack[-4]:stack[-4] + stack[-5]] // } 1D1F 5B JUMPDEST 1D20 50 POP 1D21 5A GAS 1D22 F1 CALL 1D23 15 ISZERO 1D24 80 DUP1 1D25 15 ISZERO 1D26 61 PUSH2 0x1d33 1D29 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1D22 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1D23 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 0x1d33, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1D2A: // Incoming jump from 0x1D29, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1D2A returndata.length // @1D2E returndata[0x00:0x00 + returndata.length] // @1D2F returndata.length // @1D32 memory[0x00:0x00 + returndata.length] // } 1D2A 3D RETURNDATASIZE 1D2B 60 PUSH1 0x00 1D2D 80 DUP1 1D2E 3E RETURNDATACOPY 1D2F 3D RETURNDATASIZE 1D30 60 PUSH1 0x00 1D32 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D2E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1D32 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1D33: // Incoming jump from 0x1D29, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1D3A memory[0x40:0x60] // @1D3B returndata.length // } 1D33 5B JUMPDEST 1D34 50 POP 1D35 50 POP 1D36 50 POP 1D37 50 POP 1D38 60 PUSH1 0x40 1D3A 51 MLOAD 1D3B 3D RETURNDATASIZE 1D3C 60 PUSH1 0x20 1D3E 81 DUP2 1D3F 10 LT 1D40 15 ISZERO 1D41 61 PUSH2 0x1d49 1D44 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1D3A stack[-4] = memory[0x40:0x60] // @1D3B stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1d49, if !(returndata.length < 0x20) label_1D45: // Incoming jump from 0x1D44, if not !(returndata.length < 0x20) // Inputs[1] { @1D48 memory[0x00:0x00] } 1D45 60 PUSH1 0x00 1D47 80 DUP1 1D48 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D48 revert(memory[0x00:0x00]); } // Block terminates label_1D49: // Incoming jump from 0x1D44, if !(returndata.length < 0x20) // Inputs[3] // { // @1D4A stack[-2] // @1D4B stack[-1] // @1D4F memory[stack[-2]:stack[-2] + 0x20] // } 1D49 5B JUMPDEST 1D4A 81 DUP2 1D4B 01 ADD 1D4C 90 SWAP1 1D4D 80 DUP1 1D4E 80 DUP1 1D4F 51 MLOAD 1D50 90 SWAP1 1D51 60 PUSH1 0x20 1D53 01 ADD 1D54 90 SWAP1 1D55 92 SWAP3 1D56 91 SWAP2 1D57 90 SWAP1 1D58 50 POP 1D59 50 POP 1D5A 50 POP 1D5B 50 POP // Stack delta = -2 // Block continues label_1D5C: // Incoming jump from 0x1D5B // Incoming jump from 0x1C69, if !stack[-2] // Inputs[10] // { // @1D5D stack[-4] // @1D74 stack[-5] // @1D96 stack[-3] // @1D97 block.timestamp // @1D9B memory[0x40:0x60] // @1DA8 memory[0x40:0x60] // @1DAD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1DAF block.timestamp // @1DB1 stack[-1] // @1DB3 stack[-6] // } 1D5C 5B JUMPDEST 1D5D 83 DUP4 1D5E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D73 16 AND 1D74 85 DUP6 1D75 7F PUSH32 0xb3d987963d01b2f68493b4bdb130988f157ea43070d4ad840fee0466ed9370d9 1D96 85 DUP6 1D97 42 TIMESTAMP 1D98 01 ADD 1D99 60 PUSH1 0x40 1D9B 51 MLOAD 1D9C 80 DUP1 1D9D 82 DUP3 1D9E 81 DUP2 1D9F 52 MSTORE 1DA0 60 PUSH1 0x20 1DA2 01 ADD 1DA3 91 SWAP2 1DA4 50 POP 1DA5 50 POP 1DA6 60 PUSH1 0x40 1DA8 51 MLOAD 1DA9 80 DUP1 1DAA 91 SWAP2 1DAB 03 SUB 1DAC 90 SWAP1 1DAD A3 LOG3 1DAE 82 DUP3 1DAF 42 TIMESTAMP 1DB0 01 ADD 1DB1 90 SWAP1 1DB2 50 POP 1DB3 94 SWAP5 1DB4 93 SWAP4 1DB5 50 POP 1DB6 50 POP 1DB7 50 POP 1DB8 50 POP 1DB9 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1D9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = block.timestamp + stack[-3] // @1DAD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xb3d987963d01b2f68493b4bdb130988f157ea43070d4ad840fee0466ed9370d9, stack[-5], stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff]); // @1DB3 stack[-6] = block.timestamp + stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1DBA: // Incoming call from 0x101C, returns to 0x101D // Incoming call from 0x0F12, returns to 0x0F13 // Inputs[1] { @1DC1 stack[-1] } 1DBA 5B JUMPDEST 1DBB 60 PUSH1 0x00 1DBD 80 DUP1 1DBE 61 PUSH2 0x1dc6 1DC1 83 DUP4 1DC2 61 PUSH2 0x1239 1DC5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DBB stack[0] = 0x00 // @1DBD stack[1] = 0x00 // @1DBE stack[2] = 0x1dc6 // @1DC1 stack[3] = stack[-1] // } // Block ends with call to 0x1239, returns to 0x1DC6 label_1DC6: // Incoming return from call to 0x1239 at 0x1DC5 // Inputs[3] // { // @1DC7 stack[-2] // @1DC7 stack[-1] // @1DE0 stack[-5] // } 1DC6 5B JUMPDEST 1DC7 90 SWAP1 1DC8 50 POP 1DC9 80 DUP1 1DCA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DDF 16 AND 1DE0 84 DUP5 1DE1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DF6 16 AND 1DF7 14 EQ 1DF8 80 DUP1 1DF9 61 PUSH2 0x1e35 1DFC 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1DC7 stack[-2] = stack[-1] // @1DF7 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with conditional jump to 0x1e35, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_1DFD: // Incoming jump from 0x1DFC, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @1DFE stack[-5] // @1E18 stack[-4] // } 1DFD 50 POP 1DFE 83 DUP4 1DFF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E14 16 AND 1E15 61 PUSH2 0x1e1d 1E18 84 DUP5 1E19 61 PUSH2 0x0d61 1E1C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1E14 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @1E15 stack[0] = 0x1e1d // @1E18 stack[1] = stack[-4] // } // Block ends with call to 0x0d61, returns to 0x1E1D label_1E1D: // Incoming return from call to 0x0D61 at 0x1E1C // Inputs[2] // { // @1E33 stack[-1] // @1E34 stack[-2] // } 1E1D 5B JUMPDEST 1E1E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E33 16 AND 1E34 14 EQ // Stack delta = -1 // Outputs[1] { @1E34 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block continues label_1E35: // Incoming jump from 0x1DFC, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Incoming jump from 0x1E34 // Inputs[1] { @1E36 stack[-1] } 1E35 5B JUMPDEST 1E36 80 DUP1 1E37 61 PUSH2 0x1e46 1E3A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e46, if stack[-1] label_1E3B: // Incoming jump from 0x1E3A, if not stack[-1] // Inputs[2] // { // @1E3F stack[-2] // @1E40 stack[-5] // } 1E3B 50 POP 1E3C 61 PUSH2 0x1e45 1E3F 81 DUP2 1E40 85 DUP6 1E41 61 PUSH2 0x18d4 1E44 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1E3C stack[-1] = 0x1e45 // @1E3F stack[0] = stack[-2] // @1E40 stack[1] = stack[-5] // } // Block ends with call to 0x18d4, returns to 0x1E45 label_1E45: // Incoming return from call to 0x18D4 at 0x1E44 1E45 5B JUMPDEST // Stack delta = +0 // Block continues label_1E46: // Incoming jump from 0x1E45 // Incoming jump from 0x1E3A, if stack[-1] // Inputs[4] // { // @1E47 stack[-3] // @1E47 stack[-1] // @1E4A stack[-6] // @1E4B stack[-5] // } 1E46 5B JUMPDEST 1E47 91 SWAP2 1E48 50 POP 1E49 50 POP 1E4A 92 SWAP3 1E4B 91 SWAP2 1E4C 50 POP 1E4D 50 POP 1E4E 56 *JUMP // Stack delta = -5 // Outputs[1] { @1E4A stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1E4F: // Incoming call from 0x0F26, returns to 0x0F27 // Inputs[2] // { // @1E50 stack[-3] // @1E6A stack[-1] // } 1E4F 5B JUMPDEST 1E50 82 DUP3 1E51 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E66 16 AND 1E67 61 PUSH2 0x1e6f 1E6A 82 DUP3 1E6B 61 PUSH2 0x1239 1E6E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E66 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1E67 stack[1] = 0x1e6f // @1E6A stack[2] = stack[-1] // } // Block ends with call to 0x1239, returns to 0x1E6F label_1E6F: // Incoming return from call to 0x1239 at 0x1E6E // Inputs[2] // { // @1E85 stack[-1] // @1E86 stack[-2] // } 1E6F 5B JUMPDEST 1E70 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E85 16 AND 1E86 14 EQ 1E87 61 PUSH2 0x1e8f 1E8A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1e8f, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1E8B: // Incoming jump from 0x1E8A, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1E8E memory[0x00:0x00] } 1E8B 60 PUSH1 0x00 1E8D 80 DUP1 1E8E FD *REVERT // Stack delta = +0 // Outputs[1] { @1E8E revert(memory[0x00:0x00]); } // Block terminates label_1E8F: // Incoming jump from 0x1E8A, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1EA8 stack[-2] } 1E8F 5B JUMPDEST 1E90 60 PUSH1 0x00 1E92 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EA7 16 AND 1EA8 82 DUP3 1EA9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EBE 16 AND 1EBF 14 EQ 1EC0 15 ISZERO 1EC1 61 PUSH2 0x1ec9 1EC4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ec9, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1EC5: // Incoming jump from 0x1EC4, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1EC8 memory[0x00:0x00] } 1EC5 60 PUSH1 0x00 1EC7 80 DUP1 1EC8 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EC8 revert(memory[0x00:0x00]); } // Block terminates label_1EC9: // Incoming jump from 0x1EC4, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @1ECD stack[-1] } 1EC9 5B JUMPDEST 1ECA 61 PUSH2 0x1ed2 1ECD 81 DUP2 1ECE 61 PUSH2 0x25b9 1ED1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1ECA stack[0] = 0x1ed2 // @1ECD stack[1] = stack[-1] // } // Block ends with call to 0x25b9, returns to 0x1ED2 label_1ED2: // Incoming return from call to 0x25B9 at 0x1ED1 // Inputs[3] // { // @1EDC stack[-3] // @1F16 memory[0x00:0x40] // @1F17 storage[keccak256(memory[0x00:0x40])] // } 1ED2 5B JUMPDEST 1ED3 61 PUSH2 0x1f25 1ED6 60 PUSH1 0x01 1ED8 60 PUSH1 0x07 1EDA 60 PUSH1 0x00 1EDC 86 DUP7 1EDD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1EF2 16 AND 1EF3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F08 16 AND 1F09 81 DUP2 1F0A 52 MSTORE 1F0B 60 PUSH1 0x20 1F0D 01 ADD 1F0E 90 SWAP1 1F0F 81 DUP2 1F10 52 MSTORE 1F11 60 PUSH1 0x20 1F13 01 ADD 1F14 60 PUSH1 0x00 1F16 20 SHA3 1F17 54 SLOAD 1F18 61 PUSH2 0x2677 1F1B 90 SWAP1 1F1C 91 SWAP2 1F1D 90 SWAP1 1F1E 63 PUSH4 0xffffffff 1F23 16 AND 1F24 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1ED3 stack[0] = 0x1f25 // @1F0A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1F10 memory[0x20:0x40] = 0x07 // @1F1C stack[1] = storage[keccak256(memory[0x00:0x40])] // @1F1D stack[2] = 0x01 // } // Block ends with call to 0xffffffff & 0x2677, returns to 0x1F25 label_1F25: // Incoming return from call to 0x2677 at 0x1F24 // Inputs[6] // { // @1F2A stack[-4] // @1F64 memory[0x00:0x40] // @1F65 stack[-1] // @1F72 stack[-3] // @1FAC memory[0x00:0x40] // @1FAD storage[keccak256(memory[0x00:0x40])] // } 1F25 5B JUMPDEST 1F26 60 PUSH1 0x07 1F28 60 PUSH1 0x00 1F2A 85 DUP6 1F2B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F40 16 AND 1F41 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F56 16 AND 1F57 81 DUP2 1F58 52 MSTORE 1F59 60 PUSH1 0x20 1F5B 01 ADD 1F5C 90 SWAP1 1F5D 81 DUP2 1F5E 52 MSTORE 1F5F 60 PUSH1 0x20 1F61 01 ADD 1F62 60 PUSH1 0x00 1F64 20 SHA3 1F65 81 DUP2 1F66 90 SWAP1 1F67 55 SSTORE 1F68 50 POP 1F69 61 PUSH2 0x1fbb 1F6C 60 PUSH1 0x01 1F6E 60 PUSH1 0x07 1F70 60 PUSH1 0x00 1F72 85 DUP6 1F73 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F88 16 AND 1F89 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F9E 16 AND 1F9F 81 DUP2 1FA0 52 MSTORE 1FA1 60 PUSH1 0x20 1FA3 01 ADD 1FA4 90 SWAP1 1FA5 81 DUP2 1FA6 52 MSTORE 1FA7 60 PUSH1 0x20 1FA9 01 ADD 1FAA 60 PUSH1 0x00 1FAC 20 SHA3 1FAD 54 SLOAD 1FAE 61 PUSH2 0x2697 1FB1 90 SWAP1 1FB2 91 SWAP2 1FB3 90 SWAP1 1FB4 63 PUSH4 0xffffffff 1FB9 16 AND 1FBA 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1F58 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @1F5E memory[0x20:0x40] = 0x07 // @1F67 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1F69 stack[-1] = 0x1fbb // @1FA0 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1FA6 memory[0x20:0x40] = 0x07 // @1FB2 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1FB3 stack[1] = 0x01 // } // Block ends with call to 0xffffffff & 0x2697, returns to 0x1FBB label_1FBB: // Incoming return from call to 0x2697 at 0x1FBA // Inputs[11] // { // @1FC0 stack[-3] // @1FFA memory[0x00:0x40] // @1FFB stack[-1] // @2004 stack[-2] // @2012 memory[0x00:0x40] // @201A storage[keccak256(memory[0x00:0x40])] // @2069 stack[-4] // @20A3 memory[0x40:0x60] // @20A6 memory[0x40:0x60] // @20AB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @20AF stack[-5] // } 1FBB 5B JUMPDEST 1FBC 60 PUSH1 0x07 1FBE 60 PUSH1 0x00 1FC0 84 DUP5 1FC1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FD6 16 AND 1FD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1FEC 16 AND 1FED 81 DUP2 1FEE 52 MSTORE 1FEF 60 PUSH1 0x20 1FF1 01 ADD 1FF2 90 SWAP1 1FF3 81 DUP2 1FF4 52 MSTORE 1FF5 60 PUSH1 0x20 1FF7 01 ADD 1FF8 60 PUSH1 0x00 1FFA 20 SHA3 1FFB 81 DUP2 1FFC 90 SWAP1 1FFD 55 SSTORE 1FFE 50 POP 1FFF 81 DUP2 2000 60 PUSH1 0x05 2002 60 PUSH1 0x00 2004 83 DUP4 2005 81 DUP2 2006 52 MSTORE 2007 60 PUSH1 0x20 2009 01 ADD 200A 90 SWAP1 200B 81 DUP2 200C 52 MSTORE 200D 60 PUSH1 0x20 200F 01 ADD 2010 60 PUSH1 0x00 2012 20 SHA3 2013 60 PUSH1 0x00 2015 61 PUSH2 0x0100 2018 0A EXP 2019 81 DUP2 201A 54 SLOAD 201B 81 DUP2 201C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2031 02 MUL 2032 19 NOT 2033 16 AND 2034 90 SWAP1 2035 83 DUP4 2036 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 204B 16 AND 204C 02 MUL 204D 17 OR 204E 90 SWAP1 204F 55 SSTORE 2050 50 POP 2051 80 DUP1 2052 82 DUP3 2053 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2068 16 AND 2069 84 DUP5 206A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 207F 16 AND 2080 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 20A1 60 PUSH1 0x40 20A3 51 MLOAD 20A4 60 PUSH1 0x40 20A6 51 MLOAD 20A7 80 DUP1 20A8 91 SWAP2 20A9 03 SUB 20AA 90 SWAP1 20AB A4 LOG4 20AC 50 POP 20AD 50 POP 20AE 50 POP 20AF 56 *JUMP // Stack delta = -5 // Outputs[7] // { // @1FEE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @1FF4 memory[0x20:0x40] = 0x07 // @1FFD storage[keccak256(memory[0x00:0x40])] = stack[-1] // @2006 memory[0x00:0x20] = stack[-2] // @200C memory[0x20:0x40] = 0x05 // @204F storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @20AB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-5] label_20B0: // Incoming call from 0x1262, returns to 0x1263 // Inputs[3] // { // @20B8 stack[-1] // @20C6 memory[0x00:0x40] // @20CA storage[keccak256(memory[0x00:0x40])] // } 20B0 5B JUMPDEST 20B1 60 PUSH1 0x00 20B3 80 DUP1 20B4 60 PUSH1 0x05 20B6 60 PUSH1 0x00 20B8 84 DUP5 20B9 81 DUP2 20BA 52 MSTORE 20BB 60 PUSH1 0x20 20BD 01 ADD 20BE 90 SWAP1 20BF 81 DUP2 20C0 52 MSTORE 20C1 60 PUSH1 0x20 20C3 01 ADD 20C4 60 PUSH1 0x00 20C6 20 SHA3 20C7 60 PUSH1 0x00 20C9 90 SWAP1 20CA 54 SLOAD 20CB 90 SWAP1 20CC 61 PUSH2 0x0100 20CF 0A EXP 20D0 90 SWAP1 20D1 04 DIV 20D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 20E7 16 AND 20E8 90 SWAP1 20E9 50 POP 20EA 60 PUSH1 0x00 20EC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2101 16 AND 2102 81 DUP2 2103 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2118 16 AND 2119 14 EQ 211A 15 ISZERO 211B 61 PUSH2 0x2123 211E 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @20B1 stack[0] = 0x00 // @20BA memory[0x00:0x20] = stack[-1] // @20C0 memory[0x20:0x40] = 0x05 // @20E8 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with conditional jump to 0x2123, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_211F: // Incoming jump from 0x211E, if not !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2122 memory[0x00:0x00] } 211F 60 PUSH1 0x00 2121 80 DUP1 2122 FD *REVERT // Stack delta = +0 // Outputs[1] { @2122 revert(memory[0x00:0x00]); } // Block terminates label_2123: // Incoming jump from 0x211E, if !(0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[4] // { // @2124 stack[-1] // @2125 stack[-2] // @2128 stack[-4] // @2129 stack[-3] // } 2123 5B JUMPDEST 2124 80 DUP1 2125 91 SWAP2 2126 50 POP 2127 50 POP 2128 91 SWAP2 2129 90 SWAP1 212A 50 POP 212B 56 *JUMP // Stack delta = -3 // Outputs[1] { @2128 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_212C: // Incoming call from 0x1663, returns to 0x1664 // Inputs[1] { @2132 stack[-3] } 212C 5B JUMPDEST 212D 60 PUSH1 0x00 212F 61 PUSH2 0x214d 2132 84 DUP5 2133 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2148 16 AND 2149 61 PUSH2 0x26b6 214C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @212D stack[0] = 0x00 // @212F stack[1] = 0x214d // @2148 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // } // Block ends with call to 0x26b6, returns to 0x214D label_214D: // Incoming return from call to 0x26B6 at 0x214C // Inputs[1] { @2151 stack[-1] } 214D 5B JUMPDEST 214E 61 PUSH2 0x215a 2151 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x215a, if stack[-1] label_2152: // Incoming jump from 0x2151, if not stack[-1] // Inputs[1] { @2154 stack[-1] } 2152 60 PUSH1 0x01 2154 90 SWAP1 2155 50 POP 2156 61 PUSH2 0x230d 2159 56 *JUMP // Stack delta = +0 // Outputs[1] { @2154 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x230d label_215A: // Incoming jump from 0x2151, if stack[-1] // Inputs[8] // { // @215D stack[-4] // @2179 msg.sender // @217A stack[-5] // @217B stack[-3] // @217C stack[-2] // @217F memory[0x40:0x60] // @2206 memory[stack[-2]:stack[-2] + 0x20] // @220F memory[stack[-2]:stack[-2] + 0x20] // } 215A 5B JUMPDEST 215B 60 PUSH1 0x00 215D 84 DUP5 215E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2173 16 AND 2174 63 PUSH4 0x150b7a02 2179 33 CALLER 217A 88 DUP9 217B 87 DUP8 217C 87 DUP8 217D 60 PUSH1 0x40 217F 51 MLOAD 2180 85 DUP6 2181 63 PUSH4 0xffffffff 2186 16 AND 2187 60 PUSH1 0xe0 2189 1B SHL 218A 81 DUP2 218B 52 MSTORE 218C 60 PUSH1 0x04 218E 01 ADD 218F 80 DUP1 2190 85 DUP6 2191 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21A6 16 AND 21A7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21BC 16 AND 21BD 81 DUP2 21BE 52 MSTORE 21BF 60 PUSH1 0x20 21C1 01 ADD 21C2 84 DUP5 21C3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21D8 16 AND 21D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 21EE 16 AND 21EF 81 DUP2 21F0 52 MSTORE 21F1 60 PUSH1 0x20 21F3 01 ADD 21F4 83 DUP4 21F5 81 DUP2 21F6 52 MSTORE 21F7 60 PUSH1 0x20 21F9 01 ADD 21FA 80 DUP1 21FB 60 PUSH1 0x20 21FD 01 ADD 21FE 82 DUP3 21FF 81 DUP2 2200 03 SUB 2201 82 DUP3 2202 52 MSTORE 2203 83 DUP4 2204 81 DUP2 2205 81 DUP2 2206 51 MLOAD 2207 81 DUP2 2208 52 MSTORE 2209 60 PUSH1 0x20 220B 01 ADD 220C 91 SWAP2 220D 50 POP 220E 80 DUP1 220F 51 MLOAD 2210 90 SWAP1 2211 60 PUSH1 0x20 2213 01 ADD 2214 90 SWAP1 2215 80 DUP1 2216 83 DUP4 2217 83 DUP4 2218 60 PUSH1 0x00 221A 5B JUMPDEST 221B 83 DUP4 221C 81 DUP2 221D 10 LT 221E 15 ISZERO 221F 61 PUSH2 0x2235 2222 57 *JUMPI // Stack delta = +16 // Outputs[22] // { // @215B stack[0] = 0x00 // @2173 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @2174 stack[2] = 0x150b7a02 // @2179 stack[3] = msg.sender // @217A stack[4] = stack[-5] // @217B stack[5] = stack[-3] // @217C stack[6] = stack[-2] // @218B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x150b7a02) << 0xe0 // @218E stack[7] = 0x04 + memory[0x40:0x60] // @21BE memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & msg.sender // @21F0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @21F6 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-3] // @21F9 stack[8] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2202 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2208 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @220C stack[9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2214 stack[10] = 0x20 + stack[-2] // @2214 stack[11] = memory[stack[-2]:stack[-2] + 0x20] // @2215 stack[12] = memory[stack[-2]:stack[-2] + 0x20] // @2216 stack[13] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2217 stack[14] = 0x20 + stack[-2] // @2218 stack[15] = 0x00 // } // Block ends with conditional jump to 0x2235, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_2223: // Incoming jump from 0x2222, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2222, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2223 stack[-1] // @2224 stack[-2] // @2226 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @2228 stack[-3] // } 2223 80 DUP1 2224 82 DUP3 2225 01 ADD 2226 51 MLOAD 2227 81 DUP2 2228 84 DUP5 2229 01 ADD 222A 52 MSTORE 222B 60 PUSH1 0x20 222D 81 DUP2 222E 01 ADD 222F 90 SWAP1 2230 50 POP 2231 61 PUSH2 0x221a 2234 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @222A memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @222F stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x221a label_2235: // Incoming jump from 0x2222, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2222, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @223A stack[-6] // @223A stack[-5] // @223C stack[-7] // } 2235 5B JUMPDEST 2236 50 POP 2237 50 POP 2238 50 POP 2239 50 POP 223A 90 SWAP1 223B 50 POP 223C 90 SWAP1 223D 81 DUP2 223E 01 ADD 223F 90 SWAP1 2240 60 PUSH1 0x1f 2242 16 AND 2243 80 DUP1 2244 15 ISZERO 2245 61 PUSH2 0x2262 2248 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @223F stack[-7] = stack[-5] + stack[-7] // @2242 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2262, if !(0x1f & stack[-5]) label_2249: // Incoming jump from 0x2248, if not !(0x1f & stack[-5]) // Inputs[7] // { // @2249 stack[-1] // @224A stack[-2] // @224D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2264 stack[-8] // @226F memory[0x40:0x60] // @2276 stack[-10] // @2278 address(stack[-10]).code.length // } 2249 80 DUP1 224A 82 DUP3 224B 03 SUB 224C 80 DUP1 224D 51 MLOAD 224E 60 PUSH1 0x01 2250 83 DUP4 2251 60 PUSH1 0x20 2253 03 SUB 2254 61 PUSH2 0x0100 2257 0A EXP 2258 03 SUB 2259 19 NOT 225A 16 AND 225B 81 DUP2 225C 52 MSTORE 225D 60 PUSH1 0x20 225F 01 ADD 2260 91 SWAP2 2261 50 POP 2262 5B JUMPDEST 2263 50 POP 2264 95 SWAP6 2265 50 POP 2266 50 POP 2267 50 POP 2268 50 POP 2269 50 POP 226A 50 POP 226B 60 PUSH1 0x20 226D 60 PUSH1 0x40 226F 51 MLOAD 2270 80 DUP1 2271 83 DUP4 2272 03 SUB 2273 81 DUP2 2274 60 PUSH1 0x00 2276 87 DUP8 2277 80 DUP1 2278 3B EXTCODESIZE 2279 15 ISZERO 227A 80 DUP1 227B 15 ISZERO 227C 61 PUSH2 0x2284 227F 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @225C 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] // @2264 stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @226B stack[-7] = 0x20 // @226F stack[-6] = memory[0x40:0x60] // @2272 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @2273 stack[-4] = memory[0x40:0x60] // @2274 stack[-3] = 0x00 // @2276 stack[-2] = stack[-10] // @2279 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x2284, if !!address(stack[-10]).code.length label_2280: // Incoming jump from 0x227F, if not !!address(stack[-10]).code.length // Incoming jump from 0x227F, if not !!address(stack[-10]).code.length // Inputs[1] { @2283 memory[0x00:0x00] } 2280 60 PUSH1 0x00 2282 80 DUP1 2283 FD *REVERT // Stack delta = +0 // Outputs[1] { @2283 revert(memory[0x00:0x00]); } // Block terminates label_2284: // Incoming jump from 0x227F, if !!address(stack[-10]).code.length // Incoming jump from 0x227F, if !!address(stack[-10]).code.length // Inputs[9] // { // @2286 msg.gas // @2287 stack[-4] // @2287 stack[-7] // @2287 stack[-3] // @2287 stack[-6] // @2287 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2287 memory[stack[-4]:stack[-4] + stack[-5]] // @2287 stack[-2] // @2287 stack[-5] // } 2284 5B JUMPDEST 2285 50 POP 2286 5A GAS 2287 F1 CALL 2288 15 ISZERO 2289 80 DUP1 228A 15 ISZERO 228B 61 PUSH2 0x2298 228E 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2287 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2288 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 0x2298, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_228F: // Incoming jump from 0x228E, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @228F returndata.length // @2293 returndata[0x00:0x00 + returndata.length] // @2294 returndata.length // @2297 memory[0x00:0x00 + returndata.length] // } 228F 3D RETURNDATASIZE 2290 60 PUSH1 0x00 2292 80 DUP1 2293 3E RETURNDATACOPY 2294 3D RETURNDATASIZE 2295 60 PUSH1 0x00 2297 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2293 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2297 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2298: // Incoming jump from 0x228E, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @229F memory[0x40:0x60] // @22A0 returndata.length // } 2298 5B JUMPDEST 2299 50 POP 229A 50 POP 229B 50 POP 229C 50 POP 229D 60 PUSH1 0x40 229F 51 MLOAD 22A0 3D RETURNDATASIZE 22A1 60 PUSH1 0x20 22A3 81 DUP2 22A4 10 LT 22A5 15 ISZERO 22A6 61 PUSH2 0x22ae 22A9 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @229F stack[-4] = memory[0x40:0x60] // @22A0 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x22ae, if !(returndata.length < 0x20) label_22AA: // Incoming jump from 0x22A9, if not !(returndata.length < 0x20) // Inputs[1] { @22AD memory[0x00:0x00] } 22AA 60 PUSH1 0x00 22AC 80 DUP1 22AD FD *REVERT // Stack delta = +0 // Outputs[1] { @22AD revert(memory[0x00:0x00]); } // Block terminates label_22AE: // Incoming jump from 0x22A9, if !(returndata.length < 0x20) // Inputs[7] // { // @22AF stack[-2] // @22B0 stack[-1] // @22B4 memory[stack[-2]:stack[-2] + 0x20] // @22C0 stack[-3] // @230A stack[-4] // @230E stack[-9] // @230F stack[-8] // } 22AE 5B JUMPDEST 22AF 81 DUP2 22B0 01 ADD 22B1 90 SWAP1 22B2 80 DUP1 22B3 80 DUP1 22B4 51 MLOAD 22B5 90 SWAP1 22B6 60 PUSH1 0x20 22B8 01 ADD 22B9 90 SWAP1 22BA 92 SWAP3 22BB 91 SWAP2 22BC 90 SWAP1 22BD 50 POP 22BE 50 POP 22BF 50 POP 22C0 90 SWAP1 22C1 50 POP 22C2 63 PUSH4 0x150b7a02 22C7 60 PUSH1 0xe0 22C9 1B SHL 22CA 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 22E7 19 NOT 22E8 16 AND 22E9 81 DUP2 22EA 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2307 19 NOT 2308 16 AND 2309 14 EQ 230A 91 SWAP2 230B 50 POP 230C 50 POP 230D 5B JUMPDEST 230E 94 SWAP5 230F 93 SWAP4 2310 50 POP 2311 50 POP 2312 50 POP 2313 50 POP 2314 56 *JUMP // Stack delta = -8 // Outputs[1] { @230E stack[-9] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x150b7a02 << 0xe0) } // Block ends with unconditional jump to stack[-9] label_2315: // Incoming call from 0x1981, returns to 0x1982 // Inputs[1] { @232E stack[-1] } 2315 5B JUMPDEST 2316 60 PUSH1 0x00 2318 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 232D 16 AND 232E 81 DUP2 232F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2344 16 AND 2345 14 EQ 2346 15 ISZERO 2347 61 PUSH2 0x234f 234A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x234f, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_234B: // Incoming jump from 0x234A, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @234E memory[0x00:0x00] } 234B 60 PUSH1 0x00 234D 80 DUP1 234E FD *REVERT // Stack delta = +0 // Outputs[1] { @234E revert(memory[0x00:0x00]); } // Block terminates label_234F: // Incoming jump from 0x234A, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @2350 stack[-1] // @236C storage[0x01] // @23C3 memory[0x40:0x60] // @23C6 memory[0x40:0x60] // @23CB memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @23D6 storage[0x01] // @240E stack[-2] // } 234F 5B JUMPDEST 2350 80 DUP1 2351 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2366 16 AND 2367 60 PUSH1 0x01 2369 60 PUSH1 0x00 236B 90 SWAP1 236C 54 SLOAD 236D 90 SWAP1 236E 61 PUSH2 0x0100 2371 0A EXP 2372 90 SWAP1 2373 04 DIV 2374 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2389 16 AND 238A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 239F 16 AND 23A0 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 23C1 60 PUSH1 0x40 23C3 51 MLOAD 23C4 60 PUSH1 0x40 23C6 51 MLOAD 23C7 80 DUP1 23C8 91 SWAP2 23C9 03 SUB 23CA 90 SWAP1 23CB A3 LOG3 23CC 80 DUP1 23CD 60 PUSH1 0x01 23CF 60 PUSH1 0x00 23D1 61 PUSH2 0x0100 23D4 0A EXP 23D5 81 DUP2 23D6 54 SLOAD 23D7 81 DUP2 23D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23ED 02 MUL 23EE 19 NOT 23EF 16 AND 23F0 90 SWAP1 23F1 83 DUP4 23F2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2407 16 AND 2408 02 MUL 2409 17 OR 240A 90 SWAP1 240B 55 SSTORE 240C 50 POP 240D 50 POP 240E 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @23CB log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x01] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @240B storage[0x01] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x01]) // } // Block ends with unconditional jump to stack[-2] label_240F: // Incoming call from 0x1C57, returns to 0x1C58 // Inputs[1] { @2416 stack[-1] } 240F 5B JUMPDEST 2410 61 PUSH2 0x2421 2413 61 PUSH2 0x241b 2416 82 DUP3 2417 61 PUSH2 0x1239 241A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2410 stack[0] = 0x2421 // @2413 stack[1] = 0x241b // @2416 stack[2] = stack[-1] // } // Block ends with call to 0x1239, returns to 0x241B label_241B: // Incoming return from call to 0x1239 at 0x241A // Inputs[1] { @241C stack[-3] } 241B 5B JUMPDEST 241C 82 DUP3 241D 61 PUSH2 0x26c9 2420 56 *JUMP // Stack delta = +1 // Outputs[1] { @241C stack[0] = stack[-3] } // Block ends with unconditional jump to 0x26c9 label_2421: // Incoming return from call to 0x241B at 0x241A // Inputs[1] { @2423 stack[-2] } 2421 5B JUMPDEST 2422 50 POP 2423 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2424: // Incoming call from 0x1C62, returns to 0x1C63 // Inputs[1] { @243D stack[-2] } 2424 5B JUMPDEST 2425 60 PUSH1 0x00 2427 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 243C 16 AND 243D 82 DUP3 243E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2453 16 AND 2454 14 EQ 2455 15 ISZERO 2456 61 PUSH2 0x245e 2459 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x245e, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_245A: // Incoming jump from 0x2459, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @245D memory[0x00:0x00] } 245A 60 PUSH1 0x00 245C 80 DUP1 245D FD *REVERT // Stack delta = +0 // Outputs[1] { @245D revert(memory[0x00:0x00]); } // Block terminates label_245E: // Incoming jump from 0x2459, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @2462 stack[-1] } 245E 5B JUMPDEST 245F 61 PUSH2 0x2467 2462 81 DUP2 2463 61 PUSH2 0x1a4c 2466 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @245F stack[0] = 0x2467 // @2462 stack[1] = stack[-1] // } // Block ends with call to 0x1a4c, returns to 0x2467 label_2467: // Incoming return from call to 0x1A4C at 0x2466 // Inputs[1] { @2468 stack[-1] } 2467 5B JUMPDEST 2468 15 ISZERO 2469 61 PUSH2 0x2471 246C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2471, if !stack[-1] label_246D: // Incoming jump from 0x246C, if not !stack[-1] // Inputs[1] { @2470 memory[0x00:0x00] } 246D 60 PUSH1 0x00 246F 80 DUP1 2470 FD *REVERT // Stack delta = +0 // Outputs[1] { @2470 revert(memory[0x00:0x00]); } // Block terminates label_2471: // Incoming jump from 0x246C, if !stack[-1] // Inputs[6] // { // @2472 stack[-2] // @2477 stack[-1] // @2485 memory[0x00:0x40] // @248D storage[keccak256(memory[0x00:0x40])] // @2507 memory[0x00:0x40] // @2508 storage[keccak256(memory[0x00:0x40])] // } 2471 5B JUMPDEST 2472 81 DUP2 2473 60 PUSH1 0x05 2475 60 PUSH1 0x00 2477 83 DUP4 2478 81 DUP2 2479 52 MSTORE 247A 60 PUSH1 0x20 247C 01 ADD 247D 90 SWAP1 247E 81 DUP2 247F 52 MSTORE 2480 60 PUSH1 0x20 2482 01 ADD 2483 60 PUSH1 0x00 2485 20 SHA3 2486 60 PUSH1 0x00 2488 61 PUSH2 0x0100 248B 0A EXP 248C 81 DUP2 248D 54 SLOAD 248E 81 DUP2 248F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24A4 02 MUL 24A5 19 NOT 24A6 16 AND 24A7 90 SWAP1 24A8 83 DUP4 24A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24BE 16 AND 24BF 02 MUL 24C0 17 OR 24C1 90 SWAP1 24C2 55 SSTORE 24C3 50 POP 24C4 61 PUSH2 0x2516 24C7 60 PUSH1 0x01 24C9 60 PUSH1 0x07 24CB 60 PUSH1 0x00 24CD 85 DUP6 24CE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24E3 16 AND 24E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24F9 16 AND 24FA 81 DUP2 24FB 52 MSTORE 24FC 60 PUSH1 0x20 24FE 01 ADD 24FF 90 SWAP1 2500 81 DUP2 2501 52 MSTORE 2502 60 PUSH1 0x20 2504 01 ADD 2505 60 PUSH1 0x00 2507 20 SHA3 2508 54 SLOAD 2509 61 PUSH2 0x2697 250C 90 SWAP1 250D 91 SWAP2 250E 90 SWAP1 250F 63 PUSH4 0xffffffff 2514 16 AND 2515 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @2479 memory[0x00:0x20] = stack[-1] // @247F memory[0x20:0x40] = 0x05 // @24C2 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @24C4 stack[0] = 0x2516 // @24FB memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2501 memory[0x20:0x40] = 0x07 // @250D stack[1] = storage[keccak256(memory[0x00:0x40])] // @250E stack[2] = 0x01 // } // Block ends with call to 0xffffffff & 0x2697, returns to 0x2516 label_2516: // Incoming return from call to 0x2697 at 0x2515 // Inputs[8] // { // @251B stack[-3] // @2555 memory[0x00:0x40] // @2556 stack[-1] // @255A stack[-2] // @25AD memory[0x40:0x60] // @25B0 memory[0x40:0x60] // @25B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @25B8 stack[-4] // } 2516 5B JUMPDEST 2517 60 PUSH1 0x07 2519 60 PUSH1 0x00 251B 84 DUP5 251C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2531 16 AND 2532 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2547 16 AND 2548 81 DUP2 2549 52 MSTORE 254A 60 PUSH1 0x20 254C 01 ADD 254D 90 SWAP1 254E 81 DUP2 254F 52 MSTORE 2550 60 PUSH1 0x20 2552 01 ADD 2553 60 PUSH1 0x00 2555 20 SHA3 2556 81 DUP2 2557 90 SWAP1 2558 55 SSTORE 2559 50 POP 255A 80 DUP1 255B 82 DUP3 255C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2571 16 AND 2572 60 PUSH1 0x00 2574 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2589 16 AND 258A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 25AB 60 PUSH1 0x40 25AD 51 MLOAD 25AE 60 PUSH1 0x40 25B0 51 MLOAD 25B1 80 DUP1 25B2 91 SWAP2 25B3 03 SUB 25B4 90 SWAP1 25B5 A4 LOG4 25B6 50 POP 25B7 50 POP 25B8 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @2549 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @254F memory[0x20:0x40] = 0x07 // @2558 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @25B5 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_25B9: // Incoming call from 0x1ED1, returns to 0x1ED2 // Incoming call from 0x2711, returns to 0x2712 // Inputs[3] // { // @25D6 stack[-1] // @25E4 memory[0x00:0x40] // @25E8 storage[keccak256(memory[0x00:0x40])] // } 25B9 5B JUMPDEST 25BA 60 PUSH1 0x00 25BC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25D1 16 AND 25D2 60 PUSH1 0x06 25D4 60 PUSH1 0x00 25D6 83 DUP4 25D7 81 DUP2 25D8 52 MSTORE 25D9 60 PUSH1 0x20 25DB 01 ADD 25DC 90 SWAP1 25DD 81 DUP2 25DE 52 MSTORE 25DF 60 PUSH1 0x20 25E1 01 ADD 25E2 60 PUSH1 0x00 25E4 20 SHA3 25E5 60 PUSH1 0x00 25E7 90 SWAP1 25E8 54 SLOAD 25E9 90 SWAP1 25EA 61 PUSH2 0x0100 25ED 0A EXP 25EE 90 SWAP1 25EF 04 DIV 25F0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2605 16 AND 2606 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 261B 16 AND 261C 14 EQ 261D 61 PUSH2 0x2674 2620 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @25D8 memory[0x00:0x20] = stack[-1] // @25DE memory[0x20:0x40] = 0x06 // } // Block ends with conditional jump to 0x2674, if 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 label_2621: // Incoming jump from 0x2620, if not 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 == 0xffffffffffffffffffffffffffffffffffffffff & 0x00 // Inputs[4] // { // @2627 stack[-1] // @2635 memory[0x00:0x40] // @263D storage[keccak256(memory[0x00:0x40])] // @2676 stack[-2] // } 2621 60 PUSH1 0x00 2623 60 PUSH1 0x06 2625 60 PUSH1 0x00 2627 83 DUP4 2628 81 DUP2 2629 52 MSTORE 262A 60 PUSH1 0x20 262C 01 ADD 262D 90 SWAP1 262E 81 DUP2 262F 52 MSTORE 2630 60 PUSH1 0x20 2632 01 ADD 2633 60 PUSH1 0x00 2635 20 SHA3 2636 60 PUSH1 0x00 2638 61 PUSH2 0x0100 263B 0A EXP 263C 81 DUP2 263D 54 SLOAD 263E 81 DUP2 263F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2654 02 MUL 2655 19 NOT 2656 16 AND 2657 90 SWAP1 2658 83 DUP4 2659 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 266E 16 AND 266F 02 MUL 2670 17 OR 2671 90 SWAP1 2672 55 SSTORE 2673 50 POP 2674 5B JUMPDEST 2675 50 POP 2676 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @2629 memory[0x00:0x20] = stack[-1] // @262F memory[0x20:0x40] = 0x06 // @2672 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_2677: // Incoming call from 0x2764, returns to 0x2765 // Incoming call from 0x1F24, returns to 0x1F25 // Inputs[2] // { // @267A stack[-2] // @267B stack[-1] // } 2677 5B JUMPDEST 2678 60 PUSH1 0x00 267A 82 DUP3 267B 82 DUP3 267C 11 GT 267D 15 ISZERO 267E 61 PUSH2 0x2686 2681 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2678 stack[0] = 0x00 } // Block ends with conditional jump to 0x2686, if !(stack[-1] > stack[-2]) label_2682: // Incoming jump from 0x2681, if not !(stack[-1] > stack[-2]) // Inputs[1] { @2685 memory[0x00:0x00] } 2682 60 PUSH1 0x00 2684 80 DUP1 2685 FD *REVERT // Stack delta = +0 // Outputs[1] { @2685 revert(memory[0x00:0x00]); } // Block terminates label_2686: // Incoming jump from 0x2681, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @2689 stack[-2] // @268A stack[-3] // @268F stack[-1] // @2692 stack[-4] // } 2686 5B JUMPDEST 2687 60 PUSH1 0x00 2689 82 DUP3 268A 84 DUP5 268B 03 SUB 268C 90 SWAP1 268D 50 POP 268E 80 DUP1 268F 91 SWAP2 2690 50 POP 2691 50 POP 2692 92 SWAP3 2693 91 SWAP2 2694 50 POP 2695 50 POP 2696 56 *JUMP // Stack delta = -3 // Outputs[1] { @2692 stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_2697: // Incoming call from 0x2515, returns to 0x2516 // Incoming call from 0x1FBA, returns to 0x1FBB // Inputs[2] // { // @269B stack[-1] // @269C stack[-2] // } 2697 5B JUMPDEST 2698 60 PUSH1 0x00 269A 80 DUP1 269B 82 DUP3 269C 84 DUP5 269D 01 ADD 269E 90 SWAP1 269F 50 POP 26A0 83 DUP4 26A1 81 DUP2 26A2 10 LT 26A3 15 ISZERO 26A4 61 PUSH2 0x26ac 26A7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2698 stack[0] = 0x00 // @269E stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x26ac, if !(stack[-2] + stack[-1] < stack[-2]) label_26A8: // Incoming jump from 0x26A7, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[1] { @26AB memory[0x00:0x00] } 26A8 60 PUSH1 0x00 26AA 80 DUP1 26AB FD *REVERT // Stack delta = +0 // Outputs[1] { @26AB revert(memory[0x00:0x00]); } // Block terminates label_26AC: // Incoming jump from 0x26A7, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @26AD stack[-1] // @26AE stack[-2] // @26B1 stack[-5] // @26B2 stack[-4] // } 26AC 5B JUMPDEST 26AD 80 DUP1 26AE 91 SWAP2 26AF 50 POP 26B0 50 POP 26B1 92 SWAP3 26B2 91 SWAP2 26B3 50 POP 26B4 50 POP 26B5 56 *JUMP // Stack delta = -4 // Outputs[1] { @26B1 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_26B6: // Incoming call from 0x214C, returns to 0x214D // Inputs[3] // { // @26BA stack[-1] // @26BB address(stack[-1]).code.length // @26C5 stack[-2] // } 26B6 5B JUMPDEST 26B7 60 PUSH1 0x00 26B9 80 DUP1 26BA 82 DUP3 26BB 3B EXTCODESIZE 26BC 90 SWAP1 26BD 50 POP 26BE 60 PUSH1 0x00 26C0 81 DUP2 26C1 11 GT 26C2 91 SWAP2 26C3 50 POP 26C4 50 POP 26C5 91 SWAP2 26C6 90 SWAP1 26C7 50 POP 26C8 56 *JUMP // Stack delta = -1 // Outputs[1] { @26C5 stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_26C9: // Incoming jump from 0x2420 // Inputs[2] // { // @26CA stack[-2] // @26E4 stack[-1] // } 26C9 5B JUMPDEST 26CA 81 DUP2 26CB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26E0 16 AND 26E1 61 PUSH2 0x26e9 26E4 82 DUP3 26E5 61 PUSH2 0x1239 26E8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @26E0 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @26E1 stack[1] = 0x26e9 // @26E4 stack[2] = stack[-1] // } // Block ends with call to 0x1239, returns to 0x26E9 label_26E9: // Incoming return from call to 0x1239 at 0x26E8 // Inputs[2] // { // @26FF stack[-1] // @2700 stack[-2] // } 26E9 5B JUMPDEST 26EA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26FF 16 AND 2700 14 EQ 2701 61 PUSH2 0x2709 2704 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2709, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_2705: // Incoming jump from 0x2704, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @2708 memory[0x00:0x00] } 2705 60 PUSH1 0x00 2707 80 DUP1 2708 FD *REVERT // Stack delta = +0 // Outputs[1] { @2708 revert(memory[0x00:0x00]); } // Block terminates label_2709: // Incoming jump from 0x2704, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @270D stack[-1] } 2709 5B JUMPDEST 270A 61 PUSH2 0x2712 270D 81 DUP2 270E 61 PUSH2 0x25b9 2711 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @270A stack[0] = 0x2712 // @270D stack[1] = stack[-1] // } // Block ends with call to 0x25b9, returns to 0x2712 label_2712: // Incoming return from call to 0x25B9 at 0x2711 // Inputs[3] // { // @271C stack[-2] // @2756 memory[0x00:0x40] // @2757 storage[keccak256(memory[0x00:0x40])] // } 2712 5B JUMPDEST 2713 61 PUSH2 0x2765 2716 60 PUSH1 0x01 2718 60 PUSH1 0x07 271A 60 PUSH1 0x00 271C 85 DUP6 271D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2732 16 AND 2733 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2748 16 AND 2749 81 DUP2 274A 52 MSTORE 274B 60 PUSH1 0x20 274D 01 ADD 274E 90 SWAP1 274F 81 DUP2 2750 52 MSTORE 2751 60 PUSH1 0x20 2753 01 ADD 2754 60 PUSH1 0x00 2756 20 SHA3 2757 54 SLOAD 2758 61 PUSH2 0x2677 275B 90 SWAP1 275C 91 SWAP2 275D 90 SWAP1 275E 63 PUSH4 0xffffffff 2763 16 AND 2764 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2713 stack[0] = 0x2765 // @274A memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @2750 memory[0x20:0x40] = 0x07 // @275C stack[1] = storage[keccak256(memory[0x00:0x40])] // @275D stack[2] = 0x01 // } // Block ends with call to 0xffffffff & 0x2677, returns to 0x2765 label_2765: // Incoming return from call to 0x2677 at 0x2764 // Inputs[10] // { // @276A stack[-3] // @27A4 memory[0x00:0x40] // @27A5 stack[-1] // @27AF stack[-2] // @27BD memory[0x00:0x40] // @27C5 storage[keccak256(memory[0x00:0x40])] // @284F memory[0x40:0x60] // @2852 memory[0x40:0x60] // @2857 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @285A stack[-4] // } 2765 5B JUMPDEST 2766 60 PUSH1 0x07 2768 60 PUSH1 0x00 276A 84 DUP5 276B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2780 16 AND 2781 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2796 16 AND 2797 81 DUP2 2798 52 MSTORE 2799 60 PUSH1 0x20 279B 01 ADD 279C 90 SWAP1 279D 81 DUP2 279E 52 MSTORE 279F 60 PUSH1 0x20 27A1 01 ADD 27A2 60 PUSH1 0x00 27A4 20 SHA3 27A5 81 DUP2 27A6 90 SWAP1 27A7 55 SSTORE 27A8 50 POP 27A9 60 PUSH1 0x00 27AB 60 PUSH1 0x05 27AD 60 PUSH1 0x00 27AF 83 DUP4 27B0 81 DUP2 27B1 52 MSTORE 27B2 60 PUSH1 0x20 27B4 01 ADD 27B5 90 SWAP1 27B6 81 DUP2 27B7 52 MSTORE 27B8 60 PUSH1 0x20 27BA 01 ADD 27BB 60 PUSH1 0x00 27BD 20 SHA3 27BE 60 PUSH1 0x00 27C0 61 PUSH2 0x0100 27C3 0A EXP 27C4 81 DUP2 27C5 54 SLOAD 27C6 81 DUP2 27C7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27DC 02 MUL 27DD 19 NOT 27DE 16 AND 27DF 90 SWAP1 27E0 83 DUP4 27E1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27F6 16 AND 27F7 02 MUL 27F8 17 OR 27F9 90 SWAP1 27FA 55 SSTORE 27FB 50 POP 27FC 80 DUP1 27FD 60 PUSH1 0x00 27FF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2814 16 AND 2815 83 DUP4 2816 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 282B 16 AND 282C 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 284D 60 PUSH1 0x40 284F 51 MLOAD 2850 60 PUSH1 0x40 2852 51 MLOAD 2853 80 DUP1 2854 91 SWAP2 2855 03 SUB 2856 90 SWAP1 2857 A4 LOG4 2858 50 POP 2859 50 POP 285A 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @2798 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @279E memory[0x20:0x40] = 0x07 // @27A7 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @27B1 memory[0x00:0x20] = stack[-2] // @27B7 memory[0x20:0x40] = 0x05 // @27FA storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @2857 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] 285B FE *ASSERT 285C 74 PUSH21 0x72616e7366657246726f6d28616464726573732c61 2872 64 PUSH5 0x6472657373 2878 2C 2C 2879 75 PUSH22 0x696e7432353629736166655472616e7366657246726f 2890 6D PUSH14 0x28616464726573732c6164647265 289F 73 PUSH20 0x732c75696e7432353629736166655472616e7366 28B4 65 PUSH6 0x7246726f6d28 28BB 61 PUSH2 0x6464 28BE 72 PUSH19 0x6573732c616464726573732c75696e74323536 28D2 2C 2C 28D3 62 PUSH3 0x797465 28D7 73 PUSH20 0x296973417070726f766564466f72416c6c286164 28EC 64 PUSH5 0x726573732c 28F2 61 PUSH2 0x6464 28F5 72 PUSH19 0x65737329a265627a7a723158203851e1a7c348 2909 07 SMOD 290A FD *REVERT 290B 87 DUP8 290C CD CD 290D 4B 4B 290E 67 PUSH8 0x0538168e0584812b 2917 7D PUSH30 0x1f4078ac2687a8c6455ca664736f6c63430005100032