Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x0118 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0118, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x8da5cb5b 0019 11 GT 001A 61 PUSH2 0x00a0 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00a0, if 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xad5c4648 0024 11 GT 0025 61 PUSH2 0x0064 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xad5c4648 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xad5c4648 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xad5c4648 002F 14 EQ 0030 61 PUSH2 0x0471 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0471, if 0xad5c4648 == stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xad5c4648 == stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xc45a0155 003A 14 EQ 003B 61 PUSH2 0x0486 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0486, if 0xc45a0155 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xc45a0155 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xcfa5d34d 0045 14 EQ 0046 61 PUSH2 0x049b 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049b, if 0xcfa5d34d == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xcfa5d34d == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xeb5625d9 0050 14 EQ 0051 61 PUSH2 0x04ca 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ca, if 0xeb5625d9 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xeb5625d9 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xfc4dd333 005B 14 EQ 005C 61 PUSH2 0x050d 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050d, if 0xfc4dd333 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xfc4dd333 == stack[-1] 0060 61 PUSH2 0x013d 0063 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x013d label_0064: // Incoming jump from 0x0028, if 0xad5c4648 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0x8da5cb5b 006B 14 EQ 006C 61 PUSH2 0x02c6 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c6, if 0x8da5cb5b == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0x986f5585 0076 14 EQ 0077 61 PUSH2 0x02f7 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f7, if 0x986f5585 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x986f5585 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xa3aa1989 0081 14 EQ 0082 61 PUSH2 0x030c 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030c, if 0xa3aa1989 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xa3aa1989 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xa3c68f4c 008C 14 EQ 008D 61 PUSH2 0x0389 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0389, if 0xa3c68f4c == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xa3c68f4c == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xa74e0691 0097 14 EQ 0098 61 PUSH2 0x03bf 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03bf, if 0xa74e0691 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xa74e0691 == stack[-1] 009C 61 PUSH2 0x013d 009F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x013d label_00A0: // Incoming jump from 0x001D, if 0x8da5cb5b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x423f6cef 00A7 11 GT 00A8 61 PUSH2 0x00e7 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e7, if 0x423f6cef > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x423f6cef > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x423f6cef 00B2 14 EQ 00B3 61 PUSH2 0x01b6 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b6, if 0x423f6cef == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x423f6cef == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x52b0761d 00BD 14 EQ 00BE 61 PUSH2 0x01ef 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ef, if 0x52b0761d == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x52b0761d == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x66dd0f24 00C8 14 EQ 00C9 61 PUSH2 0x0236 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0236, if 0x66dd0f24 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x66dd0f24 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x752adc32 00D3 14 EQ 00D4 61 PUSH2 0x0260 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0260, if 0x752adc32 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x752adc32 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x77cf7630 00DE 14 EQ 00DF 61 PUSH2 0x0293 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0293, if 0x77cf7630 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x77cf7630 == stack[-1] 00E3 61 PUSH2 0x013d 00E6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x013d label_00E7: // Incoming jump from 0x00AB, if 0x423f6cef > stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E7 5B JUMPDEST 00E8 80 DUP1 00E9 63 PUSH4 0x047cf9a6 00EE 14 EQ 00EF 61 PUSH2 0x0142 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0142, if 0x047cf9a6 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x047cf9a6 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x0ad60376 00F9 14 EQ 00FA 61 PUSH2 0x0172 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0172, if 0x0ad60376 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x0ad60376 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x2821040d 0104 14 EQ 0105 61 PUSH2 0x0199 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0199, if 0x2821040d == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x2821040d == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x3ccfd60b 010F 14 EQ 0110 61 PUSH2 0x01ae 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ae, if 0x3ccfd60b == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x3ccfd60b == stack[-1] 0114 61 PUSH2 0x013d 0117 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x013d label_0118: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @0119 msg.data.length } 0118 5B JUMPDEST 0119 36 CALLDATASIZE 011A 61 PUSH2 0x013d 011D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013d, if msg.data.length label_011E: // Incoming jump from 0x011D, if not msg.data.length // Inputs[3] // { // @011E msg.sender // @012C memory[0x00:0x40] // @012D storage[keccak256(memory[0x00:0x40])] // } 011E 33 CALLER 011F 60 PUSH1 0x00 0121 90 SWAP1 0122 81 DUP2 0123 52 MSTORE 0124 60 PUSH1 0x04 0126 60 PUSH1 0x20 0128 52 MSTORE 0129 60 PUSH1 0x40 012B 90 SWAP1 012C 20 SHA3 012D 54 SLOAD 012E 60 PUSH1 0xff 0130 16 AND 0131 15 ISZERO 0132 15 ISZERO 0133 60 PUSH1 0x01 0135 14 EQ 0136 61 PUSH2 0x013b 0139 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0123 memory[0x00:0x20] = msg.sender // @0128 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x013b, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) label_013A: // Incoming jump from 0x0139, if not 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) 013A FE *ASSERT // Stack delta = +0 // Outputs[1] { @013A assert(); } // Block terminates label_013B: // Incoming return from call to 0x04B1 at 0x04AC // Incoming return from call to 0x01D9 at 0x01D4 // Incoming return from call to 0x03AC at 0x03A7 // Incoming return from call to 0x032F at 0x032A // Incoming return from call to 0x08F7 at 0x01B5 // Incoming return from call to 0x03E2 at 0x03DD // Incoming return from call to 0x0283 at 0x027E // Incoming return from call to 0x0259 at 0x0254 // Incoming return from call to 0x0530 at 0x052B // Incoming jump from 0x0139, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) 013B 5B JUMPDEST 013C 00 *STOP // Stack delta = +0 // Outputs[1] { @013C stop(); } // Block terminates label_013D: // Incoming jump from 0x00E6 // Incoming jump from 0x0117 // Incoming jump from 0x009F // Incoming jump from 0x011D, if msg.data.length // Incoming jump from 0x0063 // Inputs[1] { @0141 memory[0x00:0x00] } 013D 5B JUMPDEST 013E 60 PUSH1 0x00 0140 80 DUP1 0141 FD *REVERT // Stack delta = +0 // Outputs[1] { @0141 revert(memory[0x00:0x00]); } // Block terminates label_0142: // Incoming jump from 0x00F2, if 0x047cf9a6 == stack[-1] // Inputs[1] { @0143 msg.value } 0142 5B JUMPDEST 0143 34 CALLVALUE 0144 80 DUP1 0145 15 ISZERO 0146 61 PUSH2 0x014e 0149 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0143 stack[0] = msg.value } // Block ends with conditional jump to 0x014e, if !msg.value label_014A: // Incoming jump from 0x0149, if not !msg.value // Inputs[1] { @014D memory[0x00:0x00] } 014A 60 PUSH1 0x00 014C 80 DUP1 014D FD *REVERT // Stack delta = +0 // Outputs[1] { @014D revert(memory[0x00:0x00]); } // Block terminates label_014E: // Incoming jump from 0x0149, if !msg.value // Inputs[1] { @0156 msg.data.length } 014E 5B JUMPDEST 014F 50 POP 0150 61 PUSH2 0x013b 0153 60 PUSH1 0x04 0155 80 DUP1 0156 36 CALLDATASIZE 0157 03 SUB 0158 60 PUSH1 0x40 015A 81 DUP2 015B 10 LT 015C 15 ISZERO 015D 61 PUSH2 0x0165 0160 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0150 stack[-1] = 0x013b // @0153 stack[0] = 0x04 // @0157 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0165, if !(msg.data.length - 0x04 < 0x40) label_0161: // Incoming jump from 0x0160, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0164 memory[0x00:0x00] } 0161 60 PUSH1 0x00 0163 80 DUP1 0164 FD *REVERT // Stack delta = +0 // Outputs[1] { @0164 revert(memory[0x00:0x00]); } // Block terminates label_0165: // Incoming jump from 0x0160, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0167 stack[-2] // @0168 msg.data[stack[-2]:stack[-2] + 0x20] // @016D msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0165 5B JUMPDEST 0166 50 POP 0167 80 DUP1 0168 35 CALLDATALOAD 0169 90 SWAP1 016A 60 PUSH1 0x20 016C 01 ADD 016D 35 CALLDATALOAD 016E 61 PUSH2 0x0537 0171 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0169 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @016D stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0537 label_0172: // Incoming jump from 0x00FD, if 0x0ad60376 == stack[-1] // Inputs[1] { @0173 msg.value } 0172 5B JUMPDEST 0173 34 CALLVALUE 0174 80 DUP1 0175 15 ISZERO 0176 61 PUSH2 0x017e 0179 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0173 stack[0] = msg.value } // Block ends with conditional jump to 0x017e, if !msg.value label_017A: // Incoming jump from 0x0179, if not !msg.value // Inputs[1] { @017D memory[0x00:0x00] } 017A 60 PUSH1 0x00 017C 80 DUP1 017D FD *REVERT // Stack delta = +0 // Outputs[1] { @017D revert(memory[0x00:0x00]); } // Block terminates label_017E: // Incoming jump from 0x0179, if !msg.value 017E 5B JUMPDEST 017F 50 POP 0180 61 PUSH2 0x0187 0183 61 PUSH2 0x08eb 0186 56 *JUMP // Stack delta = +0 // Outputs[1] { @0180 stack[-1] = 0x0187 } // Block ends with call to 0x08eb, returns to 0x0187 label_0187: // Incoming return from call to 0x08F1 at 0x01AD // Incoming return from call to 0x08EB at 0x0186 // Inputs[4] // { // @018B memory[0x40:0x60] // @018C stack[-1] // @018F memory[0x40:0x60] // @0198 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0187 5B JUMPDEST 0188 60 PUSH1 0x40 018A 80 DUP1 018B 51 MLOAD 018C 91 SWAP2 018D 82 DUP3 018E 52 MSTORE 018F 51 MLOAD 0190 90 SWAP1 0191 81 DUP2 0192 90 SWAP1 0193 03 SUB 0194 60 PUSH1 0x20 0196 01 ADD 0197 90 SWAP1 0198 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @018E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0198 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0199: // Incoming jump from 0x0108, if 0x2821040d == stack[-1] // Inputs[1] { @019A msg.value } 0199 5B JUMPDEST 019A 34 CALLVALUE 019B 80 DUP1 019C 15 ISZERO 019D 61 PUSH2 0x01a5 01A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @019A stack[0] = msg.value } // Block ends with conditional jump to 0x01a5, if !msg.value label_01A1: // Incoming jump from 0x01A0, if not !msg.value // Inputs[1] { @01A4 memory[0x00:0x00] } 01A1 60 PUSH1 0x00 01A3 80 DUP1 01A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @01A4 revert(memory[0x00:0x00]); } // Block terminates label_01A5: // Incoming jump from 0x01A0, if !msg.value 01A5 5B JUMPDEST 01A6 50 POP 01A7 61 PUSH2 0x0187 01AA 61 PUSH2 0x08f1 01AD 56 *JUMP // Stack delta = +0 // Outputs[1] { @01A7 stack[-1] = 0x0187 } // Block ends with call to 0x08f1, returns to 0x0187 label_01AE: // Incoming jump from 0x0113, if 0x3ccfd60b == stack[-1] 01AE 5B JUMPDEST 01AF 61 PUSH2 0x013b 01B2 61 PUSH2 0x08f7 01B5 56 *JUMP // Stack delta = +1 // Outputs[1] { @01AF stack[0] = 0x013b } // Block ends with call to 0x08f7, returns to 0x013B label_01B6: // Incoming jump from 0x00B6, if 0x423f6cef == stack[-1] // Inputs[1] { @01B7 msg.value } 01B6 5B JUMPDEST 01B7 34 CALLVALUE 01B8 80 DUP1 01B9 15 ISZERO 01BA 61 PUSH2 0x01c2 01BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01B7 stack[0] = msg.value } // Block ends with conditional jump to 0x01c2, if !msg.value label_01BE: // Incoming jump from 0x01BD, if not !msg.value // Inputs[1] { @01C1 memory[0x00:0x00] } 01BE 60 PUSH1 0x00 01C0 80 DUP1 01C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C1 revert(memory[0x00:0x00]); } // Block terminates label_01C2: // Incoming jump from 0x01BD, if !msg.value // Inputs[1] { @01CA msg.data.length } 01C2 5B JUMPDEST 01C3 50 POP 01C4 61 PUSH2 0x013b 01C7 60 PUSH1 0x04 01C9 80 DUP1 01CA 36 CALLDATASIZE 01CB 03 SUB 01CC 60 PUSH1 0x40 01CE 81 DUP2 01CF 10 LT 01D0 15 ISZERO 01D1 61 PUSH2 0x01d9 01D4 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @01C4 stack[-1] = 0x013b // @01C7 stack[0] = 0x04 // @01CB stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x01d9, returns to 0x013B, if !(msg.data.length - 0x04 < 0x40) label_01D5: // Incoming jump from 0x01D4, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @01D8 memory[0x00:0x00] } 01D5 60 PUSH1 0x00 01D7 80 DUP1 01D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D8 revert(memory[0x00:0x00]); } // Block terminates label_01D9: // Incoming call from 0x01D4, returns to 0x013B, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @01E3 stack[-2] // @01E4 msg.data[stack[-2]:stack[-2] + 0x20] // @01EA msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 01D9 5B JUMPDEST 01DA 50 POP 01DB 60 PUSH1 0x01 01DD 60 PUSH1 0x01 01DF 60 PUSH1 0xa0 01E1 1B SHL 01E2 03 SUB 01E3 81 DUP2 01E4 35 CALLDATALOAD 01E5 16 AND 01E6 90 SWAP1 01E7 60 PUSH1 0x20 01E9 01 ADD 01EA 35 CALLDATALOAD 01EB 61 PUSH2 0x0958 01EE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01E6 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @01EA stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0958 label_01EF: // Incoming jump from 0x00C1, if 0x52b0761d == stack[-1] // Inputs[1] { @01F0 msg.value } 01EF 5B JUMPDEST 01F0 34 CALLVALUE 01F1 80 DUP1 01F2 15 ISZERO 01F3 61 PUSH2 0x01fb 01F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01F0 stack[0] = msg.value } // Block ends with conditional jump to 0x01fb, if !msg.value label_01F7: // Incoming jump from 0x01F6, if not !msg.value // Inputs[1] { @01FA memory[0x00:0x00] } 01F7 60 PUSH1 0x00 01F9 80 DUP1 01FA FD *REVERT // Stack delta = +0 // Outputs[1] { @01FA revert(memory[0x00:0x00]); } // Block terminates label_01FB: // Incoming jump from 0x01F6, if !msg.value // Inputs[1] { @0203 msg.data.length } 01FB 5B JUMPDEST 01FC 50 POP 01FD 61 PUSH2 0x0222 0200 60 PUSH1 0x04 0202 80 DUP1 0203 36 CALLDATASIZE 0204 03 SUB 0205 60 PUSH1 0x20 0207 81 DUP2 0208 10 LT 0209 15 ISZERO 020A 61 PUSH2 0x0212 020D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @01FD stack[-1] = 0x0222 // @0200 stack[0] = 0x04 // @0204 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0212, returns to 0x0222, if !(msg.data.length - 0x04 < 0x20) label_020E: // Incoming jump from 0x020D, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0211 memory[0x00:0x00] } 020E 60 PUSH1 0x00 0210 80 DUP1 0211 FD *REVERT // Stack delta = +0 // Outputs[1] { @0211 revert(memory[0x00:0x00]); } // Block terminates label_0212: // Incoming call from 0x020D, returns to 0x0222, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0214 msg.data[stack[-2]:stack[-2] + 0x20] // @0214 stack[-2] // } 0212 5B JUMPDEST 0213 50 POP 0214 35 CALLDATALOAD 0215 60 PUSH1 0x01 0217 60 PUSH1 0x01 0219 60 PUSH1 0xa0 021B 1B SHL 021C 03 SUB 021D 16 AND 021E 61 PUSH2 0x09bd 0221 56 *JUMP // Stack delta = -1 // Outputs[1] { @021D stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x09bd label_0222: // Incoming return from call to 0x02B6 at 0x02B1 // Incoming return from call to 0x0212 at 0x020D // Inputs[4] // { // @0226 memory[0x40:0x60] // @0227 stack[-1] // @022C memory[0x40:0x60] // @0235 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0222 5B JUMPDEST 0223 60 PUSH1 0x40 0225 80 DUP1 0226 51 MLOAD 0227 91 SWAP2 0228 15 ISZERO 0229 15 ISZERO 022A 82 DUP3 022B 52 MSTORE 022C 51 MLOAD 022D 90 SWAP1 022E 81 DUP2 022F 90 SWAP1 0230 03 SUB 0231 60 PUSH1 0x20 0233 01 ADD 0234 90 SWAP1 0235 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @022B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0235 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0236: // Incoming jump from 0x00CC, if 0x66dd0f24 == stack[-1] // Inputs[1] { @0237 msg.value } 0236 5B JUMPDEST 0237 34 CALLVALUE 0238 80 DUP1 0239 15 ISZERO 023A 61 PUSH2 0x0242 023D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0237 stack[0] = msg.value } // Block ends with conditional jump to 0x0242, if !msg.value label_023E: // Incoming jump from 0x023D, if not !msg.value // Inputs[1] { @0241 memory[0x00:0x00] } 023E 60 PUSH1 0x00 0240 80 DUP1 0241 FD *REVERT // Stack delta = +0 // Outputs[1] { @0241 revert(memory[0x00:0x00]); } // Block terminates label_0242: // Incoming jump from 0x023D, if !msg.value // Inputs[1] { @024A msg.data.length } 0242 5B JUMPDEST 0243 50 POP 0244 61 PUSH2 0x013b 0247 60 PUSH1 0x04 0249 80 DUP1 024A 36 CALLDATASIZE 024B 03 SUB 024C 60 PUSH1 0x20 024E 81 DUP2 024F 10 LT 0250 15 ISZERO 0251 61 PUSH2 0x0259 0254 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0244 stack[-1] = 0x013b // @0247 stack[0] = 0x04 // @024B stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0259, returns to 0x013B, if !(msg.data.length - 0x04 < 0x20) label_0255: // Incoming jump from 0x0254, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0258 memory[0x00:0x00] } 0255 60 PUSH1 0x00 0257 80 DUP1 0258 FD *REVERT // Stack delta = +0 // Outputs[1] { @0258 revert(memory[0x00:0x00]); } // Block terminates label_0259: // Incoming call from 0x0254, returns to 0x013B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @025B msg.data[stack[-2]:stack[-2] + 0x20] // @025B stack[-2] // } 0259 5B JUMPDEST 025A 50 POP 025B 35 CALLDATALOAD 025C 61 PUSH2 0x09d2 025F 56 *JUMP // Stack delta = -1 // Outputs[1] { @025B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x09d2 label_0260: // Incoming jump from 0x00D7, if 0x752adc32 == stack[-1] // Inputs[1] { @0261 msg.value } 0260 5B JUMPDEST 0261 34 CALLVALUE 0262 80 DUP1 0263 15 ISZERO 0264 61 PUSH2 0x026c 0267 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0261 stack[0] = msg.value } // Block ends with conditional jump to 0x026c, if !msg.value label_0268: // Incoming jump from 0x0267, if not !msg.value // Inputs[1] { @026B memory[0x00:0x00] } 0268 60 PUSH1 0x00 026A 80 DUP1 026B FD *REVERT // Stack delta = +0 // Outputs[1] { @026B revert(memory[0x00:0x00]); } // Block terminates label_026C: // Incoming jump from 0x0267, if !msg.value // Inputs[1] { @0274 msg.data.length } 026C 5B JUMPDEST 026D 50 POP 026E 61 PUSH2 0x013b 0271 60 PUSH1 0x04 0273 80 DUP1 0274 36 CALLDATASIZE 0275 03 SUB 0276 60 PUSH1 0x20 0278 81 DUP2 0279 10 LT 027A 15 ISZERO 027B 61 PUSH2 0x0283 027E 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @026E stack[-1] = 0x013b // @0271 stack[0] = 0x04 // @0275 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0283, returns to 0x013B, if !(msg.data.length - 0x04 < 0x20) label_027F: // Incoming jump from 0x027E, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0282 memory[0x00:0x00] } 027F 60 PUSH1 0x00 0281 80 DUP1 0282 FD *REVERT // Stack delta = +0 // Outputs[1] { @0282 revert(memory[0x00:0x00]); } // Block terminates label_0283: // Incoming call from 0x027E, returns to 0x013B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0285 msg.data[stack[-2]:stack[-2] + 0x20] // @0285 stack[-2] // } 0283 5B JUMPDEST 0284 50 POP 0285 35 CALLDATALOAD 0286 60 PUSH1 0x01 0288 60 PUSH1 0x01 028A 60 PUSH1 0xa0 028C 1B SHL 028D 03 SUB 028E 16 AND 028F 61 PUSH2 0x0a8a 0292 56 *JUMP // Stack delta = -1 // Outputs[1] { @028E stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0a8a label_0293: // Incoming jump from 0x00E2, if 0x77cf7630 == stack[-1] // Inputs[1] { @0294 msg.value } 0293 5B JUMPDEST 0294 34 CALLVALUE 0295 80 DUP1 0296 15 ISZERO 0297 61 PUSH2 0x029f 029A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0294 stack[0] = msg.value } // Block ends with conditional jump to 0x029f, if !msg.value label_029B: // Incoming jump from 0x029A, if not !msg.value // Inputs[1] { @029E memory[0x00:0x00] } 029B 60 PUSH1 0x00 029D 80 DUP1 029E FD *REVERT // Stack delta = +0 // Outputs[1] { @029E revert(memory[0x00:0x00]); } // Block terminates label_029F: // Incoming jump from 0x029A, if !msg.value // Inputs[1] { @02A7 msg.data.length } 029F 5B JUMPDEST 02A0 50 POP 02A1 61 PUSH2 0x0222 02A4 60 PUSH1 0x04 02A6 80 DUP1 02A7 36 CALLDATASIZE 02A8 03 SUB 02A9 60 PUSH1 0x20 02AB 81 DUP2 02AC 10 LT 02AD 15 ISZERO 02AE 61 PUSH2 0x02b6 02B1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @02A1 stack[-1] = 0x0222 // @02A4 stack[0] = 0x04 // @02A8 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x02b6, returns to 0x0222, if !(msg.data.length - 0x04 < 0x20) label_02B2: // Incoming jump from 0x02B1, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @02B5 memory[0x00:0x00] } 02B2 60 PUSH1 0x00 02B4 80 DUP1 02B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B5 revert(memory[0x00:0x00]); } // Block terminates label_02B6: // Incoming call from 0x02B1, returns to 0x0222, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @02B8 msg.data[stack[-2]:stack[-2] + 0x20] // @02B8 stack[-2] // } 02B6 5B JUMPDEST 02B7 50 POP 02B8 35 CALLDATALOAD 02B9 60 PUSH1 0x01 02BB 60 PUSH1 0x01 02BD 60 PUSH1 0xa0 02BF 1B SHL 02C0 03 SUB 02C1 16 AND 02C2 61 PUSH2 0x0af5 02C5 56 *JUMP // Stack delta = -1 // Outputs[1] { @02C1 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0af5 label_02C6: // Incoming jump from 0x006F, if 0x8da5cb5b == stack[-1] // Inputs[1] { @02C7 msg.value } 02C6 5B JUMPDEST 02C7 34 CALLVALUE 02C8 80 DUP1 02C9 15 ISZERO 02CA 61 PUSH2 0x02d2 02CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C7 stack[0] = msg.value } // Block ends with conditional jump to 0x02d2, if !msg.value label_02CE: // Incoming jump from 0x02CD, if not !msg.value // Inputs[1] { @02D1 memory[0x00:0x00] } 02CE 60 PUSH1 0x00 02D0 80 DUP1 02D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D1 revert(memory[0x00:0x00]); } // Block terminates label_02D2: // Incoming jump from 0x02CD, if !msg.value 02D2 5B JUMPDEST 02D3 50 POP 02D4 61 PUSH2 0x02db 02D7 61 PUSH2 0x0b0a 02DA 56 *JUMP // Stack delta = +0 // Outputs[1] { @02D4 stack[-1] = 0x02db } // Block ends with call to 0x0b0a, returns to 0x02DB label_02DB: // Incoming return from call to 0x137D at 0x0485 // Incoming return from call to 0x0B0A at 0x02DA // Incoming return from call to 0x0B19 at 0x030B // Incoming return from call to 0x13A1 at 0x049A // Inputs[4] // { // @02DF memory[0x40:0x60] // @02E9 stack[-1] // @02ED memory[0x40:0x60] // @02F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 02DB 5B JUMPDEST 02DC 60 PUSH1 0x40 02DE 80 DUP1 02DF 51 MLOAD 02E0 60 PUSH1 0x01 02E2 60 PUSH1 0x01 02E4 60 PUSH1 0xa0 02E6 1B SHL 02E7 03 SUB 02E8 90 SWAP1 02E9 92 SWAP3 02EA 16 AND 02EB 82 DUP3 02EC 52 MSTORE 02ED 51 MLOAD 02EE 90 SWAP1 02EF 81 DUP2 02F0 90 SWAP1 02F1 03 SUB 02F2 60 PUSH1 0x20 02F4 01 ADD 02F5 90 SWAP1 02F6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02F6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_02F7: // Incoming jump from 0x007A, if 0x986f5585 == stack[-1] // Inputs[1] { @02F8 msg.value } 02F7 5B JUMPDEST 02F8 34 CALLVALUE 02F9 80 DUP1 02FA 15 ISZERO 02FB 61 PUSH2 0x0303 02FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0303, if !msg.value label_02FF: // Incoming jump from 0x02FE, if not !msg.value // Inputs[1] { @0302 memory[0x00:0x00] } 02FF 60 PUSH1 0x00 0301 80 DUP1 0302 FD *REVERT // Stack delta = +0 // Outputs[1] { @0302 revert(memory[0x00:0x00]); } // Block terminates label_0303: // Incoming jump from 0x02FE, if !msg.value 0303 5B JUMPDEST 0304 50 POP 0305 61 PUSH2 0x02db 0308 61 PUSH2 0x0b19 030B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0305 stack[-1] = 0x02db } // Block ends with call to 0x0b19, returns to 0x02DB label_030C: // Incoming jump from 0x0085, if 0xa3aa1989 == stack[-1] // Inputs[1] { @030D msg.value } 030C 5B JUMPDEST 030D 34 CALLVALUE 030E 80 DUP1 030F 15 ISZERO 0310 61 PUSH2 0x0318 0313 57 *JUMPI // Stack delta = +1 // Outputs[1] { @030D stack[0] = msg.value } // Block ends with conditional jump to 0x0318, if !msg.value label_0314: // Incoming jump from 0x0313, if not !msg.value // Inputs[1] { @0317 memory[0x00:0x00] } 0314 60 PUSH1 0x00 0316 80 DUP1 0317 FD *REVERT // Stack delta = +0 // Outputs[1] { @0317 revert(memory[0x00:0x00]); } // Block terminates label_0318: // Incoming jump from 0x0313, if !msg.value // Inputs[1] { @0320 msg.data.length } 0318 5B JUMPDEST 0319 50 POP 031A 61 PUSH2 0x013b 031D 60 PUSH1 0x04 031F 80 DUP1 0320 36 CALLDATASIZE 0321 03 SUB 0322 60 PUSH1 0x20 0324 81 DUP2 0325 10 LT 0326 15 ISZERO 0327 61 PUSH2 0x032f 032A 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @031A stack[-1] = 0x013b // @031D stack[0] = 0x04 // @0321 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x032f, returns to 0x013B, if !(msg.data.length - 0x04 < 0x20) label_032B: // Incoming jump from 0x032A, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @032E memory[0x00:0x00] } 032B 60 PUSH1 0x00 032D 80 DUP1 032E FD *REVERT // Stack delta = +0 // Outputs[1] { @032E revert(memory[0x00:0x00]); } // Block terminates label_032F: // Incoming call from 0x032A, returns to 0x013B, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0330 stack[-2] // @0331 stack[-1] // @0338 msg.data[stack[-2]:stack[-2] + 0x20] // } 032F 5B JUMPDEST 0330 81 DUP2 0331 01 ADD 0332 90 SWAP1 0333 60 PUSH1 0x20 0335 81 DUP2 0336 01 ADD 0337 81 DUP2 0338 35 CALLDATALOAD 0339 64 PUSH5 0x0100000000 033F 81 DUP2 0340 11 GT 0341 15 ISZERO 0342 61 PUSH2 0x034a 0345 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0332 stack[-1] = stack[-2] // @0332 stack[-2] = stack[-2] + stack[-1] // @0336 stack[0] = stack[-2] + 0x20 // @0338 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x034a, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0346: // Incoming jump from 0x0345, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0349 memory[0x00:0x00] } 0346 60 PUSH1 0x00 0348 80 DUP1 0349 FD *REVERT // Stack delta = +0 // Outputs[1] { @0349 revert(memory[0x00:0x00]); } // Block terminates label_034A: // Incoming jump from 0x0345, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @034B stack[-3] // @034C stack[-1] // @034D stack[-4] // } 034A 5B JUMPDEST 034B 82 DUP3 034C 01 ADD 034D 83 DUP4 034E 60 PUSH1 0x20 0350 82 DUP3 0351 01 ADD 0352 11 GT 0353 15 ISZERO 0354 61 PUSH2 0x035c 0357 57 *JUMPI // Stack delta = +0 // Outputs[1] { @034C stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x035c, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0358: // Incoming jump from 0x0357, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @035B memory[0x00:0x00] } 0358 60 PUSH1 0x00 035A 80 DUP1 035B FD *REVERT // Stack delta = +0 // Outputs[1] { @035B revert(memory[0x00:0x00]); } // Block terminates label_035C: // Incoming jump from 0x0357, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @035D stack[-1] // @035E msg.data[stack[-1]:stack[-1] + 0x20] // @0363 stack[-2] // @0364 stack[-4] // } 035C 5B JUMPDEST 035D 80 DUP1 035E 35 CALLDATALOAD 035F 90 SWAP1 0360 60 PUSH1 0x20 0362 01 ADD 0363 91 SWAP2 0364 84 DUP5 0365 60 PUSH1 0x20 0367 83 DUP4 0368 02 MUL 0369 84 DUP5 036A 01 ADD 036B 11 GT 036C 64 PUSH5 0x0100000000 0372 83 DUP4 0373 11 GT 0374 17 OR 0375 15 ISZERO 0376 61 PUSH2 0x037e 0379 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @035F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0363 stack[0] = stack[-2] // @0363 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x037e, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_037A: // Incoming jump from 0x0379, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @037D memory[0x00:0x00] } 037A 60 PUSH1 0x00 037C 80 DUP1 037D FD *REVERT // Stack delta = +0 // Outputs[1] { @037D revert(memory[0x00:0x00]); } // Block terminates label_037E: // Incoming jump from 0x0379, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[4] // { // @0380 stack[-3] // @0380 stack[-2] // @0381 stack[-5] // @0383 stack[-4] // } 037E 5B JUMPDEST 037F 50 POP 0380 90 SWAP1 0381 92 SWAP3 0382 50 POP 0383 90 SWAP1 0384 50 POP 0385 61 PUSH2 0x0b28 0388 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0381 stack[-5] = stack[-3] // @0383 stack[-4] = stack[-2] // } // Block ends with unconditional jump to 0x0b28 label_0389: // Incoming jump from 0x0090, if 0xa3c68f4c == stack[-1] // Inputs[1] { @038A msg.value } 0389 5B JUMPDEST 038A 34 CALLVALUE 038B 80 DUP1 038C 15 ISZERO 038D 61 PUSH2 0x0395 0390 57 *JUMPI // Stack delta = +1 // Outputs[1] { @038A stack[0] = msg.value } // Block ends with conditional jump to 0x0395, if !msg.value label_0391: // Incoming jump from 0x0390, if not !msg.value // Inputs[1] { @0394 memory[0x00:0x00] } 0391 60 PUSH1 0x00 0393 80 DUP1 0394 FD *REVERT // Stack delta = +0 // Outputs[1] { @0394 revert(memory[0x00:0x00]); } // Block terminates label_0395: // Incoming jump from 0x0390, if !msg.value // Inputs[1] { @039D msg.data.length } 0395 5B JUMPDEST 0396 50 POP 0397 61 PUSH2 0x013b 039A 60 PUSH1 0x04 039C 80 DUP1 039D 36 CALLDATASIZE 039E 03 SUB 039F 60 PUSH1 0x60 03A1 81 DUP2 03A2 10 LT 03A3 15 ISZERO 03A4 61 PUSH2 0x03ac 03A7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0397 stack[-1] = 0x013b // @039A stack[0] = 0x04 // @039E stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03ac, returns to 0x013B, if !(msg.data.length - 0x04 < 0x60) label_03A8: // Incoming jump from 0x03A7, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @03AB memory[0x00:0x00] } 03A8 60 PUSH1 0x00 03AA 80 DUP1 03AB FD *REVERT // Stack delta = +0 // Outputs[1] { @03AB revert(memory[0x00:0x00]); } // Block terminates label_03AC: // Incoming call from 0x03A7, returns to 0x013B, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @03AE stack[-2] // @03AF msg.data[stack[-2]:stack[-2] + 0x20] // @03B5 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03BA msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 03AC 5B JUMPDEST 03AD 50 POP 03AE 80 DUP1 03AF 35 CALLDATALOAD 03B0 90 SWAP1 03B1 60 PUSH1 0x20 03B3 81 DUP2 03B4 01 ADD 03B5 35 CALLDATALOAD 03B6 90 SWAP1 03B7 60 PUSH1 0x40 03B9 01 ADD 03BA 35 CALLDATALOAD 03BB 61 PUSH2 0x0ea8 03BE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @03B0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @03B6 stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @03BA stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x0ea8 label_03BF: // Incoming jump from 0x009B, if 0xa74e0691 == stack[-1] // Inputs[1] { @03C0 msg.value } 03BF 5B JUMPDEST 03C0 34 CALLVALUE 03C1 80 DUP1 03C2 15 ISZERO 03C3 61 PUSH2 0x03cb 03C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C0 stack[0] = msg.value } // Block ends with conditional jump to 0x03cb, if !msg.value label_03C7: // Incoming jump from 0x03C6, if not !msg.value // Inputs[1] { @03CA memory[0x00:0x00] } 03C7 60 PUSH1 0x00 03C9 80 DUP1 03CA FD *REVERT // Stack delta = +0 // Outputs[1] { @03CA revert(memory[0x00:0x00]); } // Block terminates label_03CB: // Incoming jump from 0x03C6, if !msg.value // Inputs[1] { @03D3 msg.data.length } 03CB 5B JUMPDEST 03CC 50 POP 03CD 61 PUSH2 0x013b 03D0 60 PUSH1 0x04 03D2 80 DUP1 03D3 36 CALLDATASIZE 03D4 03 SUB 03D5 60 PUSH1 0x40 03D7 81 DUP2 03D8 10 LT 03D9 15 ISZERO 03DA 61 PUSH2 0x03e2 03DD 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03CD stack[-1] = 0x013b // @03D0 stack[0] = 0x04 // @03D4 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03e2, returns to 0x013B, if !(msg.data.length - 0x04 < 0x40) label_03DE: // Incoming jump from 0x03DD, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @03E1 memory[0x00:0x00] } 03DE 60 PUSH1 0x00 03E0 80 DUP1 03E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E1 revert(memory[0x00:0x00]); } // Block terminates label_03E2: // Incoming call from 0x03DD, returns to 0x013B, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @03E3 stack[-2] // @03E4 stack[-1] // @03EB msg.data[stack[-2]:stack[-2] + 0x20] // } 03E2 5B JUMPDEST 03E3 81 DUP2 03E4 01 ADD 03E5 90 SWAP1 03E6 60 PUSH1 0x20 03E8 81 DUP2 03E9 01 ADD 03EA 81 DUP2 03EB 35 CALLDATALOAD 03EC 64 PUSH5 0x0100000000 03F2 81 DUP2 03F3 11 GT 03F4 15 ISZERO 03F5 61 PUSH2 0x03fd 03F8 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @03E5 stack[-1] = stack[-2] // @03E5 stack[-2] = stack[-2] + stack[-1] // @03E9 stack[0] = stack[-2] + 0x20 // @03EB stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x03fd, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_03F9: // Incoming jump from 0x03F8, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @03FC memory[0x00:0x00] } 03F9 60 PUSH1 0x00 03FB 80 DUP1 03FC FD *REVERT // Stack delta = +0 // Outputs[1] { @03FC revert(memory[0x00:0x00]); } // Block terminates label_03FD: // Incoming jump from 0x03F8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @03FE stack[-3] // @03FF stack[-1] // @0400 stack[-4] // } 03FD 5B JUMPDEST 03FE 82 DUP3 03FF 01 ADD 0400 83 DUP4 0401 60 PUSH1 0x20 0403 82 DUP3 0404 01 ADD 0405 11 GT 0406 15 ISZERO 0407 61 PUSH2 0x040f 040A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03FF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x040f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_040B: // Incoming jump from 0x040A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @040E memory[0x00:0x00] } 040B 60 PUSH1 0x00 040D 80 DUP1 040E FD *REVERT // Stack delta = +0 // Outputs[1] { @040E revert(memory[0x00:0x00]); } // Block terminates label_040F: // Incoming jump from 0x040A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0410 stack[-1] // @0411 msg.data[stack[-1]:stack[-1] + 0x20] // @0416 stack[-2] // @0417 stack[-4] // } 040F 5B JUMPDEST 0410 80 DUP1 0411 35 CALLDATALOAD 0412 90 SWAP1 0413 60 PUSH1 0x20 0415 01 ADD 0416 91 SWAP2 0417 84 DUP5 0418 60 PUSH1 0x20 041A 83 DUP4 041B 02 MUL 041C 84 DUP5 041D 01 ADD 041E 11 GT 041F 64 PUSH5 0x0100000000 0425 83 DUP4 0426 11 GT 0427 17 OR 0428 15 ISZERO 0429 61 PUSH2 0x0431 042C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0412 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0416 stack[0] = stack[-2] // @0416 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0431, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) label_042D: // Incoming jump from 0x042C, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[1] { @0430 memory[0x00:0x00] } 042D 60 PUSH1 0x00 042F 80 DUP1 0430 FD *REVERT // Stack delta = +0 // Outputs[1] { @0430 revert(memory[0x00:0x00]); } // Block terminates label_0431: // Incoming jump from 0x042C, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x20 > stack[-4])) // Inputs[8] // { // @0432 stack[-3] // @0432 stack[-1] // @0433 stack[-2] // @043E memory[0x40:0x60] // @0458 msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0463 stack[-5] // @0468 msg.data[stack[-1]:stack[-1] + 0x20] // @046B stack[-4] // } 0431 5B JUMPDEST 0432 91 SWAP2 0433 90 SWAP1 0434 80 DUP1 0435 80 DUP1 0436 60 PUSH1 0x20 0438 02 MUL 0439 60 PUSH1 0x20 043B 01 ADD 043C 60 PUSH1 0x40 043E 51 MLOAD 043F 90 SWAP1 0440 81 DUP2 0441 01 ADD 0442 60 PUSH1 0x40 0444 52 MSTORE 0445 80 DUP1 0446 93 SWAP4 0447 92 SWAP3 0448 91 SWAP2 0449 90 SWAP1 044A 81 DUP2 044B 81 DUP2 044C 52 MSTORE 044D 60 PUSH1 0x20 044F 01 ADD 0450 83 DUP4 0451 83 DUP4 0452 60 PUSH1 0x20 0454 02 MUL 0455 80 DUP1 0456 82 DUP3 0457 84 DUP5 0458 37 CALLDATACOPY 0459 60 PUSH1 0x00 045B 92 SWAP3 045C 01 ADD 045D 91 SWAP2 045E 90 SWAP1 045F 91 SWAP2 0460 52 MSTORE 0461 50 POP 0462 92 SWAP3 0463 95 SWAP6 0464 50 POP 0465 50 POP 0466 50 POP 0467 50 POP 0468 35 CALLDATALOAD 0469 15 ISZERO 046A 15 ISZERO 046B 90 SWAP1 046C 50 POP 046D 61 PUSH2 0x129d 0470 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @0444 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // @044C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0458 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20 * stack[-2]] // @0460 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-2]:0x20 + memory[0x40:0x60] + 0x20 * stack[-2] + 0x20] = 0x00 // @0463 stack[-5] = memory[0x40:0x60] // @046B stack[-4] = !!msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x129d label_0471: // Incoming jump from 0x0033, if 0xad5c4648 == stack[-1] // Inputs[1] { @0472 msg.value } 0471 5B JUMPDEST 0472 34 CALLVALUE 0473 80 DUP1 0474 15 ISZERO 0475 61 PUSH2 0x047d 0478 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0472 stack[0] = msg.value } // Block ends with conditional jump to 0x047d, if !msg.value label_0479: // Incoming jump from 0x0478, if not !msg.value // Inputs[1] { @047C memory[0x00:0x00] } 0479 60 PUSH1 0x00 047B 80 DUP1 047C FD *REVERT // Stack delta = +0 // Outputs[1] { @047C revert(memory[0x00:0x00]); } // Block terminates label_047D: // Incoming jump from 0x0478, if !msg.value 047D 5B JUMPDEST 047E 50 POP 047F 61 PUSH2 0x02db 0482 61 PUSH2 0x137d 0485 56 *JUMP // Stack delta = +0 // Outputs[1] { @047F stack[-1] = 0x02db } // Block ends with call to 0x137d, returns to 0x02DB label_0486: // Incoming jump from 0x003E, if 0xc45a0155 == stack[-1] // Inputs[1] { @0487 msg.value } 0486 5B JUMPDEST 0487 34 CALLVALUE 0488 80 DUP1 0489 15 ISZERO 048A 61 PUSH2 0x0492 048D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0487 stack[0] = msg.value } // Block ends with conditional jump to 0x0492, if !msg.value label_048E: // Incoming jump from 0x048D, if not !msg.value // Inputs[1] { @0491 memory[0x00:0x00] } 048E 60 PUSH1 0x00 0490 80 DUP1 0491 FD *REVERT // Stack delta = +0 // Outputs[1] { @0491 revert(memory[0x00:0x00]); } // Block terminates label_0492: // Incoming jump from 0x048D, if !msg.value 0492 5B JUMPDEST 0493 50 POP 0494 61 PUSH2 0x02db 0497 61 PUSH2 0x13a1 049A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0494 stack[-1] = 0x02db } // Block ends with call to 0x13a1, returns to 0x02DB label_049B: // Incoming jump from 0x0049, if 0xcfa5d34d == stack[-1] // Inputs[1] { @04A2 msg.data.length } 049B 5B JUMPDEST 049C 61 PUSH2 0x013b 049F 60 PUSH1 0x04 04A1 80 DUP1 04A2 36 CALLDATASIZE 04A3 03 SUB 04A4 60 PUSH1 0x80 04A6 81 DUP2 04A7 10 LT 04A8 15 ISZERO 04A9 61 PUSH2 0x04b1 04AC 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @049C stack[0] = 0x013b // @049F stack[1] = 0x04 // @04A3 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04b1, returns to 0x013B, if !(msg.data.length - 0x04 < 0x80) label_04AD: // Incoming jump from 0x04AC, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @04B0 memory[0x00:0x00] } 04AD 60 PUSH1 0x00 04AF 80 DUP1 04B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B0 revert(memory[0x00:0x00]); } // Block terminates label_04B1: // Incoming call from 0x04AC, returns to 0x013B, if !(msg.data.length - 0x04 < 0x80) // Inputs[5] // { // @04B3 stack[-2] // @04B4 msg.data[stack[-2]:stack[-2] + 0x20] // @04BA msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @04C0 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @04C5 msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } 04B1 5B JUMPDEST 04B2 50 POP 04B3 80 DUP1 04B4 35 CALLDATALOAD 04B5 90 SWAP1 04B6 60 PUSH1 0x20 04B8 81 DUP2 04B9 01 ADD 04BA 35 CALLDATALOAD 04BB 90 SWAP1 04BC 60 PUSH1 0x40 04BE 81 DUP2 04BF 01 ADD 04C0 35 CALLDATALOAD 04C1 90 SWAP1 04C2 60 PUSH1 0x60 04C4 01 ADD 04C5 35 CALLDATALOAD 04C6 61 PUSH2 0x13c5 04C9 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @04B5 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] // @04BB stack[-1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @04C1 stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @04C5 stack[1] = msg.data[0x60 + stack[-2]:0x60 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x13c5 label_04CA: // Incoming jump from 0x0054, if 0xeb5625d9 == stack[-1] // Inputs[1] { @04CB msg.value } 04CA 5B JUMPDEST 04CB 34 CALLVALUE 04CC 80 DUP1 04CD 15 ISZERO 04CE 61 PUSH2 0x04d6 04D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CB stack[0] = msg.value } // Block ends with conditional jump to 0x04d6, if !msg.value label_04D2: // Incoming jump from 0x04D1, if not !msg.value // Inputs[1] { @04D5 memory[0x00:0x00] } 04D2 60 PUSH1 0x00 04D4 80 DUP1 04D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D5 revert(memory[0x00:0x00]); } // Block terminates label_04D6: // Incoming jump from 0x04D1, if !msg.value // Inputs[1] { @04DE msg.data.length } 04D6 5B JUMPDEST 04D7 50 POP 04D8 61 PUSH2 0x013b 04DB 60 PUSH1 0x04 04DD 80 DUP1 04DE 36 CALLDATASIZE 04DF 03 SUB 04E0 60 PUSH1 0x60 04E2 81 DUP2 04E3 10 LT 04E4 15 ISZERO 04E5 61 PUSH2 0x04ed 04E8 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04D8 stack[-1] = 0x013b // @04DB stack[0] = 0x04 // @04DF stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x04ed, if !(msg.data.length - 0x04 < 0x60) label_04E9: // Incoming jump from 0x04E8, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @04EC memory[0x00:0x00] } 04E9 60 PUSH1 0x00 04EB 80 DUP1 04EC FD *REVERT // Stack delta = +0 // Outputs[1] { @04EC revert(memory[0x00:0x00]); } // Block terminates label_04ED: // Incoming jump from 0x04E8, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @04F7 stack[-2] // @04F8 msg.data[stack[-2]:stack[-2] + 0x20] // @0500 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0508 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 04ED 5B JUMPDEST 04EE 50 POP 04EF 60 PUSH1 0x01 04F1 60 PUSH1 0x01 04F3 60 PUSH1 0xa0 04F5 1B SHL 04F6 03 SUB 04F7 81 DUP2 04F8 35 CALLDATALOAD 04F9 81 DUP2 04FA 16 AND 04FB 91 SWAP2 04FC 60 PUSH1 0x20 04FE 81 DUP2 04FF 01 ADD 0500 35 CALLDATALOAD 0501 90 SWAP1 0502 91 SWAP2 0503 16 AND 0504 90 SWAP1 0505 60 PUSH1 0x40 0507 01 ADD 0508 35 CALLDATALOAD 0509 61 PUSH2 0x16d6 050C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @04FB stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0504 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0508 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x16d6 label_050D: // Incoming jump from 0x005F, if 0xfc4dd333 == stack[-1] // Inputs[1] { @050E msg.value } 050D 5B JUMPDEST 050E 34 CALLVALUE 050F 80 DUP1 0510 15 ISZERO 0511 61 PUSH2 0x0519 0514 57 *JUMPI // Stack delta = +1 // Outputs[1] { @050E stack[0] = msg.value } // Block ends with conditional jump to 0x0519, if !msg.value label_0515: // Incoming jump from 0x0514, if not !msg.value // Inputs[1] { @0518 memory[0x00:0x00] } 0515 60 PUSH1 0x00 0517 80 DUP1 0518 FD *REVERT // Stack delta = +0 // Outputs[1] { @0518 revert(memory[0x00:0x00]); } // Block terminates label_0519: // Incoming jump from 0x0514, if !msg.value // Inputs[1] { @0521 msg.data.length } 0519 5B JUMPDEST 051A 50 POP 051B 61 PUSH2 0x013b 051E 60 PUSH1 0x04 0520 80 DUP1 0521 36 CALLDATASIZE 0522 03 SUB 0523 60 PUSH1 0x20 0525 81 DUP2 0526 10 LT 0527 15 ISZERO 0528 61 PUSH2 0x0530 052B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @051B stack[-1] = 0x013b // @051E stack[0] = 0x04 // @0522 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0530, returns to 0x013B, if !(msg.data.length - 0x04 < 0x20) label_052C: // Incoming jump from 0x052B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @052F memory[0x00:0x00] } 052C 60 PUSH1 0x00 052E 80 DUP1 052F FD *REVERT // Stack delta = +0 // Outputs[1] { @052F revert(memory[0x00:0x00]); } // Block terminates label_0530: // Incoming call from 0x052B, returns to 0x013B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0532 msg.data[stack[-2]:stack[-2] + 0x20] // @0532 stack[-2] // } 0530 5B JUMPDEST 0531 50 POP 0532 35 CALLDATALOAD 0533 61 PUSH2 0x172a 0536 56 *JUMP // Stack delta = -1 // Outputs[1] { @0532 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x172a label_0537: // Incoming jump from 0x0171 // Inputs[3] // { // @0538 msg.sender // @0546 memory[0x00:0x40] // @0547 storage[keccak256(memory[0x00:0x40])] // } 0537 5B JUMPDEST 0538 33 CALLER 0539 60 PUSH1 0x00 053B 90 SWAP1 053C 81 DUP2 053D 52 MSTORE 053E 60 PUSH1 0x04 0540 60 PUSH1 0x20 0542 52 MSTORE 0543 60 PUSH1 0x40 0545 90 SWAP1 0546 20 SHA3 0547 54 SLOAD 0548 60 PUSH1 0xff 054A 16 AND 054B 15 ISZERO 054C 15 ISZERO 054D 60 PUSH1 0x01 054F 14 EQ 0550 61 PUSH2 0x058b 0553 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @053D memory[0x00:0x20] = msg.sender // @0542 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x058b, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) label_0554: // Incoming jump from 0x0553, if not 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0557 memory[0x40:0x60] // @0581 memory[0x40:0x60] // @058A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0554 60 PUSH1 0x40 0556 80 DUP1 0557 51 MLOAD 0558 62 PUSH3 0x461bcd 055C 60 PUSH1 0xe5 055E 1B SHL 055F 81 DUP2 0560 52 MSTORE 0561 60 PUSH1 0x20 0563 60 PUSH1 0x04 0565 82 DUP3 0566 01 ADD 0567 52 MSTORE 0568 60 PUSH1 0x08 056A 60 PUSH1 0x24 056C 82 DUP3 056D 01 ADD 056E 52 MSTORE 056F 67 PUSH8 0x13db9b1e48109bdd 0578 60 PUSH1 0xc2 057A 1B SHL 057B 60 PUSH1 0x44 057D 82 DUP3 057E 01 ADD 057F 52 MSTORE 0580 90 SWAP1 0581 51 MLOAD 0582 90 SWAP1 0583 81 DUP2 0584 90 SWAP1 0585 03 SUB 0586 60 PUSH1 0x64 0588 01 ADD 0589 90 SWAP1 058A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0560 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0567 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @056E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @057F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x13db9b1e48109bdd << 0xc2 // @058A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_058B: // Incoming jump from 0x0553, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @058C stack[-1] // @058D block.timestamp // } 058B 5B JUMPDEST 058C 80 DUP1 058D 42 TIMESTAMP 058E 81 DUP2 058F 10 LT 0590 15 ISZERO 0591 61 PUSH2 0x05c6 0594 57 *JUMPI // Stack delta = +1 // Outputs[1] { @058C stack[0] = stack[-1] } // Block ends with conditional jump to 0x05c6, if !(stack[-1] < block.timestamp) label_0595: // Incoming jump from 0x0594, if not !(stack[-1] < block.timestamp) // Inputs[3] // { // @0598 memory[0x40:0x60] // @05BC memory[0x40:0x60] // @05C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0595 60 PUSH1 0x40 0597 80 DUP1 0598 51 MLOAD 0599 62 PUSH3 0x461bcd 059D 60 PUSH1 0xe5 059F 1B SHL 05A0 81 DUP2 05A1 52 MSTORE 05A2 60 PUSH1 0x20 05A4 60 PUSH1 0x04 05A6 82 DUP3 05A7 01 ADD 05A8 52 MSTORE 05A9 60 PUSH1 0x02 05AB 60 PUSH1 0x24 05AD 82 DUP3 05AE 01 ADD 05AF 52 MSTORE 05B0 61 PUSH2 0x5445 05B3 60 PUSH1 0xf0 05B5 1B SHL 05B6 60 PUSH1 0x44 05B8 82 DUP3 05B9 01 ADD 05BA 52 MSTORE 05BB 90 SWAP1 05BC 51 MLOAD 05BD 90 SWAP1 05BE 81 DUP2 05BF 90 SWAP1 05C0 03 SUB 05C1 60 PUSH1 0x64 05C3 01 ADD 05C4 90 SWAP1 05C5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @05A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05A8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05AF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @05BA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5445 << 0xf0 // @05C5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_05C6: // Incoming jump from 0x0594, if !(stack[-1] < block.timestamp) // Inputs[10] // { // @05CA memory[0x40:0x60] // @05DE msg.data.length // @05E0 msg.data[msg.data.length:msg.data.length + 0x40] // @05E7 storage[0x00] // @05EB storage[0x02] // @0601 stack[-2] // @0602 stack[-3] // @0608 memory[0x40:0x60] // @0626 memory[0x40:0x60] // @062D address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length // } 05C6 5B JUMPDEST 05C7 60 PUSH1 0x40 05C9 80 DUP1 05CA 51 MLOAD 05CB 60 PUSH1 0x02 05CD 80 DUP1 05CE 82 DUP3 05CF 52 MSTORE 05D0 60 PUSH1 0x60 05D2 80 DUP1 05D3 83 DUP4 05D4 01 ADD 05D5 84 DUP5 05D6 52 MSTORE 05D7 92 SWAP3 05D8 60 PUSH1 0x20 05DA 83 DUP4 05DB 01 ADD 05DC 90 SWAP1 05DD 80 DUP1 05DE 36 CALLDATASIZE 05DF 83 DUP4 05E0 37 CALLDATACOPY 05E1 01 ADD 05E2 90 SWAP1 05E3 50 POP 05E4 50 POP 05E5 60 PUSH1 0x00 05E7 54 SLOAD 05E8 60 PUSH1 0x02 05EA 80 DUP1 05EB 54 SLOAD 05EC 92 SWAP3 05ED 93 SWAP4 05EE 50 POP 05EF 60 PUSH1 0x01 05F1 60 PUSH1 0x01 05F3 60 PUSH1 0xa0 05F5 1B SHL 05F6 03 SUB 05F7 90 SWAP1 05F8 91 SWAP2 05F9 16 AND 05FA 91 SWAP2 05FB 63 PUSH4 0x67ccdf38 0600 91 SWAP2 0601 86 DUP7 0602 88 DUP9 0603 03 SUB 0604 04 DIV 0605 03 SUB 0606 60 PUSH1 0x40 0608 51 MLOAD 0609 82 DUP3 060A 63 PUSH4 0xffffffff 060F 16 AND 0610 60 PUSH1 0xe0 0612 1B SHL 0613 81 DUP2 0614 52 MSTORE 0615 60 PUSH1 0x04 0617 01 ADD 0618 80 DUP1 0619 82 DUP3 061A 81 DUP2 061B 52 MSTORE 061C 60 PUSH1 0x20 061E 01 ADD 061F 91 SWAP2 0620 50 POP 0621 50 POP 0622 60 PUSH1 0x20 0624 60 PUSH1 0x40 0626 51 MLOAD 0627 80 DUP1 0628 83 DUP4 0629 03 SUB 062A 81 DUP2 062B 86 DUP7 062C 80 DUP1 062D 3B EXTCODESIZE 062E 15 ISZERO 062F 80 DUP1 0630 15 ISZERO 0631 61 PUSH2 0x0639 0634 57 *JUMPI // Stack delta = +10 // Outputs[15] // { // @05CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @05D6 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @05E0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x40] = msg.data[msg.data.length:msg.data.length + 0x40] // @05ED stack[0] = memory[0x40:0x60] // @05FA stack[1] = storage[0x00] & (0x01 << 0xa0) - 0x01 // @0600 stack[2] = 0x67ccdf38 // @0614 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x67ccdf38) << 0xe0 // @061B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-3] - stack[-2] / 0x02 - storage[0x02] // @061F stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @0622 stack[4] = 0x20 // @0626 stack[5] = memory[0x40:0x60] // @0629 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @062A stack[7] = memory[0x40:0x60] // @062B stack[8] = storage[0x00] & (0x01 << 0xa0) - 0x01 // @062E stack[9] = !address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0639, if !!address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length label_0635: // Incoming jump from 0x0634, if not !!address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0638 memory[0x00:0x00] } 0635 60 PUSH1 0x00 0637 80 DUP1 0638 FD *REVERT // Stack delta = +0 // Outputs[1] { @0638 revert(memory[0x00:0x00]); } // Block terminates label_0639: // Incoming jump from 0x0634, if !!address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @063B msg.gas // @063C stack[-5] // @063C stack[-3] // @063C memory[stack[-3]:stack[-3] + stack[-4]] // @063C address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @063C stack[-2] // @063C stack[-4] // @063C stack[-6] // } 0639 5B JUMPDEST 063A 50 POP 063B 5A GAS 063C FA STATICCALL 063D 15 ISZERO 063E 80 DUP1 063F 15 ISZERO 0640 61 PUSH2 0x064d 0643 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @063C memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @063D stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x064d, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0644: // Incoming jump from 0x0643, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0644 returndata.length // @0648 returndata[0x00:0x00 + returndata.length] // @0649 returndata.length // @064C memory[0x00:0x00 + returndata.length] // } 0644 3D RETURNDATASIZE 0645 60 PUSH1 0x00 0647 80 DUP1 0648 3E RETURNDATACOPY 0649 3D RETURNDATASIZE 064A 60 PUSH1 0x00 064C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0648 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @064C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_064D: // Incoming jump from 0x0643, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0654 memory[0x40:0x60] // @0655 returndata.length // } 064D 5B JUMPDEST 064E 50 POP 064F 50 POP 0650 50 POP 0651 50 POP 0652 60 PUSH1 0x40 0654 51 MLOAD 0655 3D RETURNDATASIZE 0656 60 PUSH1 0x20 0658 81 DUP2 0659 10 LT 065A 15 ISZERO 065B 61 PUSH2 0x0663 065E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0654 stack[-4] = memory[0x40:0x60] // @0655 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0663, if !(returndata.length < 0x20) label_065F: // Incoming jump from 0x065E, if not !(returndata.length < 0x20) // Inputs[1] { @0662 memory[0x00:0x00] } 065F 60 PUSH1 0x00 0661 80 DUP1 0662 FD *REVERT // Stack delta = +0 // Outputs[1] { @0662 revert(memory[0x00:0x00]); } // Block terminates label_0663: // Incoming jump from 0x065E, if !(returndata.length < 0x20) // Inputs[4] // { // @0665 stack[-2] // @0665 memory[stack[-2]:stack[-2] + 0x20] // @0666 stack[-3] // @0667 memory[stack[-3]:stack[-3] + 0x20] // } 0663 5B JUMPDEST 0664 50 POP 0665 51 MLOAD 0666 81 DUP2 0667 51 MLOAD 0668 82 DUP3 0669 90 SWAP1 066A 60 PUSH1 0x00 066C 90 SWAP1 066D 61 PUSH2 0x0672 0670 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0665 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @0669 stack[-1] = stack[-3] // @066C stack[0] = 0x00 // } // Block ends with conditional jump to 0x0672, if memory[stack[-3]:stack[-3] + 0x20] label_0671: // Incoming jump from 0x0670, if not memory[stack[-3]:stack[-3] + 0x20] 0671 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0671 assert(); } // Block terminates label_0672: // Incoming jump from 0x0670, if memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @0675 stack[-1] // @0679 stack[-2] // @067A stack[-3] // @06B4 stack[-4] // @06B8 memory[stack[-4]:stack[-4] + 0x20] // } 0672 5B JUMPDEST 0673 60 PUSH1 0x20 0675 02 MUL 0676 60 PUSH1 0x20 0678 01 ADD 0679 01 ADD 067A 90 SWAP1 067B 60 PUSH1 0x01 067D 60 PUSH1 0x01 067F 60 PUSH1 0xa0 0681 1B SHL 0682 03 SUB 0683 16 AND 0684 90 SWAP1 0685 81 DUP2 0686 60 PUSH1 0x01 0688 60 PUSH1 0x01 068A 60 PUSH1 0xa0 068C 1B SHL 068D 03 SUB 068E 16 AND 068F 81 DUP2 0690 52 MSTORE 0691 50 POP 0692 50 POP 0693 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 06B4 81 DUP2 06B5 60 PUSH1 0x01 06B7 81 DUP2 06B8 51 MLOAD 06B9 81 DUP2 06BA 10 LT 06BB 61 PUSH2 0x06c0 06BE 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0690 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-3] // @0693 stack[-3] = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @06B4 stack[-2] = stack[-4] // @06B5 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x06c0, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_06BF: // Incoming jump from 0x06BE, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 06BF FE *ASSERT // Stack delta = +0 // Outputs[1] { @06BF assert(); } // Block terminates label_06C0: // Incoming jump from 0x06BE, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @06C3 stack[-1] // @06C7 stack[-2] // @06C8 stack[-3] // @06E3 stack[-4] // @06E7 memory[stack[-4]:stack[-4] + 0x20] // } 06C0 5B JUMPDEST 06C1 60 PUSH1 0x20 06C3 02 MUL 06C4 60 PUSH1 0x20 06C6 01 ADD 06C7 01 ADD 06C8 90 SWAP1 06C9 60 PUSH1 0x01 06CB 60 PUSH1 0x01 06CD 60 PUSH1 0xa0 06CF 1B SHL 06D0 03 SUB 06D1 16 AND 06D2 90 SWAP1 06D3 81 DUP2 06D4 60 PUSH1 0x01 06D6 60 PUSH1 0x01 06D8 60 PUSH1 0xa0 06DA 1B SHL 06DB 03 SUB 06DC 16 AND 06DD 81 DUP2 06DE 52 MSTORE 06DF 50 POP 06E0 50 POP 06E1 60 PUSH1 0x00 06E3 81 DUP2 06E4 60 PUSH1 0x00 06E6 81 DUP2 06E7 51 MLOAD 06E8 81 DUP2 06E9 10 LT 06EA 61 PUSH2 0x06ef 06ED 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @06DE memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-3] // @06E1 stack[-3] = 0x00 // @06E3 stack[-2] = stack[-4] // @06E4 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x06ef, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_06EE: // Incoming jump from 0x06ED, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 06EE FE *ASSERT // Stack delta = +0 // Outputs[1] { @06EE assert(); } // Block terminates label_06EF: // Incoming jump from 0x06ED, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @06F2 stack[-1] // @06F6 stack[-2] // @06F7 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0706 address(this) // @0709 memory[0x40:0x60] // @0739 memory[0x40:0x60] // @0740 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 06EF 5B JUMPDEST 06F0 60 PUSH1 0x20 06F2 02 MUL 06F3 60 PUSH1 0x20 06F5 01 ADD 06F6 01 ADD 06F7 51 MLOAD 06F8 60 PUSH1 0x01 06FA 60 PUSH1 0x01 06FC 60 PUSH1 0xa0 06FE 1B SHL 06FF 03 SUB 0700 16 AND 0701 63 PUSH4 0x70a08231 0706 30 ADDRESS 0707 60 PUSH1 0x40 0709 51 MLOAD 070A 82 DUP3 070B 63 PUSH4 0xffffffff 0710 16 AND 0711 60 PUSH1 0xe0 0713 1B SHL 0714 81 DUP2 0715 52 MSTORE 0716 60 PUSH1 0x04 0718 01 ADD 0719 80 DUP1 071A 82 DUP3 071B 60 PUSH1 0x01 071D 60 PUSH1 0x01 071F 60 PUSH1 0xa0 0721 1B SHL 0722 03 SUB 0723 16 AND 0724 60 PUSH1 0x01 0726 60 PUSH1 0x01 0728 60 PUSH1 0xa0 072A 1B SHL 072B 03 SUB 072C 16 AND 072D 81 DUP2 072E 52 MSTORE 072F 60 PUSH1 0x20 0731 01 ADD 0732 91 SWAP2 0733 50 POP 0734 50 POP 0735 60 PUSH1 0x20 0737 60 PUSH1 0x40 0739 51 MLOAD 073A 80 DUP1 073B 83 DUP4 073C 03 SUB 073D 81 DUP2 073E 86 DUP7 073F 80 DUP1 0740 3B EXTCODESIZE 0741 15 ISZERO 0742 80 DUP1 0743 15 ISZERO 0744 61 PUSH2 0x074c 0747 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @0700 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0701 stack[-1] = 0x70a08231 // @0715 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @072E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & address(this) // @0732 stack[0] = 0x20 + 0x04 + memory[0x40:0x60] // @0735 stack[1] = 0x20 // @0739 stack[2] = memory[0x40:0x60] // @073C stack[3] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @073D stack[4] = memory[0x40:0x60] // @073E stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0741 stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x074c, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_0748: // Incoming jump from 0x0747, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @074B memory[0x00:0x00] } 0748 60 PUSH1 0x00 074A 80 DUP1 074B FD *REVERT // Stack delta = +0 // Outputs[1] { @074B revert(memory[0x00:0x00]); } // Block terminates label_074C: // Incoming jump from 0x0747, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @074E msg.gas // @074F stack[-6] // @074F stack[-3] // @074F stack[-4] // @074F memory[stack[-3]:stack[-3] + stack[-4]] // @074F stack[-5] // @074F address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @074F stack[-2] // } 074C 5B JUMPDEST 074D 50 POP 074E 5A GAS 074F FA STATICCALL 0750 15 ISZERO 0751 80 DUP1 0752 15 ISZERO 0753 61 PUSH2 0x0760 0756 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @074F memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0750 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0760, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0757: // Incoming jump from 0x0756, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0757 returndata.length // @075B returndata[0x00:0x00 + returndata.length] // @075C returndata.length // @075F memory[0x00:0x00 + returndata.length] // } 0757 3D RETURNDATASIZE 0758 60 PUSH1 0x00 075A 80 DUP1 075B 3E RETURNDATACOPY 075C 3D RETURNDATASIZE 075D 60 PUSH1 0x00 075F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @075B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @075F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0760: // Incoming jump from 0x0756, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0767 memory[0x40:0x60] // @0768 returndata.length // } 0760 5B JUMPDEST 0761 50 POP 0762 50 POP 0763 50 POP 0764 50 POP 0765 60 PUSH1 0x40 0767 51 MLOAD 0768 3D RETURNDATASIZE 0769 60 PUSH1 0x20 076B 81 DUP2 076C 10 LT 076D 15 ISZERO 076E 61 PUSH2 0x0776 0771 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0767 stack[-4] = memory[0x40:0x60] // @0768 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0776, if !(returndata.length < 0x20) label_0772: // Incoming jump from 0x0771, if not !(returndata.length < 0x20) // Inputs[1] { @0775 memory[0x00:0x00] } 0772 60 PUSH1 0x00 0774 80 DUP1 0775 FD *REVERT // Stack delta = +0 // Outputs[1] { @0775 revert(memory[0x00:0x00]); } // Block terminates label_0776: // Incoming jump from 0x0771, if !(returndata.length < 0x20) // Inputs[3] // { // @0778 stack[-2] // @0778 memory[stack[-2]:stack[-2] + 0x20] // @0779 stack[-3] // } 0776 5B JUMPDEST 0777 50 POP 0778 51 MLOAD 0779 90 SWAP1 077A 50 POP 077B 80 DUP1 077C 61 PUSH2 0x07b1 077F 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0779 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x07b1, if memory[stack[-2]:stack[-2] + 0x20] label_0780: // Incoming jump from 0x077F, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @0783 memory[0x40:0x60] // @07A7 memory[0x40:0x60] // @07B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0780 60 PUSH1 0x40 0782 80 DUP1 0783 51 MLOAD 0784 62 PUSH3 0x461bcd 0788 60 PUSH1 0xe5 078A 1B SHL 078B 81 DUP2 078C 52 MSTORE 078D 60 PUSH1 0x20 078F 60 PUSH1 0x04 0791 82 DUP3 0792 01 ADD 0793 52 MSTORE 0794 60 PUSH1 0x02 0796 60 PUSH1 0x24 0798 82 DUP3 0799 01 ADD 079A 52 MSTORE 079B 61 PUSH2 0x1395 079E 60 PUSH1 0xf2 07A0 1B SHL 07A1 60 PUSH1 0x44 07A3 82 DUP3 07A4 01 ADD 07A5 52 MSTORE 07A6 90 SWAP1 07A7 51 MLOAD 07A8 90 SWAP1 07A9 81 DUP2 07AA 90 SWAP1 07AB 03 SUB 07AC 60 PUSH1 0x64 07AE 01 ADD 07AF 90 SWAP1 07B0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @078C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0793 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @079A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @07A5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1395 << 0xf2 // @07B0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_07B1: // Incoming jump from 0x077F, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @07D8 stack[-2] // @07DC memory[stack[-2]:stack[-2] + 0x20] // } 07B1 5B JUMPDEST 07B2 60 PUSH1 0x00 07B4 61 PUSH2 0x0806 07B7 7F PUSH32 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f 07D8 84 DUP5 07D9 60 PUSH1 0x00 07DB 81 DUP2 07DC 51 MLOAD 07DD 81 DUP2 07DE 10 LT 07DF 61 PUSH2 0x07e4 07E2 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @07B2 stack[0] = 0x00 // @07B4 stack[1] = 0x0806 // @07B7 stack[2] = 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f // @07D8 stack[3] = stack[-2] // @07D9 stack[4] = 0x00 // } // Block ends with conditional call to 0x07e4, returns to 0x0806, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_07E3: // Incoming jump from 0x07E2, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 07E3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @07E3 assert(); } // Block terminates label_07E4: // Incoming call from 0x07E2, returns to 0x0806, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming call from 0x1153, returns to 0x1155, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @07E7 stack[-1] // @07EB stack[-2] // @07EC memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @07ED stack[-7] // @07F1 memory[stack[-7]:stack[-7] + 0x20] // } 07E4 5B JUMPDEST 07E5 60 PUSH1 0x20 07E7 02 MUL 07E8 60 PUSH1 0x20 07EA 01 ADD 07EB 01 ADD 07EC 51 MLOAD 07ED 85 DUP6 07EE 60 PUSH1 0x01 07F0 81 DUP2 07F1 51 MLOAD 07F2 81 DUP2 07F3 10 LT 07F4 61 PUSH2 0x07f9 07F7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @07EC stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @07ED stack[-1] = stack[-7] // @07EE stack[0] = 0x01 // } // Block ends with conditional jump to 0x07f9, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] label_07F8: // Incoming jump from 0x07F7, if not 0x01 < memory[stack[-7]:stack[-7] + 0x20] 07F8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @07F8 assert(); } // Block terminates label_07F9: // Incoming jump from 0x0DD9, if 0x01 < memory[stack[-8]:stack[-8] + 0x20] // Incoming jump from 0x07F7, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] // Incoming jump from 0x15A3, if 0x01 < memory[stack[-6]:stack[-6] + 0x20] // Inputs[3] // { // @07FC stack[-1] // @0800 stack[-2] // @0801 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 07F9 5B JUMPDEST 07FA 60 PUSH1 0x20 07FC 02 MUL 07FD 60 PUSH1 0x20 07FF 01 ADD 0800 01 ADD 0801 51 MLOAD 0802 61 PUSH2 0x17f4 0805 56 *JUMP // Stack delta = -1 // Outputs[1] { @0801 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x17f4 label_0806: // Incoming return from call to 0x07E4 at 0x07E2 // Inputs[4] // { // @0807 stack[-2] // @0807 stack[-1] // @080D stack[-4] // @0811 memory[stack[-4]:stack[-4] + 0x20] // } 0806 5B JUMPDEST 0807 90 SWAP1 0808 50 POP 0809 60 PUSH1 0x05 080B 60 PUSH1 0x00 080D 84 DUP5 080E 60 PUSH1 0x00 0810 81 DUP2 0811 51 MLOAD 0812 81 DUP2 0813 10 LT 0814 61 PUSH2 0x0819 0817 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0807 stack[-2] = stack[-1] // @0809 stack[-1] = 0x05 // @080B stack[0] = 0x00 // @080D stack[1] = stack[-4] // @080E stack[2] = 0x00 // } // Block ends with conditional jump to 0x0819, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_0818: // Incoming jump from 0x0817, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 0818 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0818 assert(); } // Block terminates label_0819: // Incoming jump from 0x0817, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @081C stack[-1] // @081F stack[-2] // @0825 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @082F stack[-3] // @0833 stack[-4] // @083C memory[0x00:0x00 + 0x40 + stack[-3]] // @083D storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // } 0819 5B JUMPDEST 081A 60 PUSH1 0x20 081C 90 SWAP1 081D 81 DUP2 081E 02 MUL 081F 91 SWAP2 0820 90 SWAP1 0821 91 SWAP2 0822 01 ADD 0823 81 DUP2 0824 01 ADD 0825 51 MLOAD 0826 60 PUSH1 0x01 0828 60 PUSH1 0x01 082A 60 PUSH1 0xa0 082C 1B SHL 082D 03 SUB 082E 16 AND 082F 82 DUP3 0830 52 MSTORE 0831 81 DUP2 0832 01 ADD 0833 91 SWAP2 0834 90 SWAP1 0835 91 SWAP2 0836 52 MSTORE 0837 60 PUSH1 0x40 0839 01 ADD 083A 60 PUSH1 0x00 083C 20 SHA3 083D 54 SLOAD 083E 60 PUSH1 0xff 0840 16 AND 0841 61 PUSH2 0x08b8 0844 57 *JUMPI // Stack delta = -4 // Outputs[2] // { // @0830 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0836 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x08b8, if 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] label_0845: // Incoming jump from 0x0844, if not 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // Inputs[2] // { // @0848 stack[-3] // @084C memory[stack[-3]:stack[-3] + 0x20] // } 0845 61 PUSH2 0x0865 0848 83 DUP4 0849 60 PUSH1 0x00 084B 81 DUP2 084C 51 MLOAD 084D 81 DUP2 084E 10 LT 084F 61 PUSH2 0x0854 0852 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0845 stack[0] = 0x0865 // @0848 stack[1] = stack[-3] // @0849 stack[2] = 0x00 // } // Block ends with conditional call to 0x0854, returns to 0x0865, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_0853: // Incoming jump from 0x0852, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 0853 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0853 assert(); } // Block terminates label_0854: // Incoming call from 0x0E27, returns to 0x0E29, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Incoming call from 0x11FE, returns to 0x1200, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Incoming call from 0x0852, returns to 0x0865, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0857 stack[-1] // @085B stack[-2] // @085C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @085D address(this) // } 0854 5B JUMPDEST 0855 60 PUSH1 0x20 0857 02 MUL 0858 60 PUSH1 0x20 085A 01 ADD 085B 01 ADD 085C 51 MLOAD 085D 30 ADDRESS 085E 60 PUSH1 0x00 0860 19 NOT 0861 61 PUSH2 0x18b4 0864 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @085C stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @085D stack[-1] = address(this) // @0860 stack[0] = ~0x00 // } // Block ends with unconditional jump to 0x18b4 label_0865: // Incoming return from call to 0x0854 at 0x0852 // Inputs[2] // { // @086C stack[-3] // @0870 memory[stack[-3]:stack[-3] + 0x20] // } 0865 5B JUMPDEST 0866 60 PUSH1 0x01 0868 60 PUSH1 0x05 086A 60 PUSH1 0x00 086C 85 DUP6 086D 60 PUSH1 0x00 086F 81 DUP2 0870 51 MLOAD 0871 81 DUP2 0872 10 LT 0873 61 PUSH2 0x0878 0876 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0866 stack[0] = 0x01 // @0868 stack[1] = 0x05 // @086A stack[2] = 0x00 // @086C stack[3] = stack[-3] // @086D stack[4] = 0x00 // } // Block ends with conditional jump to 0x0878, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_0877: // Incoming jump from 0x0876, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 0877 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0877 assert(); } // Block terminates label_0878: // Incoming jump from 0x0876, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[8] // { // @087B stack[-1] // @087F stack[-2] // @0880 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0893 stack[-3] // @0898 stack[-4] // @08A0 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @08A8 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @08B0 stack[-5] // } 0878 5B JUMPDEST 0879 60 PUSH1 0x20 087B 02 MUL 087C 60 PUSH1 0x20 087E 01 ADD 087F 01 ADD 0880 51 MLOAD 0881 60 PUSH1 0x01 0883 60 PUSH1 0x01 0885 60 PUSH1 0xa0 0887 1B SHL 0888 03 SUB 0889 16 AND 088A 60 PUSH1 0x01 088C 60 PUSH1 0x01 088E 60 PUSH1 0xa0 0890 1B SHL 0891 03 SUB 0892 16 AND 0893 81 DUP2 0894 52 MSTORE 0895 60 PUSH1 0x20 0897 01 ADD 0898 90 SWAP1 0899 81 DUP2 089A 52 MSTORE 089B 60 PUSH1 0x20 089D 01 ADD 089E 60 PUSH1 0x00 08A0 20 SHA3 08A1 60 PUSH1 0x00 08A3 61 PUSH2 0x0100 08A6 0A EXP 08A7 81 DUP2 08A8 54 SLOAD 08A9 81 DUP2 08AA 60 PUSH1 0xff 08AC 02 MUL 08AD 19 NOT 08AE 16 AND 08AF 90 SWAP1 08B0 83 DUP4 08B1 15 ISZERO 08B2 15 ISZERO 08B3 02 MUL 08B4 17 OR 08B5 90 SWAP1 08B6 55 SSTORE 08B7 50 POP // Stack delta = -5 // Outputs[3] // { // @0894 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @089A memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @08B6 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // } // Block continues label_08B8: // Incoming jump from 0x08B7 // Incoming jump from 0x0844, if 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // Inputs[2] // { // @08BC stack[-3] // @08C0 memory[stack[-3]:stack[-3] + 0x20] // } 08B8 5B JUMPDEST 08B9 61 PUSH2 0x08d8 08BC 83 DUP4 08BD 60 PUSH1 0x00 08BF 81 DUP2 08C0 51 MLOAD 08C1 81 DUP2 08C2 10 LT 08C3 61 PUSH2 0x08c8 08C6 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @08B9 stack[0] = 0x08d8 // @08BC stack[1] = stack[-3] // @08BD stack[2] = 0x00 // } // Block ends with conditional call to 0x08c8, returns to 0x08D8, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_08C7: // Incoming jump from 0x08C6, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 08C7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @08C7 assert(); } // Block terminates label_08C8: // Incoming call from 0x08C6, returns to 0x08D8, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Incoming call from 0x0E8A, returns to 0x0E8C, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[6] // { // @08CB stack[-1] // @08CF stack[-2] // @08D0 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @08D1 address(this) // @08D2 stack[-4] // @08D3 stack[-5] // } 08C8 5B JUMPDEST 08C9 60 PUSH1 0x20 08CB 02 MUL 08CC 60 PUSH1 0x20 08CE 01 ADD 08CF 01 ADD 08D0 51 MLOAD 08D1 30 ADDRESS 08D2 83 DUP4 08D3 85 DUP6 08D4 61 PUSH2 0x1a17 08D7 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @08D0 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @08D1 stack[-1] = address(this) // @08D2 stack[0] = stack[-4] // @08D3 stack[1] = stack[-5] // } // Block ends with unconditional jump to 0x1a17 label_08D8: // Incoming return from call to 0x08C8 at 0x08C6 // Inputs[3] // { // @08DC stack[-3] // @08DD address(this) // @08DE stack[-1] // } 08D8 5B JUMPDEST 08D9 61 PUSH2 0x08e3 08DC 83 DUP4 08DD 30 ADDRESS 08DE 83 DUP4 08DF 61 PUSH2 0x1b6c 08E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08D9 stack[0] = 0x08e3 // @08DC stack[1] = stack[-3] // @08DD stack[2] = address(this) // @08DE stack[3] = stack[-1] // } // Block ends with call to 0x1b6c, returns to 0x08E3 label_08E3: // Incoming return from call to 0x1B6C at 0x08E2 // Incoming jump from 0x1B35, if stack[-1] // Incoming jump from 0x0A80, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @08EA stack[-7] } 08E3 5B JUMPDEST 08E4 50 POP 08E5 50 POP 08E6 50 POP 08E7 50 POP 08E8 50 POP 08E9 50 POP 08EA 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_08EB: // Incoming call from 0x0186, returns to 0x0187 // Inputs[2] // { // @08EE storage[0x02] // @08EF stack[-1] // } 08EB 5B JUMPDEST 08EC 60 PUSH1 0x02 08EE 54 SLOAD 08EF 81 DUP2 08F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @08EE stack[0] = storage[0x02] } // Block ends with unconditional jump to stack[-1] label_08F1: // Incoming call from 0x01AD, returns to 0x0187 // Inputs[2] // { // @08F4 storage[0x01] // @08F5 stack[-1] // } 08F1 5B JUMPDEST 08F2 60 PUSH1 0x01 08F4 54 SLOAD 08F5 81 DUP2 08F6 56 *JUMP // Stack delta = +1 // Outputs[1] { @08F4 stack[0] = storage[0x01] } // Block ends with unconditional jump to stack[-1] label_08F7: // Incoming call from 0x01B5, returns to 0x013B // Inputs[2] // { // @08FA storage[0x03] // @0904 msg.sender // } 08F7 5B JUMPDEST 08F8 60 PUSH1 0x03 08FA 54 SLOAD 08FB 60 PUSH1 0x01 08FD 60 PUSH1 0x01 08FF 60 PUSH1 0xa0 0901 1B SHL 0902 03 SUB 0903 16 AND 0904 33 CALLER 0905 14 EQ 0906 61 PUSH2 0x0940 0909 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0940, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_090A: // Incoming jump from 0x0909, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @090D memory[0x40:0x60] // @0936 memory[0x40:0x60] // @093F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 090A 60 PUSH1 0x40 090C 80 DUP1 090D 51 MLOAD 090E 62 PUSH3 0x461bcd 0912 60 PUSH1 0xe5 0914 1B SHL 0915 81 DUP2 0916 52 MSTORE 0917 60 PUSH1 0x20 0919 60 PUSH1 0x04 091B 82 DUP3 091C 01 ADD 091D 52 MSTORE 091E 60 PUSH1 0x07 0920 60 PUSH1 0x24 0922 82 DUP3 0923 01 ADD 0924 52 MSTORE 0925 66 PUSH7 0x4f6e6c79204d65 092D 60 PUSH1 0xc8 092F 1B SHL 0930 60 PUSH1 0x44 0932 82 DUP3 0933 01 ADD 0934 52 MSTORE 0935 90 SWAP1 0936 51 MLOAD 0937 90 SWAP1 0938 81 DUP2 0939 90 SWAP1 093A 03 SUB 093B 60 PUSH1 0x64 093D 01 ADD 093E 90 SWAP1 093F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0916 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @091D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0924 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @0934 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79204d65 << 0xc8 // @093F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0940: // Incoming jump from 0x0909, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @0943 storage[0x03] // @0951 address(this).balance // @0951 address(this) // } 0940 5B JUMPDEST 0941 60 PUSH1 0x03 0943 54 SLOAD 0944 61 PUSH2 0x0956 0947 90 SWAP1 0948 60 PUSH1 0x01 094A 60 PUSH1 0x01 094C 60 PUSH1 0xa0 094E 1B SHL 094F 03 SUB 0950 16 AND 0951 47 SELFBALANCE 0952 61 PUSH2 0x1e37 0955 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0947 stack[0] = 0x0956 // @0950 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @0951 stack[2] = address(this).balance // } // Block ends with call to 0x1e37, returns to 0x0956 label_0956: // Incoming return from call to 0x1E37 at 0x0955 // Inputs[1] { @0957 stack[-1] } 0956 5B JUMPDEST 0957 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0958: // Incoming jump from 0x01EE // Inputs[2] // { // @095B storage[0x03] // @0965 msg.sender // } 0958 5B JUMPDEST 0959 60 PUSH1 0x03 095B 54 SLOAD 095C 60 PUSH1 0x01 095E 60 PUSH1 0x01 0960 60 PUSH1 0xa0 0962 1B SHL 0963 03 SUB 0964 16 AND 0965 33 CALLER 0966 14 EQ 0967 61 PUSH2 0x09a1 096A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09a1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_096B: // Incoming jump from 0x096A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @096E memory[0x40:0x60] // @0997 memory[0x40:0x60] // @09A0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 096B 60 PUSH1 0x40 096D 80 DUP1 096E 51 MLOAD 096F 62 PUSH3 0x461bcd 0973 60 PUSH1 0xe5 0975 1B SHL 0976 81 DUP2 0977 52 MSTORE 0978 60 PUSH1 0x20 097A 60 PUSH1 0x04 097C 82 DUP3 097D 01 ADD 097E 52 MSTORE 097F 60 PUSH1 0x07 0981 60 PUSH1 0x24 0983 82 DUP3 0984 01 ADD 0985 52 MSTORE 0986 66 PUSH7 0x4f6e6c79204d65 098E 60 PUSH1 0xc8 0990 1B SHL 0991 60 PUSH1 0x44 0993 82 DUP3 0994 01 ADD 0995 52 MSTORE 0996 90 SWAP1 0997 51 MLOAD 0998 90 SWAP1 0999 81 DUP2 099A 90 SWAP1 099B 03 SUB 099C 60 PUSH1 0x64 099E 01 ADD 099F 90 SWAP1 09A0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0977 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @097E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0985 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @0995 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79204d65 << 0xc8 // @09A0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_09A1: // Incoming jump from 0x096A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @09A4 storage[0x03] // @09A9 stack[-2] // @09B4 stack[-1] // } 09A1 5B JUMPDEST 09A2 60 PUSH1 0x03 09A4 54 SLOAD 09A5 61 PUSH2 0x09b9 09A8 90 SWAP1 09A9 83 DUP4 09AA 90 SWAP1 09AB 60 PUSH1 0x01 09AD 60 PUSH1 0x01 09AF 60 PUSH1 0xa0 09B1 1B SHL 09B2 03 SUB 09B3 16 AND 09B4 83 DUP4 09B5 61 PUSH2 0x1f2a 09B8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09A8 stack[0] = 0x09b9 // @09AA stack[1] = stack[-2] // @09B3 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x03] // @09B4 stack[3] = stack[-1] // } // Block ends with call to 0x1f2a, returns to 0x09B9 label_09B9: // Incoming return from call to 0x1F2A at 0x09B8 // Inputs[1] { @09BC stack[-3] } 09B9 5B JUMPDEST 09BA 50 POP 09BB 50 POP 09BC 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_09BD: // Incoming jump from 0x0221 // Inputs[4] // { // @09C5 stack[-1] // @09CB memory[0x00:0x40] // @09CC storage[keccak256(memory[0x00:0x40])] // @09D0 stack[-2] // } 09BD 5B JUMPDEST 09BE 60 PUSH1 0x04 09C0 60 PUSH1 0x20 09C2 52 MSTORE 09C3 60 PUSH1 0x00 09C5 90 SWAP1 09C6 81 DUP2 09C7 52 MSTORE 09C8 60 PUSH1 0x40 09CA 90 SWAP1 09CB 20 SHA3 09CC 54 SLOAD 09CD 60 PUSH1 0xff 09CF 16 AND 09D0 81 DUP2 09D1 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09C2 memory[0x20:0x40] = 0x04 // @09C7 memory[0x00:0x20] = stack[-1] // @09CF stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_09D2: // Incoming jump from 0x025F // Inputs[2] // { // @09D5 storage[0x03] // @09DF msg.sender // } 09D2 5B JUMPDEST 09D3 60 PUSH1 0x03 09D5 54 SLOAD 09D6 60 PUSH1 0x01 09D8 60 PUSH1 0x01 09DA 60 PUSH1 0xa0 09DC 1B SHL 09DD 03 SUB 09DE 16 AND 09DF 33 CALLER 09E0 14 EQ 09E1 61 PUSH2 0x0a1b 09E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a1b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_09E5: // Incoming jump from 0x09E4, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @09E8 memory[0x40:0x60] // @0A11 memory[0x40:0x60] // @0A1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 09E5 60 PUSH1 0x40 09E7 80 DUP1 09E8 51 MLOAD 09E9 62 PUSH3 0x461bcd 09ED 60 PUSH1 0xe5 09EF 1B SHL 09F0 81 DUP2 09F1 52 MSTORE 09F2 60 PUSH1 0x20 09F4 60 PUSH1 0x04 09F6 82 DUP3 09F7 01 ADD 09F8 52 MSTORE 09F9 60 PUSH1 0x07 09FB 60 PUSH1 0x24 09FD 82 DUP3 09FE 01 ADD 09FF 52 MSTORE 0A00 66 PUSH7 0x4f6e6c79204d65 0A08 60 PUSH1 0xc8 0A0A 1B SHL 0A0B 60 PUSH1 0x44 0A0D 82 DUP3 0A0E 01 ADD 0A0F 52 MSTORE 0A10 90 SWAP1 0A11 51 MLOAD 0A12 90 SWAP1 0A13 81 DUP2 0A14 90 SWAP1 0A15 03 SUB 0A16 60 PUSH1 0x64 0A18 01 ADD 0A19 90 SWAP1 0A1A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @09F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09F8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09FF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @0A0F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79204d65 << 0xc8 // @0A1A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0A1B: // Incoming jump from 0x09E4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[4] // { // @0A4B stack[-1] // @0A4E memory[0x40:0x60] // @0A62 memory[0x40:0x60] // @0A6A address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 0A1B 5B JUMPDEST 0A1C 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0A3D 60 PUSH1 0x01 0A3F 60 PUSH1 0x01 0A41 60 PUSH1 0xa0 0A43 1B SHL 0A44 03 SUB 0A45 16 AND 0A46 63 PUSH4 0xd0e30db0 0A4B 82 DUP3 0A4C 60 PUSH1 0x40 0A4E 51 MLOAD 0A4F 82 DUP3 0A50 63 PUSH4 0xffffffff 0A55 16 AND 0A56 60 PUSH1 0xe0 0A58 1B SHL 0A59 81 DUP2 0A5A 52 MSTORE 0A5B 60 PUSH1 0x04 0A5D 01 ADD 0A5E 60 PUSH1 0x00 0A60 60 PUSH1 0x40 0A62 51 MLOAD 0A63 80 DUP1 0A64 83 DUP4 0A65 03 SUB 0A66 81 DUP2 0A67 85 DUP6 0A68 88 DUP9 0A69 80 DUP1 0A6A 3B EXTCODESIZE 0A6B 15 ISZERO 0A6C 80 DUP1 0A6D 15 ISZERO 0A6E 61 PUSH2 0x0a76 0A71 57 *JUMPI // Stack delta = +11 // Outputs[12] // { // @0A45 stack[0] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0A46 stack[1] = 0xd0e30db0 // @0A4B stack[2] = stack[-1] // @0A5A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xd0e30db0) << 0xe0 // @0A5D stack[3] = 0x04 + memory[0x40:0x60] // @0A5E stack[4] = 0x00 // @0A62 stack[5] = memory[0x40:0x60] // @0A65 stack[6] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0A66 stack[7] = memory[0x40:0x60] // @0A67 stack[8] = stack[-1] // @0A68 stack[9] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0A6B stack[10] = !address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x0a76, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_0A72: // Incoming jump from 0x0A71, if not !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @0A75 memory[0x00:0x00] } 0A72 60 PUSH1 0x00 0A74 80 DUP1 0A75 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A75 revert(memory[0x00:0x00]); } // Block terminates label_0A76: // Incoming jump from 0x0A71, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @0A78 msg.gas // @0A79 stack[-5] // @0A79 stack[-3] // @0A79 memory[stack[-4]:stack[-4] + stack[-5]] // @0A79 stack[-2] // @0A79 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0A79 stack[-4] // @0A79 stack[-7] // @0A79 stack[-6] // } 0A76 5B JUMPDEST 0A77 50 POP 0A78 5A GAS 0A79 F1 CALL 0A7A 15 ISZERO 0A7B 80 DUP1 0A7C 15 ISZERO 0A7D 61 PUSH2 0x08e3 0A80 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0A79 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0A7A 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 0x08e3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0A81: // Incoming jump from 0x0A80, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0A81 returndata.length // @0A85 returndata[0x00:0x00 + returndata.length] // @0A86 returndata.length // @0A89 memory[0x00:0x00 + returndata.length] // } 0A81 3D RETURNDATASIZE 0A82 60 PUSH1 0x00 0A84 80 DUP1 0A85 3E RETURNDATACOPY 0A86 3D RETURNDATASIZE 0A87 60 PUSH1 0x00 0A89 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A85 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A89 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A8A: // Incoming jump from 0x0292 // Inputs[2] // { // @0A8D storage[0x03] // @0A97 msg.sender // } 0A8A 5B JUMPDEST 0A8B 60 PUSH1 0x03 0A8D 54 SLOAD 0A8E 60 PUSH1 0x01 0A90 60 PUSH1 0x01 0A92 60 PUSH1 0xa0 0A94 1B SHL 0A95 03 SUB 0A96 16 AND 0A97 33 CALLER 0A98 14 EQ 0A99 61 PUSH2 0x0ad3 0A9C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ad3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0A9D: // Incoming jump from 0x0A9C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @0AA0 memory[0x40:0x60] // @0AC9 memory[0x40:0x60] // @0AD2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0A9D 60 PUSH1 0x40 0A9F 80 DUP1 0AA0 51 MLOAD 0AA1 62 PUSH3 0x461bcd 0AA5 60 PUSH1 0xe5 0AA7 1B SHL 0AA8 81 DUP2 0AA9 52 MSTORE 0AAA 60 PUSH1 0x20 0AAC 60 PUSH1 0x04 0AAE 82 DUP3 0AAF 01 ADD 0AB0 52 MSTORE 0AB1 60 PUSH1 0x07 0AB3 60 PUSH1 0x24 0AB5 82 DUP3 0AB6 01 ADD 0AB7 52 MSTORE 0AB8 66 PUSH7 0x4f6e6c79204d65 0AC0 60 PUSH1 0xc8 0AC2 1B SHL 0AC3 60 PUSH1 0x44 0AC5 82 DUP3 0AC6 01 ADD 0AC7 52 MSTORE 0AC8 90 SWAP1 0AC9 51 MLOAD 0ACA 90 SWAP1 0ACB 81 DUP2 0ACC 90 SWAP1 0ACD 03 SUB 0ACE 60 PUSH1 0x64 0AD0 01 ADD 0AD1 90 SWAP1 0AD2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0AA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AB0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AB7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @0AC7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79204d65 << 0xc8 // @0AD2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0AD3: // Incoming jump from 0x0A9C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @0AD7 storage[0x00] // @0AEA stack[-1] // @0AF4 stack[-2] // } 0AD3 5B JUMPDEST 0AD4 60 PUSH1 0x00 0AD6 80 DUP1 0AD7 54 SLOAD 0AD8 60 PUSH1 0x01 0ADA 60 PUSH1 0x01 0ADC 60 PUSH1 0xa0 0ADE 1B SHL 0ADF 03 SUB 0AE0 19 NOT 0AE1 16 AND 0AE2 60 PUSH1 0x01 0AE4 60 PUSH1 0x01 0AE6 60 PUSH1 0xa0 0AE8 1B SHL 0AE9 03 SUB 0AEA 92 SWAP3 0AEB 90 SWAP1 0AEC 92 SWAP3 0AED 16 AND 0AEE 91 SWAP2 0AEF 90 SWAP1 0AF0 91 SWAP2 0AF1 17 OR 0AF2 90 SWAP1 0AF3 55 SSTORE 0AF4 56 *JUMP // Stack delta = -2 // Outputs[1] { @0AF3 storage[0x00] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x00]) } // Block ends with unconditional jump to stack[-2] label_0AF5: // Incoming jump from 0x02C5 // Inputs[4] // { // @0AFD stack[-1] // @0B03 memory[0x00:0x40] // @0B04 storage[keccak256(memory[0x00:0x40])] // @0B08 stack[-2] // } 0AF5 5B JUMPDEST 0AF6 60 PUSH1 0x05 0AF8 60 PUSH1 0x20 0AFA 52 MSTORE 0AFB 60 PUSH1 0x00 0AFD 90 SWAP1 0AFE 81 DUP2 0AFF 52 MSTORE 0B00 60 PUSH1 0x40 0B02 90 SWAP1 0B03 20 SHA3 0B04 54 SLOAD 0B05 60 PUSH1 0xff 0B07 16 AND 0B08 81 DUP2 0B09 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AFA memory[0x20:0x40] = 0x05 // @0AFF memory[0x00:0x20] = stack[-1] // @0B07 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0B0A: // Incoming call from 0x02DA, returns to 0x02DB // Inputs[2] // { // @0B0D storage[0x03] // @0B17 stack[-1] // } 0B0A 5B JUMPDEST 0B0B 60 PUSH1 0x03 0B0D 54 SLOAD 0B0E 60 PUSH1 0x01 0B10 60 PUSH1 0x01 0B12 60 PUSH1 0xa0 0B14 1B SHL 0B15 03 SUB 0B16 16 AND 0B17 81 DUP2 0B18 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B16 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x03] } // Block ends with unconditional jump to stack[-1] label_0B19: // Incoming call from 0x030B, returns to 0x02DB // Inputs[2] // { // @0B1C storage[0x00] // @0B26 stack[-1] // } 0B19 5B JUMPDEST 0B1A 60 PUSH1 0x00 0B1C 54 SLOAD 0B1D 60 PUSH1 0x01 0B1F 60 PUSH1 0x01 0B21 60 PUSH1 0xa0 0B23 1B SHL 0B24 03 SUB 0B25 16 AND 0B26 81 DUP2 0B27 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B25 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to stack[-1] label_0B28: // Incoming jump from 0x0388 // Inputs[3] // { // @0B29 msg.sender // @0B37 memory[0x00:0x40] // @0B38 storage[keccak256(memory[0x00:0x40])] // } 0B28 5B JUMPDEST 0B29 33 CALLER 0B2A 60 PUSH1 0x00 0B2C 90 SWAP1 0B2D 81 DUP2 0B2E 52 MSTORE 0B2F 60 PUSH1 0x04 0B31 60 PUSH1 0x20 0B33 52 MSTORE 0B34 60 PUSH1 0x40 0B36 90 SWAP1 0B37 20 SHA3 0B38 54 SLOAD 0B39 60 PUSH1 0xff 0B3B 16 AND 0B3C 15 ISZERO 0B3D 15 ISZERO 0B3E 60 PUSH1 0x01 0B40 14 EQ 0B41 61 PUSH2 0x0b7c 0B44 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0B2E memory[0x00:0x20] = msg.sender // @0B33 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0b7c, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) label_0B45: // Incoming jump from 0x0B44, if not 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0B48 memory[0x40:0x60] // @0B72 memory[0x40:0x60] // @0B7B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0B45 60 PUSH1 0x40 0B47 80 DUP1 0B48 51 MLOAD 0B49 62 PUSH3 0x461bcd 0B4D 60 PUSH1 0xe5 0B4F 1B SHL 0B50 81 DUP2 0B51 52 MSTORE 0B52 60 PUSH1 0x20 0B54 60 PUSH1 0x04 0B56 82 DUP3 0B57 01 ADD 0B58 52 MSTORE 0B59 60 PUSH1 0x08 0B5B 60 PUSH1 0x24 0B5D 82 DUP3 0B5E 01 ADD 0B5F 52 MSTORE 0B60 67 PUSH8 0x13db9b1e48109bdd 0B69 60 PUSH1 0xc2 0B6B 1B SHL 0B6C 60 PUSH1 0x44 0B6E 82 DUP3 0B6F 01 ADD 0B70 52 MSTORE 0B71 90 SWAP1 0B72 51 MLOAD 0B73 90 SWAP1 0B74 81 DUP2 0B75 90 SWAP1 0B76 03 SUB 0B77 60 PUSH1 0x64 0B79 01 ADD 0B7A 90 SWAP1 0B7B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B51 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B58 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B5F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @0B70 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x13db9b1e48109bdd << 0xc2 // @0B7B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0B7C: // Incoming jump from 0x0B44, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @0B80 memory[0x40:0x60] // @0B94 msg.data.length // @0B96 msg.data[msg.data.length:msg.data.length + 0x40] // @0BC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0B7C 5B JUMPDEST 0B7D 60 PUSH1 0x40 0B7F 80 DUP1 0B80 51 MLOAD 0B81 60 PUSH1 0x02 0B83 80 DUP1 0B84 82 DUP3 0B85 52 MSTORE 0B86 60 PUSH1 0x60 0B88 80 DUP1 0B89 83 DUP4 0B8A 01 ADD 0B8B 84 DUP5 0B8C 52 MSTORE 0B8D 92 SWAP3 0B8E 60 PUSH1 0x20 0B90 83 DUP4 0B91 01 ADD 0B92 90 SWAP1 0B93 80 DUP1 0B94 36 CALLDATASIZE 0B95 83 DUP4 0B96 37 CALLDATACOPY 0B97 01 ADD 0B98 90 SWAP1 0B99 50 POP 0B9A 50 POP 0B9B 90 SWAP1 0B9C 50 POP 0B9D 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0BBE 81 DUP2 0BBF 60 PUSH1 0x01 0BC1 81 DUP2 0BC2 51 MLOAD 0BC3 81 DUP2 0BC4 10 LT 0BC5 61 PUSH2 0x0bca 0BC8 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @0B85 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @0B8C memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0B96 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x40] = msg.data[msg.data.length:msg.data.length + 0x40] // @0B9B stack[0] = memory[0x40:0x60] // @0B9D stack[1] = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0BBE stack[2] = memory[0x40:0x60] // @0BBF stack[3] = 0x01 // } // Block ends with conditional jump to 0x0bca, if 0x01 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_0BC9: // Incoming jump from 0x0BC8, if not 0x01 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] 0BC9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0BC9 assert(); } // Block terminates label_0BCA: // Incoming jump from 0x0BC8, if 0x01 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[4] // { // @0BD3 stack[-1] // @0BD4 stack[-3] // @0BDB stack[-2] // @0BE6 stack[-5] // } 0BCA 5B JUMPDEST 0BCB 60 PUSH1 0x01 0BCD 60 PUSH1 0x01 0BCF 60 PUSH1 0xa0 0BD1 1B SHL 0BD2 03 SUB 0BD3 90 SWAP1 0BD4 92 SWAP3 0BD5 16 AND 0BD6 60 PUSH1 0x20 0BD8 92 SWAP3 0BD9 83 DUP4 0BDA 02 MUL 0BDB 91 SWAP2 0BDC 90 SWAP1 0BDD 91 SWAP2 0BDE 01 ADD 0BDF 90 SWAP1 0BE0 91 SWAP2 0BE1 01 ADD 0BE2 52 MSTORE 0BE3 60 PUSH1 0x00 0BE5 5B JUMPDEST 0BE6 82 DUP3 0BE7 81 DUP2 0BE8 10 LT 0BE9 15 ISZERO 0BEA 61 PUSH2 0x0ea2 0BED 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0BE2 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0BE3 stack[-3] = 0x00 // } // Block ends with conditional jump to 0x0ea2, if !(0x00 < stack[-5]) label_0BEE: // Incoming jump from 0x0BED, if not !(0x00 < stack[-5]) // Incoming jump from 0x0BED, if not !(stack[-1] < stack[-3]) // Inputs[3] // { // @0BF0 stack[-4] // @0BF1 stack[-3] // @0BF2 stack[-1] // } 0BEE 60 PUSH1 0x00 0BF0 84 DUP5 0BF1 84 DUP5 0BF2 83 DUP4 0BF3 81 DUP2 0BF4 81 DUP2 0BF5 10 LT 0BF6 61 PUSH2 0x0bfb 0BF9 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0BEE stack[0] = 0x00 // @0BF0 stack[1] = stack[-4] // @0BF1 stack[2] = stack[-3] // @0BF2 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0bfb, if stack[-1] < stack[-3] label_0BFA: // Incoming jump from 0x0BF9, if not stack[-1] < stack[-3] 0BFA FE *ASSERT // Stack delta = +0 // Outputs[1] { @0BFA assert(); } // Block terminates label_0BFB: // Incoming jump from 0x0BF9, if stack[-1] < stack[-3] // Inputs[8] // { // @0BFF memory[0x40:0x60] // @0C0A address(this) // @0C11 memory[0x40:0x60] // @0C14 stack[-1] // @0C17 stack[-3] // @0C1B msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0C2B stack[-2] // @0C3B address((0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20]).code.length // } 0BFB 5B JUMPDEST 0BFC 60 PUSH1 0x40 0BFE 80 DUP1 0BFF 51 MLOAD 0C00 63 PUSH4 0x70a08231 0C05 60 PUSH1 0xe0 0C07 1B SHL 0C08 81 DUP2 0C09 52 MSTORE 0C0A 30 ADDRESS 0C0B 60 PUSH1 0x04 0C0D 82 DUP3 0C0E 01 ADD 0C0F 52 MSTORE 0C10 90 SWAP1 0C11 51 MLOAD 0C12 60 PUSH1 0x20 0C14 92 SWAP3 0C15 83 DUP4 0C16 02 MUL 0C17 94 SWAP5 0C18 90 SWAP1 0C19 94 SWAP5 0C1A 01 ADD 0C1B 35 CALLDATALOAD 0C1C 60 PUSH1 0x01 0C1E 60 PUSH1 0x01 0C20 60 PUSH1 0xa0 0C22 1B SHL 0C23 03 SUB 0C24 16 AND 0C25 93 SWAP4 0C26 63 PUSH4 0x70a08231 0C2B 93 SWAP4 0C2C 50 POP 0C2D 60 PUSH1 0x24 0C2F 80 DUP1 0C30 83 DUP4 0C31 01 ADD 0C32 93 SWAP4 0C33 92 SWAP3 0C34 82 DUP3 0C35 90 SWAP1 0C36 03 SUB 0C37 01 ADD 0C38 81 DUP2 0C39 86 DUP7 0C3A 80 DUP1 0C3B 3B EXTCODESIZE 0C3C 15 ISZERO 0C3D 80 DUP1 0C3E 15 ISZERO 0C3F 61 PUSH2 0x0c47 0C42 57 *JUMPI // Stack delta = +6 // Outputs[11] // { // @0C09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @0C0F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0C25 stack[1] = memory[0x40:0x60] // @0C25 stack[-3] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0C2B stack[-2] = 0x70a08231 // @0C32 stack[-1] = memory[0x40:0x60] + 0x24 // @0C33 stack[0] = 0x20 // @0C37 stack[2] = memory[0x40:0x60] - memory[0x40:0x60] + 0x24 // @0C38 stack[3] = memory[0x40:0x60] // @0C39 stack[4] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0C3C stack[5] = !address((0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20]).code.length // } // Block ends with conditional jump to 0x0c47, if !!address((0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20]).code.length label_0C43: // Incoming jump from 0x0C42, if not !!address((0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20]).code.length // Inputs[1] { @0C46 memory[0x00:0x00] } 0C43 60 PUSH1 0x00 0C45 80 DUP1 0C46 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C46 revert(memory[0x00:0x00]); } // Block terminates label_0C47: // Incoming jump from 0x0C42, if !!address((0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20]).code.length // Inputs[8] // { // @0C49 msg.gas // @0C4A memory[stack[-3]:stack[-3] + stack[-4]] // @0C4A stack[-2] // @0C4A stack[-6] // @0C4A stack[-4] // @0C4A stack[-5] // @0C4A address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0C4A stack[-3] // } 0C47 5B JUMPDEST 0C48 50 POP 0C49 5A GAS 0C4A FA STATICCALL 0C4B 15 ISZERO 0C4C 80 DUP1 0C4D 15 ISZERO 0C4E 61 PUSH2 0x0c5b 0C51 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0C4A memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0C4B stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0c5b, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0C52: // Incoming jump from 0x0C51, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0C52 returndata.length // @0C56 returndata[0x00:0x00 + returndata.length] // @0C57 returndata.length // @0C5A memory[0x00:0x00 + returndata.length] // } 0C52 3D RETURNDATASIZE 0C53 60 PUSH1 0x00 0C55 80 DUP1 0C56 3E RETURNDATACOPY 0C57 3D RETURNDATASIZE 0C58 60 PUSH1 0x00 0C5A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C56 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0C5A revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0C5B: // Incoming jump from 0x0C51, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0C62 memory[0x40:0x60] // @0C63 returndata.length // } 0C5B 5B JUMPDEST 0C5C 50 POP 0C5D 50 POP 0C5E 50 POP 0C5F 50 POP 0C60 60 PUSH1 0x40 0C62 51 MLOAD 0C63 3D RETURNDATASIZE 0C64 60 PUSH1 0x20 0C66 81 DUP2 0C67 10 LT 0C68 15 ISZERO 0C69 61 PUSH2 0x0c71 0C6C 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0C62 stack[-4] = memory[0x40:0x60] // @0C63 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0c71, if !(returndata.length < 0x20) label_0C6D: // Incoming jump from 0x0C6C, if not !(returndata.length < 0x20) // Inputs[1] { @0C70 memory[0x00:0x00] } 0C6D 60 PUSH1 0x00 0C6F 80 DUP1 0C70 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C70 revert(memory[0x00:0x00]); } // Block terminates label_0C71: // Incoming jump from 0x0C6C, if !(returndata.length < 0x20) // Inputs[3] // { // @0C73 memory[stack[-2]:stack[-2] + 0x20] // @0C73 stack[-2] // @0C74 stack[-3] // } 0C71 5B JUMPDEST 0C72 50 POP 0C73 51 MLOAD 0C74 11 GT 0C75 15 ISZERO 0C76 61 PUSH2 0x0e9a 0C79 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0e9a, if !(memory[stack[-2]:stack[-2] + 0x20] > stack[-3]) label_0C7A: // Incoming jump from 0x0C79, if not !(memory[stack[-2]:stack[-2] + 0x20] > stack[-3]) // Inputs[3] // { // @0C7A stack[-4] // @0C7B stack[-3] // @0C7C stack[-1] // } 0C7A 83 DUP4 0C7B 83 DUP4 0C7C 82 DUP3 0C7D 81 DUP2 0C7E 81 DUP2 0C7F 10 LT 0C80 61 PUSH2 0x0c85 0C83 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C7A stack[0] = stack[-4] // @0C7B stack[1] = stack[-3] // @0C7C stack[2] = stack[-1] // } // Block ends with conditional jump to 0x0c85, if stack[-1] < stack[-3] label_0C84: // Incoming jump from 0x0C83, if not stack[-1] < stack[-3] 0C84 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0C84 assert(); } // Block terminates label_0C85: // Incoming jump from 0x0C83, if stack[-1] < stack[-3] // Inputs[6] // { // @0C86 stack[-2] // @0C86 stack[-1] // @0C8B stack[-3] // @0C8C msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0C96 stack[-5] // @0C9A memory[stack[-5]:stack[-5] + 0x20] // } 0C85 5B JUMPDEST 0C86 90 SWAP1 0C87 50 POP 0C88 60 PUSH1 0x20 0C8A 02 MUL 0C8B 01 ADD 0C8C 35 CALLDATALOAD 0C8D 60 PUSH1 0x01 0C8F 60 PUSH1 0x01 0C91 60 PUSH1 0xa0 0C93 1B SHL 0C94 03 SUB 0C95 16 AND 0C96 82 DUP3 0C97 60 PUSH1 0x00 0C99 81 DUP2 0C9A 51 MLOAD 0C9B 81 DUP2 0C9C 10 LT 0C9D 61 PUSH2 0x0ca2 0CA0 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @0C95 stack[-3] = (0x01 << 0xa0) - 0x01 & msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0C96 stack[-2] = stack[-5] // @0C97 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0ca2, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_0CA1: // Incoming jump from 0x0CA0, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 0CA1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CA1 assert(); } // Block terminates label_0CA2: // Incoming jump from 0x0CA0, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @0CA5 stack[-1] // @0CA9 stack[-2] // @0CAA stack[-3] // @0CC5 stack[-5] // @0CC9 memory[stack[-5]:stack[-5] + 0x20] // } 0CA2 5B JUMPDEST 0CA3 60 PUSH1 0x20 0CA5 02 MUL 0CA6 60 PUSH1 0x20 0CA8 01 ADD 0CA9 01 ADD 0CAA 90 SWAP1 0CAB 60 PUSH1 0x01 0CAD 60 PUSH1 0x01 0CAF 60 PUSH1 0xa0 0CB1 1B SHL 0CB2 03 SUB 0CB3 16 AND 0CB4 90 SWAP1 0CB5 81 DUP2 0CB6 60 PUSH1 0x01 0CB8 60 PUSH1 0x01 0CBA 60 PUSH1 0xa0 0CBC 1B SHL 0CBD 03 SUB 0CBE 16 AND 0CBF 81 DUP2 0CC0 52 MSTORE 0CC1 50 POP 0CC2 50 POP 0CC3 60 PUSH1 0x00 0CC5 82 DUP3 0CC6 60 PUSH1 0x00 0CC8 81 DUP2 0CC9 51 MLOAD 0CCA 81 DUP2 0CCB 10 LT 0CCC 61 PUSH2 0x0cd1 0CCF 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0CC0 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-3] // @0CC3 stack[-3] = 0x00 // @0CC5 stack[-2] = stack[-5] // @0CC6 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0cd1, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_0CD0: // Incoming jump from 0x0CCF, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 0CD0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CD0 assert(); } // Block terminates label_0CD1: // Incoming jump from 0x0CCF, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[7] // { // @0CD4 stack[-1] // @0CD8 stack[-2] // @0CD9 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CE8 address(this) // @0CEB memory[0x40:0x60] // @0D1B memory[0x40:0x60] // @0D22 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 0CD1 5B JUMPDEST 0CD2 60 PUSH1 0x20 0CD4 02 MUL 0CD5 60 PUSH1 0x20 0CD7 01 ADD 0CD8 01 ADD 0CD9 51 MLOAD 0CDA 60 PUSH1 0x01 0CDC 60 PUSH1 0x01 0CDE 60 PUSH1 0xa0 0CE0 1B SHL 0CE1 03 SUB 0CE2 16 AND 0CE3 63 PUSH4 0x70a08231 0CE8 30 ADDRESS 0CE9 60 PUSH1 0x40 0CEB 51 MLOAD 0CEC 82 DUP3 0CED 63 PUSH4 0xffffffff 0CF2 16 AND 0CF3 60 PUSH1 0xe0 0CF5 1B SHL 0CF6 81 DUP2 0CF7 52 MSTORE 0CF8 60 PUSH1 0x04 0CFA 01 ADD 0CFB 80 DUP1 0CFC 82 DUP3 0CFD 60 PUSH1 0x01 0CFF 60 PUSH1 0x01 0D01 60 PUSH1 0xa0 0D03 1B SHL 0D04 03 SUB 0D05 16 AND 0D06 60 PUSH1 0x01 0D08 60 PUSH1 0x01 0D0A 60 PUSH1 0xa0 0D0C 1B SHL 0D0D 03 SUB 0D0E 16 AND 0D0F 81 DUP2 0D10 52 MSTORE 0D11 60 PUSH1 0x20 0D13 01 ADD 0D14 91 SWAP2 0D15 50 POP 0D16 50 POP 0D17 60 PUSH1 0x20 0D19 60 PUSH1 0x40 0D1B 51 MLOAD 0D1C 80 DUP1 0D1D 83 DUP4 0D1E 03 SUB 0D1F 81 DUP2 0D20 86 DUP7 0D21 80 DUP1 0D22 3B EXTCODESIZE 0D23 15 ISZERO 0D24 80 DUP1 0D25 15 ISZERO 0D26 61 PUSH2 0x0d2e 0D29 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @0CE2 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0CE3 stack[-1] = 0x70a08231 // @0CF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @0D10 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & address(this) // @0D14 stack[0] = 0x20 + 0x04 + memory[0x40:0x60] // @0D17 stack[1] = 0x20 // @0D1B stack[2] = memory[0x40:0x60] // @0D1E stack[3] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0D1F stack[4] = memory[0x40:0x60] // @0D20 stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0D23 stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x0d2e, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_0D2A: // Incoming jump from 0x0D29, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @0D2D memory[0x00:0x00] } 0D2A 60 PUSH1 0x00 0D2C 80 DUP1 0D2D FD *REVERT // Stack delta = +0 // Outputs[1] { @0D2D revert(memory[0x00:0x00]); } // Block terminates label_0D2E: // Incoming jump from 0x0D29, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @0D30 msg.gas // @0D31 stack[-3] // @0D31 stack[-6] // @0D31 stack[-4] // @0D31 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D31 stack[-5] // @0D31 memory[stack[-3]:stack[-3] + stack[-4]] // @0D31 stack[-2] // } 0D2E 5B JUMPDEST 0D2F 50 POP 0D30 5A GAS 0D31 FA STATICCALL 0D32 15 ISZERO 0D33 80 DUP1 0D34 15 ISZERO 0D35 61 PUSH2 0x0d42 0D38 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0D31 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0D32 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0d42, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0D39: // Incoming jump from 0x0D38, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0D39 returndata.length // @0D3D returndata[0x00:0x00 + returndata.length] // @0D3E returndata.length // @0D41 memory[0x00:0x00 + returndata.length] // } 0D39 3D RETURNDATASIZE 0D3A 60 PUSH1 0x00 0D3C 80 DUP1 0D3D 3E RETURNDATACOPY 0D3E 3D RETURNDATASIZE 0D3F 60 PUSH1 0x00 0D41 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D3D memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0D41 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0D42: // Incoming jump from 0x0D38, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0D49 memory[0x40:0x60] // @0D4A returndata.length // } 0D42 5B JUMPDEST 0D43 50 POP 0D44 50 POP 0D45 50 POP 0D46 50 POP 0D47 60 PUSH1 0x40 0D49 51 MLOAD 0D4A 3D RETURNDATASIZE 0D4B 60 PUSH1 0x20 0D4D 81 DUP2 0D4E 10 LT 0D4F 15 ISZERO 0D50 61 PUSH2 0x0d58 0D53 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0D49 stack[-4] = memory[0x40:0x60] // @0D4A stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0d58, if !(returndata.length < 0x20) label_0D54: // Incoming jump from 0x0D53, if not !(returndata.length < 0x20) // Inputs[1] { @0D57 memory[0x00:0x00] } 0D54 60 PUSH1 0x00 0D56 80 DUP1 0D57 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D57 revert(memory[0x00:0x00]); } // Block terminates label_0D58: // Incoming jump from 0x0D53, if !(returndata.length < 0x20) // Inputs[3] // { // @0D5A memory[stack[-2]:stack[-2] + 0x20] // @0D5A stack[-2] // @0D5B stack[-3] // } 0D58 5B JUMPDEST 0D59 50 POP 0D5A 51 MLOAD 0D5B 90 SWAP1 0D5C 50 POP 0D5D 80 DUP1 0D5E 61 PUSH2 0x0d93 0D61 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0D5B stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0d93, if memory[stack[-2]:stack[-2] + 0x20] label_0D62: // Incoming jump from 0x0D61, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @0D65 memory[0x40:0x60] // @0D89 memory[0x40:0x60] // @0D92 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0D62 60 PUSH1 0x40 0D64 80 DUP1 0D65 51 MLOAD 0D66 62 PUSH3 0x461bcd 0D6A 60 PUSH1 0xe5 0D6C 1B SHL 0D6D 81 DUP2 0D6E 52 MSTORE 0D6F 60 PUSH1 0x20 0D71 60 PUSH1 0x04 0D73 82 DUP3 0D74 01 ADD 0D75 52 MSTORE 0D76 60 PUSH1 0x02 0D78 60 PUSH1 0x24 0D7A 82 DUP3 0D7B 01 ADD 0D7C 52 MSTORE 0D7D 61 PUSH2 0x1395 0D80 60 PUSH1 0xf2 0D82 1B SHL 0D83 60 PUSH1 0x44 0D85 82 DUP3 0D86 01 ADD 0D87 52 MSTORE 0D88 90 SWAP1 0D89 51 MLOAD 0D8A 90 SWAP1 0D8B 81 DUP2 0D8C 90 SWAP1 0D8D 03 SUB 0D8E 60 PUSH1 0x64 0D90 01 ADD 0D91 90 SWAP1 0D92 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0D6E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D75 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D7C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @0D87 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1395 << 0xf2 // @0D92 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0D93: // Incoming jump from 0x0D61, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @0DBA stack[-3] // @0DBE memory[stack[-3]:stack[-3] + 0x20] // } 0D93 5B JUMPDEST 0D94 60 PUSH1 0x00 0D96 61 PUSH2 0x0ddb 0D99 7F PUSH32 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f 0DBA 85 DUP6 0DBB 60 PUSH1 0x00 0DBD 81 DUP2 0DBE 51 MLOAD 0DBF 81 DUP2 0DC0 10 LT 0DC1 61 PUSH2 0x0dc6 0DC4 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0D94 stack[0] = 0x00 // @0D96 stack[1] = 0x0ddb // @0D99 stack[2] = 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f // @0DBA stack[3] = stack[-3] // @0DBB stack[4] = 0x00 // } // Block ends with conditional call to 0x0dc6, returns to 0x0DDB, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_0DC5: // Incoming jump from 0x0DC4, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 0DC5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0DC5 assert(); } // Block terminates label_0DC6: // Incoming call from 0x0DC4, returns to 0x0DDB, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @0DC9 stack[-1] // @0DCD stack[-2] // @0DCE memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0DCF stack[-8] // @0DD3 memory[stack[-8]:stack[-8] + 0x20] // } 0DC6 5B JUMPDEST 0DC7 60 PUSH1 0x20 0DC9 02 MUL 0DCA 60 PUSH1 0x20 0DCC 01 ADD 0DCD 01 ADD 0DCE 51 MLOAD 0DCF 86 DUP7 0DD0 60 PUSH1 0x01 0DD2 81 DUP2 0DD3 51 MLOAD 0DD4 81 DUP2 0DD5 10 LT 0DD6 61 PUSH2 0x07f9 0DD9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0DCE stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0DCF stack[-1] = stack[-8] // @0DD0 stack[0] = 0x01 // } // Block ends with conditional jump to 0x07f9, if 0x01 < memory[stack[-8]:stack[-8] + 0x20] label_0DDA: // Incoming jump from 0x0DD9, if not 0x01 < memory[stack[-8]:stack[-8] + 0x20] 0DDA FE *ASSERT // Stack delta = +0 // Outputs[1] { @0DDA assert(); } // Block terminates label_0DDB: // Incoming return from call to 0x0DC6 at 0x0DC4 // Inputs[4] // { // @0DDC stack[-2] // @0DDC stack[-1] // @0DE2 stack[-5] // @0DE6 memory[stack[-5]:stack[-5] + 0x20] // } 0DDB 5B JUMPDEST 0DDC 90 SWAP1 0DDD 50 POP 0DDE 60 PUSH1 0x05 0DE0 60 PUSH1 0x00 0DE2 85 DUP6 0DE3 60 PUSH1 0x00 0DE5 81 DUP2 0DE6 51 MLOAD 0DE7 81 DUP2 0DE8 10 LT 0DE9 61 PUSH2 0x0dee 0DEC 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0DDC stack[-2] = stack[-1] // @0DDE stack[-1] = 0x05 // @0DE0 stack[0] = 0x00 // @0DE2 stack[1] = stack[-5] // @0DE3 stack[2] = 0x00 // } // Block ends with conditional jump to 0x0dee, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] label_0DED: // Incoming jump from 0x0DEC, if not 0x00 < memory[stack[-5]:stack[-5] + 0x20] 0DED FE *ASSERT // Stack delta = +0 // Outputs[1] { @0DED assert(); } // Block terminates label_0DEE: // Incoming jump from 0x0DEC, if 0x00 < memory[stack[-5]:stack[-5] + 0x20] // Inputs[7] // { // @0DF1 stack[-1] // @0DF4 stack[-2] // @0DFA memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E04 stack[-3] // @0E08 stack[-4] // @0E11 memory[0x00:0x00 + 0x40 + stack[-3]] // @0E12 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // } 0DEE 5B JUMPDEST 0DEF 60 PUSH1 0x20 0DF1 90 SWAP1 0DF2 81 DUP2 0DF3 02 MUL 0DF4 91 SWAP2 0DF5 90 SWAP1 0DF6 91 SWAP2 0DF7 01 ADD 0DF8 81 DUP2 0DF9 01 ADD 0DFA 51 MLOAD 0DFB 60 PUSH1 0x01 0DFD 60 PUSH1 0x01 0DFF 60 PUSH1 0xa0 0E01 1B SHL 0E02 03 SUB 0E03 16 AND 0E04 82 DUP3 0E05 52 MSTORE 0E06 81 DUP2 0E07 01 ADD 0E08 91 SWAP2 0E09 90 SWAP1 0E0A 91 SWAP2 0E0B 52 MSTORE 0E0C 60 PUSH1 0x40 0E0E 01 ADD 0E0F 60 PUSH1 0x00 0E11 20 SHA3 0E12 54 SLOAD 0E13 60 PUSH1 0xff 0E15 16 AND 0E16 61 PUSH2 0x0e7c 0E19 57 *JUMPI // Stack delta = -4 // Outputs[2] // { // @0E05 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E0B memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x0e7c, if 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] label_0E1A: // Incoming jump from 0x0E19, if not 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // Inputs[2] // { // @0E1D stack[-4] // @0E21 memory[stack[-4]:stack[-4] + 0x20] // } 0E1A 61 PUSH2 0x0e29 0E1D 84 DUP5 0E1E 60 PUSH1 0x00 0E20 81 DUP2 0E21 51 MLOAD 0E22 81 DUP2 0E23 10 LT 0E24 61 PUSH2 0x0854 0E27 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E1A stack[0] = 0x0e29 // @0E1D stack[1] = stack[-4] // @0E1E stack[2] = 0x00 // } // Block ends with conditional call to 0x0854, returns to 0x0E29, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_0E28: // Incoming jump from 0x0E27, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 0E28 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E28 assert(); } // Block terminates label_0E29: // Incoming return from call to 0x0854 at 0x0E27 // Inputs[2] // { // @0E30 stack[-4] // @0E34 memory[stack[-4]:stack[-4] + 0x20] // } 0E29 5B JUMPDEST 0E2A 60 PUSH1 0x01 0E2C 60 PUSH1 0x05 0E2E 60 PUSH1 0x00 0E30 86 DUP7 0E31 60 PUSH1 0x00 0E33 81 DUP2 0E34 51 MLOAD 0E35 81 DUP2 0E36 10 LT 0E37 61 PUSH2 0x0e3c 0E3A 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @0E2A stack[0] = 0x01 // @0E2C stack[1] = 0x05 // @0E2E stack[2] = 0x00 // @0E30 stack[3] = stack[-4] // @0E31 stack[4] = 0x00 // } // Block ends with conditional jump to 0x0e3c, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_0E3B: // Incoming jump from 0x0E3A, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 0E3B FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E3B assert(); } // Block terminates label_0E3C: // Incoming jump from 0x0E3A, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[8] // { // @0E3F stack[-1] // @0E43 stack[-2] // @0E44 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E57 stack[-3] // @0E5C stack[-4] // @0E64 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @0E6C storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @0E74 stack[-5] // } 0E3C 5B JUMPDEST 0E3D 60 PUSH1 0x20 0E3F 02 MUL 0E40 60 PUSH1 0x20 0E42 01 ADD 0E43 01 ADD 0E44 51 MLOAD 0E45 60 PUSH1 0x01 0E47 60 PUSH1 0x01 0E49 60 PUSH1 0xa0 0E4B 1B SHL 0E4C 03 SUB 0E4D 16 AND 0E4E 60 PUSH1 0x01 0E50 60 PUSH1 0x01 0E52 60 PUSH1 0xa0 0E54 1B SHL 0E55 03 SUB 0E56 16 AND 0E57 81 DUP2 0E58 52 MSTORE 0E59 60 PUSH1 0x20 0E5B 01 ADD 0E5C 90 SWAP1 0E5D 81 DUP2 0E5E 52 MSTORE 0E5F 60 PUSH1 0x20 0E61 01 ADD 0E62 60 PUSH1 0x00 0E64 20 SHA3 0E65 60 PUSH1 0x00 0E67 61 PUSH2 0x0100 0E6A 0A EXP 0E6B 81 DUP2 0E6C 54 SLOAD 0E6D 81 DUP2 0E6E 60 PUSH1 0xff 0E70 02 MUL 0E71 19 NOT 0E72 16 AND 0E73 90 SWAP1 0E74 83 DUP4 0E75 15 ISZERO 0E76 15 ISZERO 0E77 02 MUL 0E78 17 OR 0E79 90 SWAP1 0E7A 55 SSTORE 0E7B 50 POP // Stack delta = -5 // Outputs[3] // { // @0E58 memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0E5E memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @0E7A storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // } // Block continues label_0E7C: // Incoming jump from 0x0E7B // Incoming jump from 0x0E19, if 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // Inputs[2] // { // @0E80 stack[-4] // @0E84 memory[stack[-4]:stack[-4] + 0x20] // } 0E7C 5B JUMPDEST 0E7D 61 PUSH2 0x0e8c 0E80 84 DUP5 0E81 60 PUSH1 0x00 0E83 81 DUP2 0E84 51 MLOAD 0E85 81 DUP2 0E86 10 LT 0E87 61 PUSH2 0x08c8 0E8A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0E7D stack[0] = 0x0e8c // @0E80 stack[1] = stack[-4] // @0E81 stack[2] = 0x00 // } // Block ends with conditional call to 0x08c8, returns to 0x0E8C, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_0E8B: // Incoming jump from 0x0E8A, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 0E8B FE *ASSERT // Stack delta = +0 // Outputs[1] { @0E8B assert(); } // Block terminates label_0E8C: // Incoming return from call to 0x08C8 at 0x0E8A // Inputs[3] // { // @0E90 stack[-4] // @0E91 address(this) // @0E92 stack[-1] // } 0E8C 5B JUMPDEST 0E8D 61 PUSH2 0x0e97 0E90 84 DUP5 0E91 30 ADDRESS 0E92 83 DUP4 0E93 61 PUSH2 0x1b6c 0E96 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E8D stack[0] = 0x0e97 // @0E90 stack[1] = stack[-4] // @0E91 stack[2] = address(this) // @0E92 stack[3] = stack[-1] // } // Block ends with call to 0x1b6c, returns to 0x0E97 label_0E97: // Incoming return from call to 0x1B6C at 0x0E96 0E97 5B JUMPDEST 0E98 50 POP 0E99 50 POP // Stack delta = -2 // Block continues label_0E9A: // Incoming jump from 0x0E99 // Incoming jump from 0x0C79, if !(memory[stack[-2]:stack[-2] + 0x20] > stack[-3]) // Inputs[1] { @0E9D stack[-1] } 0E9A 5B JUMPDEST 0E9B 60 PUSH1 0x01 0E9D 01 ADD 0E9E 61 PUSH2 0x0be5 0EA1 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E9D stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x0be5 label_0EA2: // Incoming jump from 0x0BED, if !(0x00 < stack[-5]) // Incoming jump from 0x0BED, if !(stack[-1] < stack[-3]) // Inputs[1] { @0EA7 stack[-5] } 0EA2 5B JUMPDEST 0EA3 50 POP 0EA4 50 POP 0EA5 50 POP 0EA6 50 POP 0EA7 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0EA8: // Incoming jump from 0x03BE // Inputs[3] // { // @0EA9 msg.sender // @0EB7 memory[0x00:0x40] // @0EB8 storage[keccak256(memory[0x00:0x40])] // } 0EA8 5B JUMPDEST 0EA9 33 CALLER 0EAA 60 PUSH1 0x00 0EAC 90 SWAP1 0EAD 81 DUP2 0EAE 52 MSTORE 0EAF 60 PUSH1 0x04 0EB1 60 PUSH1 0x20 0EB3 52 MSTORE 0EB4 60 PUSH1 0x40 0EB6 90 SWAP1 0EB7 20 SHA3 0EB8 54 SLOAD 0EB9 60 PUSH1 0xff 0EBB 16 AND 0EBC 15 ISZERO 0EBD 15 ISZERO 0EBE 60 PUSH1 0x01 0EC0 14 EQ 0EC1 61 PUSH2 0x0efc 0EC4 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0EAE memory[0x00:0x20] = msg.sender // @0EB3 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0efc, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) label_0EC5: // Incoming jump from 0x0EC4, if not 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0EC8 memory[0x40:0x60] // @0EF2 memory[0x40:0x60] // @0EFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0EC5 60 PUSH1 0x40 0EC7 80 DUP1 0EC8 51 MLOAD 0EC9 62 PUSH3 0x461bcd 0ECD 60 PUSH1 0xe5 0ECF 1B SHL 0ED0 81 DUP2 0ED1 52 MSTORE 0ED2 60 PUSH1 0x20 0ED4 60 PUSH1 0x04 0ED6 82 DUP3 0ED7 01 ADD 0ED8 52 MSTORE 0ED9 60 PUSH1 0x08 0EDB 60 PUSH1 0x24 0EDD 82 DUP3 0EDE 01 ADD 0EDF 52 MSTORE 0EE0 67 PUSH8 0x13db9b1e48109bdd 0EE9 60 PUSH1 0xc2 0EEB 1B SHL 0EEC 60 PUSH1 0x44 0EEE 82 DUP3 0EEF 01 ADD 0EF0 52 MSTORE 0EF1 90 SWAP1 0EF2 51 MLOAD 0EF3 90 SWAP1 0EF4 81 DUP2 0EF5 90 SWAP1 0EF6 03 SUB 0EF7 60 PUSH1 0x64 0EF9 01 ADD 0EFA 90 SWAP1 0EFB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0ED1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0ED8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EDF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @0EF0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x13db9b1e48109bdd << 0xc2 // @0EFB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0EFC: // Incoming jump from 0x0EC4, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @0EFD stack[-1] // @0EFE block.timestamp // } 0EFC 5B JUMPDEST 0EFD 80 DUP1 0EFE 42 TIMESTAMP 0EFF 81 DUP2 0F00 10 LT 0F01 15 ISZERO 0F02 61 PUSH2 0x0f37 0F05 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EFD stack[0] = stack[-1] } // Block ends with conditional jump to 0x0f37, if !(stack[-1] < block.timestamp) label_0F06: // Incoming jump from 0x0F05, if not !(stack[-1] < block.timestamp) // Inputs[3] // { // @0F09 memory[0x40:0x60] // @0F2D memory[0x40:0x60] // @0F36 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0F06 60 PUSH1 0x40 0F08 80 DUP1 0F09 51 MLOAD 0F0A 62 PUSH3 0x461bcd 0F0E 60 PUSH1 0xe5 0F10 1B SHL 0F11 81 DUP2 0F12 52 MSTORE 0F13 60 PUSH1 0x20 0F15 60 PUSH1 0x04 0F17 82 DUP3 0F18 01 ADD 0F19 52 MSTORE 0F1A 60 PUSH1 0x02 0F1C 60 PUSH1 0x24 0F1E 82 DUP3 0F1F 01 ADD 0F20 52 MSTORE 0F21 61 PUSH2 0x5445 0F24 60 PUSH1 0xf0 0F26 1B SHL 0F27 60 PUSH1 0x44 0F29 82 DUP3 0F2A 01 ADD 0F2B 52 MSTORE 0F2C 90 SWAP1 0F2D 51 MLOAD 0F2E 90 SWAP1 0F2F 81 DUP2 0F30 90 SWAP1 0F31 03 SUB 0F32 60 PUSH1 0x64 0F34 01 ADD 0F35 90 SWAP1 0F36 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F19 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F20 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @0F2B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5445 << 0xf0 // @0F36 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0F37: // Incoming jump from 0x0F05, if !(stack[-1] < block.timestamp) // Inputs[10] // { // @0F3B memory[0x40:0x60] // @0F4F msg.data.length // @0F51 msg.data[msg.data.length:msg.data.length + 0x40] // @0F58 storage[0x00] // @0F5C storage[0x02] // @0F72 stack[-2] // @0F73 stack[-3] // @0F79 memory[0x40:0x60] // @0F97 memory[0x40:0x60] // @0F9E address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length // } 0F37 5B JUMPDEST 0F38 60 PUSH1 0x40 0F3A 80 DUP1 0F3B 51 MLOAD 0F3C 60 PUSH1 0x02 0F3E 80 DUP1 0F3F 82 DUP3 0F40 52 MSTORE 0F41 60 PUSH1 0x60 0F43 80 DUP1 0F44 83 DUP4 0F45 01 ADD 0F46 84 DUP5 0F47 52 MSTORE 0F48 92 SWAP3 0F49 60 PUSH1 0x20 0F4B 83 DUP4 0F4C 01 ADD 0F4D 90 SWAP1 0F4E 80 DUP1 0F4F 36 CALLDATASIZE 0F50 83 DUP4 0F51 37 CALLDATACOPY 0F52 01 ADD 0F53 90 SWAP1 0F54 50 POP 0F55 50 POP 0F56 60 PUSH1 0x00 0F58 54 SLOAD 0F59 60 PUSH1 0x02 0F5B 80 DUP1 0F5C 54 SLOAD 0F5D 92 SWAP3 0F5E 93 SWAP4 0F5F 50 POP 0F60 60 PUSH1 0x01 0F62 60 PUSH1 0x01 0F64 60 PUSH1 0xa0 0F66 1B SHL 0F67 03 SUB 0F68 90 SWAP1 0F69 91 SWAP2 0F6A 16 AND 0F6B 91 SWAP2 0F6C 63 PUSH4 0x67ccdf38 0F71 91 SWAP2 0F72 86 DUP7 0F73 88 DUP9 0F74 03 SUB 0F75 04 DIV 0F76 03 SUB 0F77 60 PUSH1 0x40 0F79 51 MLOAD 0F7A 82 DUP3 0F7B 63 PUSH4 0xffffffff 0F80 16 AND 0F81 60 PUSH1 0xe0 0F83 1B SHL 0F84 81 DUP2 0F85 52 MSTORE 0F86 60 PUSH1 0x04 0F88 01 ADD 0F89 80 DUP1 0F8A 82 DUP3 0F8B 81 DUP2 0F8C 52 MSTORE 0F8D 60 PUSH1 0x20 0F8F 01 ADD 0F90 91 SWAP2 0F91 50 POP 0F92 50 POP 0F93 60 PUSH1 0x20 0F95 60 PUSH1 0x40 0F97 51 MLOAD 0F98 80 DUP1 0F99 83 DUP4 0F9A 03 SUB 0F9B 81 DUP2 0F9C 86 DUP7 0F9D 80 DUP1 0F9E 3B EXTCODESIZE 0F9F 15 ISZERO 0FA0 80 DUP1 0FA1 15 ISZERO 0FA2 61 PUSH2 0x0faa 0FA5 57 *JUMPI // Stack delta = +10 // Outputs[15] // { // @0F40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @0F47 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0F51 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x40] = msg.data[msg.data.length:msg.data.length + 0x40] // @0F5E stack[0] = memory[0x40:0x60] // @0F6B stack[1] = storage[0x00] & (0x01 << 0xa0) - 0x01 // @0F71 stack[2] = 0x67ccdf38 // @0F85 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x67ccdf38) << 0xe0 // @0F8C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-3] - stack[-2] / 0x02 - storage[0x02] // @0F90 stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @0F93 stack[4] = 0x20 // @0F97 stack[5] = memory[0x40:0x60] // @0F9A stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0F9B stack[7] = memory[0x40:0x60] // @0F9C stack[8] = storage[0x00] & (0x01 << 0xa0) - 0x01 // @0F9F stack[9] = !address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x0faa, if !!address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length label_0FA6: // Incoming jump from 0x0FA5, if not !!address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0FA9 memory[0x00:0x00] } 0FA6 60 PUSH1 0x00 0FA8 80 DUP1 0FA9 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FA9 revert(memory[0x00:0x00]); } // Block terminates label_0FAA: // Incoming jump from 0x0FA5, if !!address(storage[0x00] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @0FAC msg.gas // @0FAD stack[-4] // @0FAD memory[stack[-3]:stack[-3] + stack[-4]] // @0FAD stack[-2] // @0FAD stack[-6] // @0FAD address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0FAD stack[-3] // @0FAD stack[-5] // } 0FAA 5B JUMPDEST 0FAB 50 POP 0FAC 5A GAS 0FAD FA STATICCALL 0FAE 15 ISZERO 0FAF 80 DUP1 0FB0 15 ISZERO 0FB1 61 PUSH2 0x0fbe 0FB4 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0FAD memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0FAE stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0fbe, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0FB5: // Incoming jump from 0x0FB4, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0FB5 returndata.length // @0FB9 returndata[0x00:0x00 + returndata.length] // @0FBA returndata.length // @0FBD memory[0x00:0x00 + returndata.length] // } 0FB5 3D RETURNDATASIZE 0FB6 60 PUSH1 0x00 0FB8 80 DUP1 0FB9 3E RETURNDATACOPY 0FBA 3D RETURNDATASIZE 0FBB 60 PUSH1 0x00 0FBD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FB9 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0FBD revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0FBE: // Incoming jump from 0x0FB4, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0FC5 memory[0x40:0x60] // @0FC6 returndata.length // } 0FBE 5B JUMPDEST 0FBF 50 POP 0FC0 50 POP 0FC1 50 POP 0FC2 50 POP 0FC3 60 PUSH1 0x40 0FC5 51 MLOAD 0FC6 3D RETURNDATASIZE 0FC7 60 PUSH1 0x20 0FC9 81 DUP2 0FCA 10 LT 0FCB 15 ISZERO 0FCC 61 PUSH2 0x0fd4 0FCF 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0FC5 stack[-4] = memory[0x40:0x60] // @0FC6 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0fd4, if !(returndata.length < 0x20) label_0FD0: // Incoming jump from 0x0FCF, if not !(returndata.length < 0x20) // Inputs[1] { @0FD3 memory[0x00:0x00] } 0FD0 60 PUSH1 0x00 0FD2 80 DUP1 0FD3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0FD3 revert(memory[0x00:0x00]); } // Block terminates label_0FD4: // Incoming jump from 0x0FCF, if !(returndata.length < 0x20) // Inputs[4] // { // @0FD6 memory[stack[-2]:stack[-2] + 0x20] // @0FD6 stack[-2] // @0FD7 stack[-3] // @0FD8 memory[stack[-3]:stack[-3] + 0x20] // } 0FD4 5B JUMPDEST 0FD5 50 POP 0FD6 51 MLOAD 0FD7 81 DUP2 0FD8 51 MLOAD 0FD9 82 DUP3 0FDA 90 SWAP1 0FDB 60 PUSH1 0x00 0FDD 90 SWAP1 0FDE 61 PUSH2 0x0fe3 0FE1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0FD6 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @0FDA stack[-1] = stack[-3] // @0FDD stack[0] = 0x00 // } // Block ends with conditional jump to 0x0fe3, if memory[stack[-3]:stack[-3] + 0x20] label_0FE2: // Incoming jump from 0x0FE1, if not memory[stack[-3]:stack[-3] + 0x20] 0FE2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0FE2 assert(); } // Block terminates label_0FE3: // Incoming jump from 0x0FE1, if memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @0FE6 stack[-1] // @0FEA stack[-2] // @0FEB stack[-3] // @1025 stack[-4] // @1029 memory[stack[-4]:stack[-4] + 0x20] // } 0FE3 5B JUMPDEST 0FE4 60 PUSH1 0x20 0FE6 02 MUL 0FE7 60 PUSH1 0x20 0FE9 01 ADD 0FEA 01 ADD 0FEB 90 SWAP1 0FEC 60 PUSH1 0x01 0FEE 60 PUSH1 0x01 0FF0 60 PUSH1 0xa0 0FF2 1B SHL 0FF3 03 SUB 0FF4 16 AND 0FF5 90 SWAP1 0FF6 81 DUP2 0FF7 60 PUSH1 0x01 0FF9 60 PUSH1 0x01 0FFB 60 PUSH1 0xa0 0FFD 1B SHL 0FFE 03 SUB 0FFF 16 AND 1000 81 DUP2 1001 52 MSTORE 1002 50 POP 1003 50 POP 1004 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1025 81 DUP2 1026 60 PUSH1 0x01 1028 81 DUP2 1029 51 MLOAD 102A 81 DUP2 102B 10 LT 102C 61 PUSH2 0x1031 102F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1001 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-3] // @1004 stack[-3] = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1025 stack[-2] = stack[-4] // @1026 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x1031, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_1030: // Incoming jump from 0x102F, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 1030 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1030 assert(); } // Block terminates label_1031: // Incoming jump from 0x102F, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @1034 stack[-1] // @1038 stack[-2] // @1039 stack[-3] // @1054 stack[-4] // @1058 memory[stack[-4]:stack[-4] + 0x20] // } 1031 5B JUMPDEST 1032 60 PUSH1 0x20 1034 02 MUL 1035 60 PUSH1 0x20 1037 01 ADD 1038 01 ADD 1039 90 SWAP1 103A 60 PUSH1 0x01 103C 60 PUSH1 0x01 103E 60 PUSH1 0xa0 1040 1B SHL 1041 03 SUB 1042 16 AND 1043 90 SWAP1 1044 81 DUP2 1045 60 PUSH1 0x01 1047 60 PUSH1 0x01 1049 60 PUSH1 0xa0 104B 1B SHL 104C 03 SUB 104D 16 AND 104E 81 DUP2 104F 52 MSTORE 1050 50 POP 1051 50 POP 1052 60 PUSH1 0x00 1054 81 DUP2 1055 60 PUSH1 0x00 1057 81 DUP2 1058 51 MLOAD 1059 81 DUP2 105A 10 LT 105B 61 PUSH2 0x1060 105E 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @104F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-3] // @1052 stack[-3] = 0x00 // @1054 stack[-2] = stack[-4] // @1055 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x1060, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_105F: // Incoming jump from 0x105E, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 105F FE *ASSERT // Stack delta = +0 // Outputs[1] { @105F assert(); } // Block terminates label_1060: // Incoming jump from 0x105E, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @1063 stack[-1] // @1067 stack[-2] // @1068 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1077 address(this) // @107A memory[0x40:0x60] // @10AA memory[0x40:0x60] // @10B1 address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } 1060 5B JUMPDEST 1061 60 PUSH1 0x20 1063 02 MUL 1064 60 PUSH1 0x20 1066 01 ADD 1067 01 ADD 1068 51 MLOAD 1069 60 PUSH1 0x01 106B 60 PUSH1 0x01 106D 60 PUSH1 0xa0 106F 1B SHL 1070 03 SUB 1071 16 AND 1072 63 PUSH4 0x70a08231 1077 30 ADDRESS 1078 60 PUSH1 0x40 107A 51 MLOAD 107B 82 DUP3 107C 63 PUSH4 0xffffffff 1081 16 AND 1082 60 PUSH1 0xe0 1084 1B SHL 1085 81 DUP2 1086 52 MSTORE 1087 60 PUSH1 0x04 1089 01 ADD 108A 80 DUP1 108B 82 DUP3 108C 60 PUSH1 0x01 108E 60 PUSH1 0x01 1090 60 PUSH1 0xa0 1092 1B SHL 1093 03 SUB 1094 16 AND 1095 60 PUSH1 0x01 1097 60 PUSH1 0x01 1099 60 PUSH1 0xa0 109B 1B SHL 109C 03 SUB 109D 16 AND 109E 81 DUP2 109F 52 MSTORE 10A0 60 PUSH1 0x20 10A2 01 ADD 10A3 91 SWAP2 10A4 50 POP 10A5 50 POP 10A6 60 PUSH1 0x20 10A8 60 PUSH1 0x40 10AA 51 MLOAD 10AB 80 DUP1 10AC 83 DUP4 10AD 03 SUB 10AE 81 DUP2 10AF 86 DUP7 10B0 80 DUP1 10B1 3B EXTCODESIZE 10B2 15 ISZERO 10B3 80 DUP1 10B4 15 ISZERO 10B5 61 PUSH2 0x10bd 10B8 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @1071 stack[-2] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1072 stack[-1] = 0x70a08231 // @1086 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @109F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & address(this) // @10A3 stack[0] = 0x20 + 0x04 + memory[0x40:0x60] // @10A6 stack[1] = 0x20 // @10AA stack[2] = memory[0x40:0x60] // @10AD stack[3] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @10AE stack[4] = memory[0x40:0x60] // @10AF stack[5] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @10B2 stack[6] = !address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // } // Block ends with conditional jump to 0x10bd, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length label_10B9: // Incoming jump from 0x10B8, if not !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[1] { @10BC memory[0x00:0x00] } 10B9 60 PUSH1 0x00 10BB 80 DUP1 10BC FD *REVERT // Stack delta = +0 // Outputs[1] { @10BC revert(memory[0x00:0x00]); } // Block terminates label_10BD: // Incoming jump from 0x10B8, if !!address((0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20]).code.length // Inputs[8] // { // @10BF msg.gas // @10C0 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @10C0 stack[-3] // @10C0 stack[-6] // @10C0 memory[stack[-3]:stack[-3] + stack[-4]] // @10C0 stack[-2] // @10C0 stack[-5] // @10C0 stack[-4] // } 10BD 5B JUMPDEST 10BE 50 POP 10BF 5A GAS 10C0 FA STATICCALL 10C1 15 ISZERO 10C2 80 DUP1 10C3 15 ISZERO 10C4 61 PUSH2 0x10d1 10C7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @10C0 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @10C1 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x10d1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_10C8: // Incoming jump from 0x10C7, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @10C8 returndata.length // @10CC returndata[0x00:0x00 + returndata.length] // @10CD returndata.length // @10D0 memory[0x00:0x00 + returndata.length] // } 10C8 3D RETURNDATASIZE 10C9 60 PUSH1 0x00 10CB 80 DUP1 10CC 3E RETURNDATACOPY 10CD 3D RETURNDATASIZE 10CE 60 PUSH1 0x00 10D0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @10CC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @10D0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_10D1: // Incoming jump from 0x10C7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @10D8 memory[0x40:0x60] // @10D9 returndata.length // } 10D1 5B JUMPDEST 10D2 50 POP 10D3 50 POP 10D4 50 POP 10D5 50 POP 10D6 60 PUSH1 0x40 10D8 51 MLOAD 10D9 3D RETURNDATASIZE 10DA 60 PUSH1 0x20 10DC 81 DUP2 10DD 10 LT 10DE 15 ISZERO 10DF 61 PUSH2 0x10e7 10E2 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @10D8 stack[-4] = memory[0x40:0x60] // @10D9 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x10e7, if !(returndata.length < 0x20) label_10E3: // Incoming jump from 0x10E2, if not !(returndata.length < 0x20) // Inputs[1] { @10E6 memory[0x00:0x00] } 10E3 60 PUSH1 0x00 10E5 80 DUP1 10E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @10E6 revert(memory[0x00:0x00]); } // Block terminates label_10E7: // Incoming jump from 0x10E2, if !(returndata.length < 0x20) // Inputs[3] // { // @10E9 stack[-2] // @10E9 memory[stack[-2]:stack[-2] + 0x20] // @10EA stack[-3] // } 10E7 5B JUMPDEST 10E8 50 POP 10E9 51 MLOAD 10EA 90 SWAP1 10EB 50 POP 10EC 80 DUP1 10ED 61 PUSH2 0x1122 10F0 57 *JUMPI // Stack delta = -2 // Outputs[1] { @10EA stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1122, if memory[stack[-2]:stack[-2] + 0x20] label_10F1: // Incoming jump from 0x10F0, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @10F4 memory[0x40:0x60] // @1118 memory[0x40:0x60] // @1121 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 10F1 60 PUSH1 0x40 10F3 80 DUP1 10F4 51 MLOAD 10F5 62 PUSH3 0x461bcd 10F9 60 PUSH1 0xe5 10FB 1B SHL 10FC 81 DUP2 10FD 52 MSTORE 10FE 60 PUSH1 0x20 1100 60 PUSH1 0x04 1102 82 DUP3 1103 01 ADD 1104 52 MSTORE 1105 60 PUSH1 0x02 1107 60 PUSH1 0x24 1109 82 DUP3 110A 01 ADD 110B 52 MSTORE 110C 61 PUSH2 0x1395 110F 60 PUSH1 0xf2 1111 1B SHL 1112 60 PUSH1 0x44 1114 82 DUP3 1115 01 ADD 1116 52 MSTORE 1117 90 SWAP1 1118 51 MLOAD 1119 90 SWAP1 111A 81 DUP2 111B 90 SWAP1 111C 03 SUB 111D 60 PUSH1 0x64 111F 01 ADD 1120 90 SWAP1 1121 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @10FD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1104 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @110B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @1116 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1395 << 0xf2 // @1121 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1122: // Incoming jump from 0x10F0, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @1149 stack[-2] // @114D memory[stack[-2]:stack[-2] + 0x20] // } 1122 5B JUMPDEST 1123 60 PUSH1 0x00 1125 61 PUSH2 0x1155 1128 7F PUSH32 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f 1149 84 DUP5 114A 60 PUSH1 0x00 114C 81 DUP2 114D 51 MLOAD 114E 81 DUP2 114F 10 LT 1150 61 PUSH2 0x07e4 1153 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1123 stack[0] = 0x00 // @1125 stack[1] = 0x1155 // @1128 stack[2] = 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f // @1149 stack[3] = stack[-2] // @114A stack[4] = 0x00 // } // Block ends with conditional call to 0x07e4, returns to 0x1155, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_1154: // Incoming jump from 0x1153, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 1154 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1154 assert(); } // Block terminates label_1155: // Incoming return from call to 0x07E4 at 0x1153 // Inputs[4] // { // @1156 stack[-2] // @1156 stack[-1] // @115E stack[-3] // @115F stack[-4] // } 1155 5B JUMPDEST 1156 90 SWAP1 1157 50 POP 1158 60 PUSH1 0x60 115A 61 PUSH2 0x1164 115D 82 DUP3 115E 84 DUP5 115F 86 DUP7 1160 61 PUSH2 0x208d 1163 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1156 stack[-2] = stack[-1] // @1158 stack[-1] = 0x60 // @115A stack[0] = 0x1164 // @115D stack[1] = stack[-1] // @115E stack[2] = stack[-3] // @115F stack[3] = stack[-4] // } // Block ends with call to 0x208d, returns to 0x1164 label_1164: // Incoming return from call to 0x208D at 0x1163 // Inputs[4] // { // @1165 stack[-2] // @1165 stack[-1] // @1167 stack[-9] // @116C memory[stack[-1]:stack[-1] + 0x20] // } 1164 5B JUMPDEST 1165 90 SWAP1 1166 50 POP 1167 87 DUP8 1168 81 DUP2 1169 60 PUSH1 0x01 116B 81 DUP2 116C 51 MLOAD 116D 81 DUP2 116E 10 LT 116F 61 PUSH2 0x1174 1172 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1165 stack[-2] = stack[-1] // @1167 stack[-1] = stack[-9] // @1168 stack[0] = stack[-1] // @1169 stack[1] = 0x01 // } // Block ends with conditional jump to 0x1174, if 0x01 < memory[stack[-1]:stack[-1] + 0x20] label_1173: // Incoming jump from 0x1172, if not 0x01 < memory[stack[-1]:stack[-1] + 0x20] 1173 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1173 assert(); } // Block terminates label_1174: // Incoming jump from 0x1172, if 0x01 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[4] // { // @1177 stack[-1] // @117B stack[-2] // @117C memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @117D stack[-3] // } 1174 5B JUMPDEST 1175 60 PUSH1 0x20 1177 02 MUL 1178 60 PUSH1 0x20 117A 01 ADD 117B 01 ADD 117C 51 MLOAD 117D 10 LT 117E 15 ISZERO 117F 61 PUSH2 0x11b4 1182 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x11b4, if !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] < stack[-3]) label_1183: // Incoming jump from 0x1182, if not !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] < stack[-3]) // Inputs[3] // { // @1186 memory[0x40:0x60] // @11AA memory[0x40:0x60] // @11B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1183 60 PUSH1 0x40 1185 80 DUP1 1186 51 MLOAD 1187 62 PUSH3 0x461bcd 118B 60 PUSH1 0xe5 118D 1B SHL 118E 81 DUP2 118F 52 MSTORE 1190 60 PUSH1 0x20 1192 60 PUSH1 0x04 1194 82 DUP3 1195 01 ADD 1196 52 MSTORE 1197 60 PUSH1 0x02 1199 60 PUSH1 0x24 119B 82 DUP3 119C 01 ADD 119D 52 MSTORE 119E 61 PUSH2 0x4941 11A1 60 PUSH1 0xf0 11A3 1B SHL 11A4 60 PUSH1 0x44 11A6 82 DUP3 11A7 01 ADD 11A8 52 MSTORE 11A9 90 SWAP1 11AA 51 MLOAD 11AB 90 SWAP1 11AC 81 DUP2 11AD 90 SWAP1 11AE 03 SUB 11AF 60 PUSH1 0x64 11B1 01 ADD 11B2 90 SWAP1 11B3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @118F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1196 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @119D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @11A8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4941 << 0xf0 // @11B3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_11B4: // Incoming jump from 0x1182, if !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] < stack[-3]) // Inputs[2] // { // @11B9 stack[-4] // @11BD memory[stack[-4]:stack[-4] + 0x20] // } 11B4 5B JUMPDEST 11B5 60 PUSH1 0x05 11B7 60 PUSH1 0x00 11B9 85 DUP6 11BA 60 PUSH1 0x00 11BC 81 DUP2 11BD 51 MLOAD 11BE 81 DUP2 11BF 10 LT 11C0 61 PUSH2 0x11c5 11C3 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @11B5 stack[0] = 0x05 // @11B7 stack[1] = 0x00 // @11B9 stack[2] = stack[-4] // @11BA stack[3] = 0x00 // } // Block ends with conditional jump to 0x11c5, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_11C4: // Incoming jump from 0x11C3, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 11C4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @11C4 assert(); } // Block terminates label_11C5: // Incoming jump from 0x11C3, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @11C8 stack[-1] // @11CB stack[-2] // @11D1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @11DB stack[-3] // @11DF stack[-4] // @11E8 memory[0x00:0x00 + 0x40 + stack[-3]] // @11E9 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // } 11C5 5B JUMPDEST 11C6 60 PUSH1 0x20 11C8 90 SWAP1 11C9 81 DUP2 11CA 02 MUL 11CB 91 SWAP2 11CC 90 SWAP1 11CD 91 SWAP2 11CE 01 ADD 11CF 81 DUP2 11D0 01 ADD 11D1 51 MLOAD 11D2 60 PUSH1 0x01 11D4 60 PUSH1 0x01 11D6 60 PUSH1 0xa0 11D8 1B SHL 11D9 03 SUB 11DA 16 AND 11DB 82 DUP3 11DC 52 MSTORE 11DD 81 DUP2 11DE 01 ADD 11DF 91 SWAP2 11E0 90 SWAP1 11E1 91 SWAP2 11E2 52 MSTORE 11E3 60 PUSH1 0x40 11E5 01 ADD 11E6 60 PUSH1 0x00 11E8 20 SHA3 11E9 54 SLOAD 11EA 60 PUSH1 0xff 11EC 16 AND 11ED 61 PUSH2 0x1253 11F0 57 *JUMPI // Stack delta = -4 // Outputs[2] // { // @11DC memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @11E2 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x1253, if 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] label_11F1: // Incoming jump from 0x11F0, if not 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // Inputs[2] // { // @11F4 stack[-4] // @11F8 memory[stack[-4]:stack[-4] + 0x20] // } 11F1 61 PUSH2 0x1200 11F4 84 DUP5 11F5 60 PUSH1 0x00 11F7 81 DUP2 11F8 51 MLOAD 11F9 81 DUP2 11FA 10 LT 11FB 61 PUSH2 0x0854 11FE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @11F1 stack[0] = 0x1200 // @11F4 stack[1] = stack[-4] // @11F5 stack[2] = 0x00 // } // Block ends with conditional call to 0x0854, returns to 0x1200, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_11FF: // Incoming jump from 0x11FE, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 11FF FE *ASSERT // Stack delta = +0 // Outputs[1] { @11FF assert(); } // Block terminates label_1200: // Incoming return from call to 0x0854 at 0x11FE // Inputs[2] // { // @1207 stack[-4] // @120B memory[stack[-4]:stack[-4] + 0x20] // } 1200 5B JUMPDEST 1201 60 PUSH1 0x01 1203 60 PUSH1 0x05 1205 60 PUSH1 0x00 1207 86 DUP7 1208 60 PUSH1 0x00 120A 81 DUP2 120B 51 MLOAD 120C 81 DUP2 120D 10 LT 120E 61 PUSH2 0x1213 1211 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1201 stack[0] = 0x01 // @1203 stack[1] = 0x05 // @1205 stack[2] = 0x00 // @1207 stack[3] = stack[-4] // @1208 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1213, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_1212: // Incoming jump from 0x1211, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 1212 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1212 assert(); } // Block terminates label_1213: // Incoming jump from 0x1211, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[8] // { // @1216 stack[-1] // @121A stack[-2] // @121B memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @122E stack[-3] // @1233 stack[-4] // @123B memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @1243 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @124B stack[-5] // } 1213 5B JUMPDEST 1214 60 PUSH1 0x20 1216 02 MUL 1217 60 PUSH1 0x20 1219 01 ADD 121A 01 ADD 121B 51 MLOAD 121C 60 PUSH1 0x01 121E 60 PUSH1 0x01 1220 60 PUSH1 0xa0 1222 1B SHL 1223 03 SUB 1224 16 AND 1225 60 PUSH1 0x01 1227 60 PUSH1 0x01 1229 60 PUSH1 0xa0 122B 1B SHL 122C 03 SUB 122D 16 AND 122E 81 DUP2 122F 52 MSTORE 1230 60 PUSH1 0x20 1232 01 ADD 1233 90 SWAP1 1234 81 DUP2 1235 52 MSTORE 1236 60 PUSH1 0x20 1238 01 ADD 1239 60 PUSH1 0x00 123B 20 SHA3 123C 60 PUSH1 0x00 123E 61 PUSH2 0x0100 1241 0A EXP 1242 81 DUP2 1243 54 SLOAD 1244 81 DUP2 1245 60 PUSH1 0xff 1247 02 MUL 1248 19 NOT 1249 16 AND 124A 90 SWAP1 124B 83 DUP4 124C 15 ISZERO 124D 15 ISZERO 124E 02 MUL 124F 17 OR 1250 90 SWAP1 1251 55 SSTORE 1252 50 POP // Stack delta = -5 // Outputs[3] // { // @122F memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1235 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @1251 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // } // Block continues label_1253: // Incoming jump from 0x1252 // Incoming jump from 0x11F0, if 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-3]])] // Inputs[2] // { // @1257 stack[-4] // @125B memory[stack[-4]:stack[-4] + 0x20] // } 1253 5B JUMPDEST 1254 61 PUSH2 0x1287 1257 84 DUP5 1258 60 PUSH1 0x00 125A 81 DUP2 125B 51 MLOAD 125C 81 DUP2 125D 10 LT 125E 61 PUSH2 0x1263 1261 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1254 stack[0] = 0x1287 // @1257 stack[1] = stack[-4] // @1258 stack[2] = 0x00 // } // Block ends with conditional call to 0x1263, returns to 0x1287, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_1262: // Incoming jump from 0x1261, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 1262 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1262 assert(); } // Block terminates label_1263: // Incoming call from 0x1261, returns to 0x1287, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[7] // { // @1266 stack[-1] // @126A stack[-2] // @126B memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @126C address(this) // @126D stack[-5] // @126E stack[-4] // @1272 memory[stack[-4]:stack[-4] + 0x20] // } 1263 5B JUMPDEST 1264 60 PUSH1 0x20 1266 02 MUL 1267 60 PUSH1 0x20 1269 01 ADD 126A 01 ADD 126B 51 MLOAD 126C 30 ADDRESS 126D 84 DUP5 126E 84 DUP5 126F 60 PUSH1 0x00 1271 81 DUP2 1272 51 MLOAD 1273 81 DUP2 1274 10 LT 1275 61 PUSH2 0x127a 1278 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @126B stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @126C stack[-1] = address(this) // @126D stack[0] = stack[-5] // @126E stack[1] = stack[-4] // @126F stack[2] = 0x00 // } // Block ends with conditional jump to 0x127a, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_1279: // Incoming jump from 0x1278, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 1279 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1279 assert(); } // Block terminates label_127A: // Incoming jump from 0x1278, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @127D stack[-1] // @1281 stack[-2] // @1282 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 127A 5B JUMPDEST 127B 60 PUSH1 0x20 127D 02 MUL 127E 60 PUSH1 0x20 1280 01 ADD 1281 01 ADD 1282 51 MLOAD 1283 61 PUSH2 0x1a17 1286 56 *JUMP // Stack delta = -1 // Outputs[1] { @1282 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1a17 label_1287: // Incoming return from call to 0x1263 at 0x1261 // Inputs[4] // { // @128B stack[-1] // @128C stack[-4] // @128D address(this) // @128E stack[-2] // } 1287 5B JUMPDEST 1288 61 PUSH2 0x1293 128B 81 DUP2 128C 85 DUP6 128D 30 ADDRESS 128E 85 DUP6 128F 61 PUSH2 0x21d9 1292 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1288 stack[0] = 0x1293 // @128B stack[1] = stack[-1] // @128C stack[2] = stack[-4] // @128D stack[3] = address(this) // @128E stack[4] = stack[-2] // } // Block ends with call to 0x21d9, returns to 0x1293 label_1293: // Incoming return from call to 0x21D9 at 0x1292 // Incoming return from call to 0x21D9 at 0x16D5 // Inputs[1] { @129C stack[-9] } 1293 5B JUMPDEST 1294 50 POP 1295 50 POP 1296 50 POP 1297 50 POP 1298 50 POP 1299 50 POP 129A 50 POP 129B 50 POP 129C 56 *JUMP // Stack delta = -9 // Block ends with unconditional jump to stack[-9] label_129D: // Incoming jump from 0x0470 // Inputs[2] // { // @12A0 storage[0x03] // @12AA msg.sender // } 129D 5B JUMPDEST 129E 60 PUSH1 0x03 12A0 54 SLOAD 12A1 60 PUSH1 0x01 12A3 60 PUSH1 0x01 12A5 60 PUSH1 0xa0 12A7 1B SHL 12A8 03 SUB 12A9 16 AND 12AA 33 CALLER 12AB 14 EQ 12AC 61 PUSH2 0x12e6 12AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x12e6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_12B0: // Incoming jump from 0x12AF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @12B3 memory[0x40:0x60] // @12DC memory[0x40:0x60] // @12E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 12B0 60 PUSH1 0x40 12B2 80 DUP1 12B3 51 MLOAD 12B4 62 PUSH3 0x461bcd 12B8 60 PUSH1 0xe5 12BA 1B SHL 12BB 81 DUP2 12BC 52 MSTORE 12BD 60 PUSH1 0x20 12BF 60 PUSH1 0x04 12C1 82 DUP3 12C2 01 ADD 12C3 52 MSTORE 12C4 60 PUSH1 0x07 12C6 60 PUSH1 0x24 12C8 82 DUP3 12C9 01 ADD 12CA 52 MSTORE 12CB 66 PUSH7 0x4f6e6c79204d65 12D3 60 PUSH1 0xc8 12D5 1B SHL 12D6 60 PUSH1 0x44 12D8 82 DUP3 12D9 01 ADD 12DA 52 MSTORE 12DB 90 SWAP1 12DC 51 MLOAD 12DD 90 SWAP1 12DE 81 DUP2 12DF 90 SWAP1 12E0 03 SUB 12E1 60 PUSH1 0x64 12E3 01 ADD 12E4 90 SWAP1 12E5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @12BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12C3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12CA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @12DA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79204d65 << 0xc8 // @12E5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_12E6: // Incoming jump from 0x12AF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[2] // { // @12EA stack[-2] // @12EB memory[stack[-2]:stack[-2] + 0x20] // } 12E6 5B JUMPDEST 12E7 60 PUSH1 0x00 12E9 5B JUMPDEST 12EA 82 DUP3 12EB 51 MLOAD 12EC 81 DUP2 12ED 10 LT 12EE 15 ISZERO 12EF 61 PUSH2 0x1378 12F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12E7 stack[0] = 0x00 } // Block ends with conditional jump to 0x1378, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_12F3: // Incoming jump from 0x12F2, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x12F2, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @12FE stack[-3] // @12FF stack[-1] // @1301 memory[stack[-3]:stack[-3] + 0x20] // } 12F3 60 PUSH1 0x00 12F5 60 PUSH1 0x01 12F7 60 PUSH1 0x01 12F9 60 PUSH1 0xa0 12FB 1B SHL 12FC 03 SUB 12FD 16 AND 12FE 83 DUP4 12FF 82 DUP3 1300 81 DUP2 1301 51 MLOAD 1302 81 DUP2 1303 10 LT 1304 61 PUSH2 0x1309 1307 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @12FD stack[0] = (0x01 << 0xa0) - 0x01 & 0x00 // @12FE stack[1] = stack[-3] // @12FF stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1309, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_1308: // Incoming jump from 0x1307, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 1308 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1308 assert(); } // Block terminates label_1309: // Incoming jump from 0x1307, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @130C stack[-1] // @1310 stack[-2] // @1311 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @131B stack[-3] // } 1309 5B JUMPDEST 130A 60 PUSH1 0x20 130C 02 MUL 130D 60 PUSH1 0x20 130F 01 ADD 1310 01 ADD 1311 51 MLOAD 1312 60 PUSH1 0x01 1314 60 PUSH1 0x01 1316 60 PUSH1 0xa0 1318 1B SHL 1319 03 SUB 131A 16 AND 131B 14 EQ 131C 61 PUSH2 0x1370 131F 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x1370, if (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3] label_1320: // Incoming jump from 0x131F, if not (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3] // Inputs[4] // { // @1320 stack[-2] // @1325 stack[-3] // @1326 stack[-1] // @1328 memory[stack[-3]:stack[-3] + 0x20] // } 1320 81 DUP2 1321 60 PUSH1 0x04 1323 60 PUSH1 0x00 1325 85 DUP6 1326 84 DUP5 1327 81 DUP2 1328 51 MLOAD 1329 81 DUP2 132A 10 LT 132B 61 PUSH2 0x1330 132E 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1320 stack[0] = stack[-2] // @1321 stack[1] = 0x04 // @1323 stack[2] = 0x00 // @1325 stack[3] = stack[-3] // @1326 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x1330, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_132F: // Incoming jump from 0x132E, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 132F FE *ASSERT // Stack delta = +0 // Outputs[1] { @132F assert(); } // Block terminates label_1330: // Incoming jump from 0x132E, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[8] // { // @1333 stack[-1] // @1337 stack[-2] // @1338 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @134B stack[-3] // @1350 stack[-4] // @1358 memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]] // @1360 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] // @1368 stack[-5] // } 1330 5B JUMPDEST 1331 60 PUSH1 0x20 1333 02 MUL 1334 60 PUSH1 0x20 1336 01 ADD 1337 01 ADD 1338 51 MLOAD 1339 60 PUSH1 0x01 133B 60 PUSH1 0x01 133D 60 PUSH1 0xa0 133F 1B SHL 1340 03 SUB 1341 16 AND 1342 60 PUSH1 0x01 1344 60 PUSH1 0x01 1346 60 PUSH1 0xa0 1348 1B SHL 1349 03 SUB 134A 16 AND 134B 81 DUP2 134C 52 MSTORE 134D 60 PUSH1 0x20 134F 01 ADD 1350 90 SWAP1 1351 81 DUP2 1352 52 MSTORE 1353 60 PUSH1 0x20 1355 01 ADD 1356 60 PUSH1 0x00 1358 20 SHA3 1359 60 PUSH1 0x00 135B 61 PUSH2 0x0100 135E 0A EXP 135F 81 DUP2 1360 54 SLOAD 1361 81 DUP2 1362 60 PUSH1 0xff 1364 02 MUL 1365 19 NOT 1366 16 AND 1367 90 SWAP1 1368 83 DUP4 1369 15 ISZERO 136A 15 ISZERO 136B 02 MUL 136C 17 OR 136D 90 SWAP1 136E 55 SSTORE 136F 50 POP // Stack delta = -5 // Outputs[3] // { // @134C memory[stack[-3]:stack[-3] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1352 memory[0x20 + stack[-3]:0x20 + stack[-3] + 0x20] = stack[-4] // @136E storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])] = !!stack[-5] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-3]])]) // } // Block continues label_1370: // Incoming jump from 0x131F, if (0x01 << 0xa0) - 0x01 & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] == stack[-3] // Incoming jump from 0x136F // Inputs[1] { @1373 stack[-1] } 1370 5B JUMPDEST 1371 60 PUSH1 0x01 1373 01 ADD 1374 61 PUSH2 0x12e9 1377 56 *JUMP // Stack delta = +0 // Outputs[1] { @1373 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x12e9 label_1378: // Incoming return from call to 0x18B4 at 0x1729 // Incoming jump from 0x12F2, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x12F2, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Incoming jump from 0x1EF3, if stack[-3] // Incoming jump from 0x1EF3, if stack[-3] // Inputs[1] { @137C stack[-4] } 1378 5B JUMPDEST 1379 50 POP 137A 50 POP 137B 50 POP 137C 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_137D: // Incoming call from 0x0485, returns to 0x02DB // Inputs[1] { @139F stack[-1] } 137D 5B JUMPDEST 137E 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 139F 81 DUP2 13A0 56 *JUMP // Stack delta = +1 // Outputs[1] { @137E stack[0] = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 } // Block ends with unconditional jump to stack[-1] label_13A1: // Incoming call from 0x049A, returns to 0x02DB // Inputs[1] { @13C3 stack[-1] } 13A1 5B JUMPDEST 13A2 7F PUSH32 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f 13C3 81 DUP2 13C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @13A2 stack[0] = 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f } // Block ends with unconditional jump to stack[-1] label_13C5: // Incoming jump from 0x04C9 // Inputs[3] // { // @13C6 msg.sender // @13D4 memory[0x00:0x40] // @13D5 storage[keccak256(memory[0x00:0x40])] // } 13C5 5B JUMPDEST 13C6 33 CALLER 13C7 60 PUSH1 0x00 13C9 90 SWAP1 13CA 81 DUP2 13CB 52 MSTORE 13CC 60 PUSH1 0x04 13CE 60 PUSH1 0x20 13D0 52 MSTORE 13D1 60 PUSH1 0x40 13D3 90 SWAP1 13D4 20 SHA3 13D5 54 SLOAD 13D6 60 PUSH1 0xff 13D8 16 AND 13D9 15 ISZERO 13DA 15 ISZERO 13DB 60 PUSH1 0x01 13DD 14 EQ 13DE 61 PUSH2 0x1419 13E1 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @13CB memory[0x00:0x20] = msg.sender // @13D0 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x1419, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) label_13E2: // Incoming jump from 0x13E1, if not 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @13E5 memory[0x40:0x60] // @140F memory[0x40:0x60] // @1418 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 13E2 60 PUSH1 0x40 13E4 80 DUP1 13E5 51 MLOAD 13E6 62 PUSH3 0x461bcd 13EA 60 PUSH1 0xe5 13EC 1B SHL 13ED 81 DUP2 13EE 52 MSTORE 13EF 60 PUSH1 0x20 13F1 60 PUSH1 0x04 13F3 82 DUP3 13F4 01 ADD 13F5 52 MSTORE 13F6 60 PUSH1 0x08 13F8 60 PUSH1 0x24 13FA 82 DUP3 13FB 01 ADD 13FC 52 MSTORE 13FD 67 PUSH8 0x13db9b1e48109bdd 1406 60 PUSH1 0xc2 1408 1B SHL 1409 60 PUSH1 0x44 140B 82 DUP3 140C 01 ADD 140D 52 MSTORE 140E 90 SWAP1 140F 51 MLOAD 1410 90 SWAP1 1411 81 DUP2 1412 90 SWAP1 1413 03 SUB 1414 60 PUSH1 0x64 1416 01 ADD 1417 90 SWAP1 1418 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @13EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13F5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13FC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @140D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x13db9b1e48109bdd << 0xc2 // @1418 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1419: // Incoming jump from 0x13E1, if 0x01 == !!(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @141A stack[-1] // @141B block.timestamp // } 1419 5B JUMPDEST 141A 80 DUP1 141B 42 TIMESTAMP 141C 81 DUP2 141D 10 LT 141E 15 ISZERO 141F 61 PUSH2 0x1454 1422 57 *JUMPI // Stack delta = +1 // Outputs[1] { @141A stack[0] = stack[-1] } // Block ends with conditional jump to 0x1454, if !(stack[-1] < block.timestamp) label_1423: // Incoming jump from 0x1422, if not !(stack[-1] < block.timestamp) // Inputs[3] // { // @1426 memory[0x40:0x60] // @144A memory[0x40:0x60] // @1453 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1423 60 PUSH1 0x40 1425 80 DUP1 1426 51 MLOAD 1427 62 PUSH3 0x461bcd 142B 60 PUSH1 0xe5 142D 1B SHL 142E 81 DUP2 142F 52 MSTORE 1430 60 PUSH1 0x20 1432 60 PUSH1 0x04 1434 82 DUP3 1435 01 ADD 1436 52 MSTORE 1437 60 PUSH1 0x02 1439 60 PUSH1 0x24 143B 82 DUP3 143C 01 ADD 143D 52 MSTORE 143E 61 PUSH2 0x5445 1441 60 PUSH1 0xf0 1443 1B SHL 1444 60 PUSH1 0x44 1446 82 DUP3 1447 01 ADD 1448 52 MSTORE 1449 90 SWAP1 144A 51 MLOAD 144B 90 SWAP1 144C 81 DUP2 144D 90 SWAP1 144E 03 SUB 144F 60 PUSH1 0x64 1451 01 ADD 1452 90 SWAP1 1453 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @142F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1436 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @143D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @1448 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5445 << 0xf0 // @1453 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1454: // Incoming jump from 0x1422, if !(stack[-1] < block.timestamp) // Inputs[4] // { // @1458 memory[0x40:0x60] // @146C msg.data.length // @146E msg.data[msg.data.length:msg.data.length + 0x40] // @149A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1454 5B JUMPDEST 1455 60 PUSH1 0x40 1457 80 DUP1 1458 51 MLOAD 1459 60 PUSH1 0x02 145B 80 DUP1 145C 82 DUP3 145D 52 MSTORE 145E 60 PUSH1 0x60 1460 80 DUP1 1461 83 DUP4 1462 01 ADD 1463 84 DUP5 1464 52 MSTORE 1465 92 SWAP3 1466 60 PUSH1 0x20 1468 83 DUP4 1469 01 ADD 146A 90 SWAP1 146B 80 DUP1 146C 36 CALLDATASIZE 146D 83 DUP4 146E 37 CALLDATACOPY 146F 01 ADD 1470 90 SWAP1 1471 50 POP 1472 50 POP 1473 90 SWAP1 1474 50 POP 1475 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1496 81 DUP2 1497 60 PUSH1 0x00 1499 81 DUP2 149A 51 MLOAD 149B 81 DUP2 149C 10 LT 149D 61 PUSH2 0x14a2 14A0 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @145D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x02 // @1464 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @146E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x40] = msg.data[msg.data.length:msg.data.length + 0x40] // @1473 stack[0] = memory[0x40:0x60] // @1475 stack[1] = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @1496 stack[2] = memory[0x40:0x60] // @1497 stack[3] = 0x00 // } // Block ends with conditional jump to 0x14a2, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_14A1: // Incoming jump from 0x14A0, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] 14A1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @14A1 assert(); } // Block terminates label_14A2: // Incoming jump from 0x14A0, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[10] // { // @14AB stack[-3] // @14B0 stack[-1] // @14B3 stack[-2] // @14BB storage[0x00] // @14BE storage[0x01] // @14CA stack[-6] // @14CB stack[-7] // @14D1 memory[0x40:0x60] // @14EF memory[0x40:0x60] // @14F6 address((0x01 << 0xa0) - 0x01 & storage[0x00]).code.length // } 14A2 5B JUMPDEST 14A3 60 PUSH1 0x01 14A5 60 PUSH1 0x01 14A7 60 PUSH1 0xa0 14A9 1B SHL 14AA 03 SUB 14AB 92 SWAP3 14AC 83 DUP4 14AD 16 AND 14AE 60 PUSH1 0x20 14B0 91 SWAP2 14B1 82 DUP3 14B2 02 MUL 14B3 92 SWAP3 14B4 90 SWAP1 14B5 92 SWAP3 14B6 01 ADD 14B7 01 ADD 14B8 52 MSTORE 14B9 60 PUSH1 0x00 14BB 54 SLOAD 14BC 60 PUSH1 0x01 14BE 54 SLOAD 14BF 91 SWAP2 14C0 16 AND 14C1 90 SWAP1 14C2 63 PUSH4 0x67ccdf38 14C7 90 SWAP1 14C8 60 PUSH1 0x02 14CA 86 DUP7 14CB 88 DUP9 14CC 03 SUB 14CD 04 DIV 14CE 03 SUB 14CF 60 PUSH1 0x40 14D1 51 MLOAD 14D2 82 DUP3 14D3 63 PUSH4 0xffffffff 14D8 16 AND 14D9 60 PUSH1 0xe0 14DB 1B SHL 14DC 81 DUP2 14DD 52 MSTORE 14DE 60 PUSH1 0x04 14E0 01 ADD 14E1 80 DUP1 14E2 82 DUP3 14E3 81 DUP2 14E4 52 MSTORE 14E5 60 PUSH1 0x20 14E7 01 ADD 14E8 91 SWAP2 14E9 50 POP 14EA 50 POP 14EB 60 PUSH1 0x20 14ED 60 PUSH1 0x40 14EF 51 MLOAD 14F0 80 DUP1 14F1 83 DUP4 14F2 03 SUB 14F3 81 DUP2 14F4 86 DUP7 14F5 80 DUP1 14F6 3B EXTCODESIZE 14F7 15 ISZERO 14F8 80 DUP1 14F9 15 ISZERO 14FA 61 PUSH2 0x1502 14FD 57 *JUMPI // Stack delta = +6 // Outputs[12] // { // @14B8 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @14C1 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[0x00] // @14C7 stack[-2] = 0x67ccdf38 // @14DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x67ccdf38) << 0xe0 // @14E4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-7] - stack[-6] / 0x02 - storage[0x01] // @14E8 stack[-1] = 0x20 + 0x04 + memory[0x40:0x60] // @14EB stack[0] = 0x20 // @14EF stack[1] = memory[0x40:0x60] // @14F2 stack[2] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @14F3 stack[3] = memory[0x40:0x60] // @14F4 stack[4] = (0x01 << 0xa0) - 0x01 & storage[0x00] // @14F7 stack[5] = !address((0x01 << 0xa0) - 0x01 & storage[0x00]).code.length // } // Block ends with conditional jump to 0x1502, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00]).code.length label_14FE: // Incoming jump from 0x14FD, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00]).code.length // Inputs[1] { @1501 memory[0x00:0x00] } 14FE 60 PUSH1 0x00 1500 80 DUP1 1501 FD *REVERT // Stack delta = +0 // Outputs[1] { @1501 revert(memory[0x00:0x00]); } // Block terminates label_1502: // Incoming jump from 0x14FD, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00]).code.length // Inputs[8] // { // @1504 msg.gas // @1505 stack[-4] // @1505 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1505 stack[-2] // @1505 stack[-3] // @1505 memory[stack[-3]:stack[-3] + stack[-4]] // @1505 stack[-6] // @1505 stack[-5] // } 1502 5B JUMPDEST 1503 50 POP 1504 5A GAS 1505 FA STATICCALL 1506 15 ISZERO 1507 80 DUP1 1508 15 ISZERO 1509 61 PUSH2 0x1516 150C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1505 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1506 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1516, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_150D: // Incoming jump from 0x150C, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @150D returndata.length // @1511 returndata[0x00:0x00 + returndata.length] // @1512 returndata.length // @1515 memory[0x00:0x00 + returndata.length] // } 150D 3D RETURNDATASIZE 150E 60 PUSH1 0x00 1510 80 DUP1 1511 3E RETURNDATACOPY 1512 3D RETURNDATASIZE 1513 60 PUSH1 0x00 1515 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1511 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1515 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1516: // Incoming jump from 0x150C, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @151D memory[0x40:0x60] // @151E returndata.length // } 1516 5B JUMPDEST 1517 50 POP 1518 50 POP 1519 50 POP 151A 50 POP 151B 60 PUSH1 0x40 151D 51 MLOAD 151E 3D RETURNDATASIZE 151F 60 PUSH1 0x20 1521 81 DUP2 1522 10 LT 1523 15 ISZERO 1524 61 PUSH2 0x152c 1527 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @151D stack[-4] = memory[0x40:0x60] // @151E stack[-3] = returndata.length // } // Block ends with conditional jump to 0x152c, if !(returndata.length < 0x20) label_1528: // Incoming jump from 0x1527, if not !(returndata.length < 0x20) // Inputs[1] { @152B memory[0x00:0x00] } 1528 60 PUSH1 0x00 152A 80 DUP1 152B FD *REVERT // Stack delta = +0 // Outputs[1] { @152B revert(memory[0x00:0x00]); } // Block terminates label_152C: // Incoming jump from 0x1527, if !(returndata.length < 0x20) // Inputs[4] // { // @152E stack[-2] // @152E memory[stack[-2]:stack[-2] + 0x20] // @152F stack[-3] // @1530 memory[stack[-3]:stack[-3] + 0x20] // } 152C 5B JUMPDEST 152D 50 POP 152E 51 MLOAD 152F 81 DUP2 1530 51 MLOAD 1531 82 DUP3 1532 90 SWAP1 1533 60 PUSH1 0x01 1535 90 SWAP1 1536 81 DUP2 1537 10 LT 1538 61 PUSH2 0x153d 153B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @152E stack[-2] = memory[stack[-2]:stack[-2] + 0x20] // @1532 stack[-1] = stack[-3] // @1535 stack[0] = 0x01 // } // Block ends with conditional jump to 0x153d, if 0x01 < memory[stack[-3]:stack[-3] + 0x20] label_153C: // Incoming jump from 0x153B, if not 0x01 < memory[stack[-3]:stack[-3] + 0x20] 153C FE *ASSERT // Stack delta = +0 // Outputs[1] { @153C assert(); } // Block terminates label_153D: // Incoming jump from 0x153B, if 0x01 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @1540 stack[-1] // @1544 stack[-2] // @1545 stack[-3] // @1584 stack[-4] // @1588 memory[stack[-4]:stack[-4] + 0x20] // } 153D 5B JUMPDEST 153E 60 PUSH1 0x20 1540 02 MUL 1541 60 PUSH1 0x20 1543 01 ADD 1544 01 ADD 1545 90 SWAP1 1546 60 PUSH1 0x01 1548 60 PUSH1 0x01 154A 60 PUSH1 0xa0 154C 1B SHL 154D 03 SUB 154E 16 AND 154F 90 SWAP1 1550 81 DUP2 1551 60 PUSH1 0x01 1553 60 PUSH1 0x01 1555 60 PUSH1 0xa0 1557 1B SHL 1558 03 SUB 1559 16 AND 155A 81 DUP2 155B 52 MSTORE 155C 50 POP 155D 50 POP 155E 60 PUSH1 0x00 1560 61 PUSH2 0x15a5 1563 7F PUSH32 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f 1584 83 DUP4 1585 60 PUSH1 0x00 1587 81 DUP2 1588 51 MLOAD 1589 81 DUP2 158A 10 LT 158B 61 PUSH2 0x1590 158E 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @155B memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-3] // @155E stack[-3] = 0x00 // @1560 stack[-2] = 0x15a5 // @1563 stack[-1] = 0x0000000000000000000000005c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f // @1584 stack[0] = stack[-4] // @1585 stack[1] = 0x00 // } // Block ends with conditional call to 0x1590, returns to 0x15A5, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] label_158F: // Incoming jump from 0x158E, if not 0x00 < memory[stack[-4]:stack[-4] + 0x20] 158F FE *ASSERT // Stack delta = +0 // Outputs[1] { @158F assert(); } // Block terminates label_1590: // Incoming call from 0x158E, returns to 0x15A5, if 0x00 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @1593 stack[-1] // @1597 stack[-2] // @1598 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1599 stack[-6] // @159D memory[stack[-6]:stack[-6] + 0x20] // } 1590 5B JUMPDEST 1591 60 PUSH1 0x20 1593 02 MUL 1594 60 PUSH1 0x20 1596 01 ADD 1597 01 ADD 1598 51 MLOAD 1599 84 DUP5 159A 60 PUSH1 0x01 159C 81 DUP2 159D 51 MLOAD 159E 81 DUP2 159F 10 LT 15A0 61 PUSH2 0x07f9 15A3 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1598 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1599 stack[-1] = stack[-6] // @159A stack[0] = 0x01 // } // Block ends with conditional jump to 0x07f9, if 0x01 < memory[stack[-6]:stack[-6] + 0x20] label_15A4: // Incoming jump from 0x15A3, if not 0x01 < memory[stack[-6]:stack[-6] + 0x20] 15A4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @15A4 assert(); } // Block terminates label_15A5: // Incoming return from call to 0x1590 at 0x158E // Inputs[4] // { // @15A6 stack[-1] // @15A6 stack[-2] // @15AE stack[-8] // @15AF stack[-3] // } 15A5 5B JUMPDEST 15A6 90 SWAP1 15A7 50 POP 15A8 60 PUSH1 0x60 15AA 61 PUSH2 0x15b4 15AD 82 DUP3 15AE 89 DUP10 15AF 85 DUP6 15B0 61 PUSH2 0x208d 15B3 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @15A6 stack[-2] = stack[-1] // @15A8 stack[-1] = 0x60 // @15AA stack[0] = 0x15b4 // @15AD stack[1] = stack[-1] // @15AE stack[2] = stack[-8] // @15AF stack[3] = stack[-3] // } // Block ends with call to 0x208d, returns to 0x15B4 label_15B4: // Incoming return from call to 0x208D at 0x15B3 // Inputs[4] // { // @15B5 stack[-2] // @15B5 stack[-1] // @15B7 stack[-8] // @15BC memory[stack[-1]:stack[-1] + 0x20] // } 15B4 5B JUMPDEST 15B5 90 SWAP1 15B6 50 POP 15B7 86 DUP7 15B8 81 DUP2 15B9 60 PUSH1 0x01 15BB 81 DUP2 15BC 51 MLOAD 15BD 81 DUP2 15BE 10 LT 15BF 61 PUSH2 0x15c4 15C2 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @15B5 stack[-2] = stack[-1] // @15B7 stack[-1] = stack[-8] // @15B8 stack[0] = stack[-1] // @15B9 stack[1] = 0x01 // } // Block ends with conditional jump to 0x15c4, if 0x01 < memory[stack[-1]:stack[-1] + 0x20] label_15C3: // Incoming jump from 0x15C2, if not 0x01 < memory[stack[-1]:stack[-1] + 0x20] 15C3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @15C3 assert(); } // Block terminates label_15C4: // Incoming jump from 0x15C2, if 0x01 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[4] // { // @15C7 stack[-1] // @15CB stack[-2] // @15CC memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @15CD stack[-3] // } 15C4 5B JUMPDEST 15C5 60 PUSH1 0x20 15C7 02 MUL 15C8 60 PUSH1 0x20 15CA 01 ADD 15CB 01 ADD 15CC 51 MLOAD 15CD 10 LT 15CE 15 ISZERO 15CF 61 PUSH2 0x1604 15D2 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x1604, if !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] < stack[-3]) label_15D3: // Incoming jump from 0x15D2, if not !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] < stack[-3]) // Inputs[3] // { // @15D6 memory[0x40:0x60] // @15FA memory[0x40:0x60] // @1603 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 15D3 60 PUSH1 0x40 15D5 80 DUP1 15D6 51 MLOAD 15D7 62 PUSH3 0x461bcd 15DB 60 PUSH1 0xe5 15DD 1B SHL 15DE 81 DUP2 15DF 52 MSTORE 15E0 60 PUSH1 0x20 15E2 60 PUSH1 0x04 15E4 82 DUP3 15E5 01 ADD 15E6 52 MSTORE 15E7 60 PUSH1 0x02 15E9 60 PUSH1 0x24 15EB 82 DUP3 15EC 01 ADD 15ED 52 MSTORE 15EE 61 PUSH2 0x4941 15F1 60 PUSH1 0xf0 15F3 1B SHL 15F4 60 PUSH1 0x44 15F6 82 DUP3 15F7 01 ADD 15F8 52 MSTORE 15F9 90 SWAP1 15FA 51 MLOAD 15FB 90 SWAP1 15FC 81 DUP2 15FD 90 SWAP1 15FE 03 SUB 15FF 60 PUSH1 0x64 1601 01 ADD 1602 90 SWAP1 1603 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @15DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15E6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15ED memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @15F8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4941 << 0xf0 // @1603 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1604: // Incoming jump from 0x15D2, if !(memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] < stack[-3]) // Inputs[3] // { // @1634 stack[-2] // @1635 stack[-1] // @1639 memory[stack[-1]:stack[-1] + 0x20] // } 1604 5B JUMPDEST 1605 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1626 60 PUSH1 0x01 1628 60 PUSH1 0x01 162A 60 PUSH1 0xa0 162C 1B SHL 162D 03 SUB 162E 16 AND 162F 63 PUSH4 0xa9059cbb 1634 83 DUP4 1635 83 DUP4 1636 60 PUSH1 0x00 1638 81 DUP2 1639 51 MLOAD 163A 81 DUP2 163B 10 LT 163C 61 PUSH2 0x1641 163F 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @162E stack[0] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @162F stack[1] = 0xa9059cbb // @1634 stack[2] = stack[-2] // @1635 stack[3] = stack[-1] // @1636 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1641, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_1640: // Incoming jump from 0x163F, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] 1640 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1640 assert(); } // Block terminates label_1641: // Incoming jump from 0x163F, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[9] // { // @1644 stack[-1] // @1648 stack[-2] // @1649 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @164C memory[0x40:0x60] // @164D stack[-4] // @165D stack[-3] // @1683 memory[0x40:0x60] // @168A stack[-5] // @168C address(stack[-5]).code.length // } 1641 5B JUMPDEST 1642 60 PUSH1 0x20 1644 02 MUL 1645 60 PUSH1 0x20 1647 01 ADD 1648 01 ADD 1649 51 MLOAD 164A 60 PUSH1 0x40 164C 51 MLOAD 164D 83 DUP4 164E 63 PUSH4 0xffffffff 1653 16 AND 1654 60 PUSH1 0xe0 1656 1B SHL 1657 81 DUP2 1658 52 MSTORE 1659 60 PUSH1 0x04 165B 01 ADD 165C 80 DUP1 165D 83 DUP4 165E 60 PUSH1 0x01 1660 60 PUSH1 0x01 1662 60 PUSH1 0xa0 1664 1B SHL 1665 03 SUB 1666 16 AND 1667 60 PUSH1 0x01 1669 60 PUSH1 0x01 166B 60 PUSH1 0xa0 166D 1B SHL 166E 03 SUB 166F 16 AND 1670 81 DUP2 1671 52 MSTORE 1672 60 PUSH1 0x20 1674 01 ADD 1675 82 DUP3 1676 81 DUP2 1677 52 MSTORE 1678 60 PUSH1 0x20 167A 01 ADD 167B 92 SWAP3 167C 50 POP 167D 50 POP 167E 50 POP 167F 60 PUSH1 0x20 1681 60 PUSH1 0x40 1683 51 MLOAD 1684 80 DUP1 1685 83 DUP4 1686 03 SUB 1687 81 DUP2 1688 60 PUSH1 0x00 168A 87 DUP8 168B 80 DUP1 168C 3B EXTCODESIZE 168D 15 ISZERO 168E 80 DUP1 168F 15 ISZERO 1690 61 PUSH2 0x1698 1693 57 *JUMPI // Stack delta = +5 // Outputs[11] // { // @1658 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-4]) << 0xe0 // @1671 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-3] // @1677 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @167B stack[-3] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @167F stack[-2] = 0x20 // @1683 stack[-1] = memory[0x40:0x60] // @1686 stack[0] = (0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1687 stack[1] = memory[0x40:0x60] // @1688 stack[2] = 0x00 // @168A stack[3] = stack[-5] // @168D stack[4] = !address(stack[-5]).code.length // } // Block ends with conditional jump to 0x1698, if !!address(stack[-5]).code.length label_1694: // Incoming jump from 0x1693, if not !!address(stack[-5]).code.length // Inputs[1] { @1697 memory[0x00:0x00] } 1694 60 PUSH1 0x00 1696 80 DUP1 1697 FD *REVERT // Stack delta = +0 // Outputs[1] { @1697 revert(memory[0x00:0x00]); } // Block terminates label_1698: // Incoming jump from 0x1693, if !!address(stack[-5]).code.length // Inputs[9] // { // @169A msg.gas // @169B stack[-2] // @169B stack[-5] // @169B address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @169B stack[-3] // @169B stack[-7] // @169B stack[-4] // @169B memory[stack[-4]:stack[-4] + stack[-5]] // @169B stack[-6] // } 1698 5B JUMPDEST 1699 50 POP 169A 5A GAS 169B F1 CALL 169C 15 ISZERO 169D 80 DUP1 169E 15 ISZERO 169F 61 PUSH2 0x16ac 16A2 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @169B memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @169C 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 0x16ac, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_16A3: // Incoming jump from 0x16A2, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @16A3 returndata.length // @16A7 returndata[0x00:0x00 + returndata.length] // @16A8 returndata.length // @16AB memory[0x00:0x00 + returndata.length] // } 16A3 3D RETURNDATASIZE 16A4 60 PUSH1 0x00 16A6 80 DUP1 16A7 3E RETURNDATACOPY 16A8 3D RETURNDATASIZE 16A9 60 PUSH1 0x00 16AB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16A7 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @16AB revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_16AC: // Incoming jump from 0x16A2, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @16B3 memory[0x40:0x60] // @16B4 returndata.length // } 16AC 5B JUMPDEST 16AD 50 POP 16AE 50 POP 16AF 50 POP 16B0 50 POP 16B1 60 PUSH1 0x40 16B3 51 MLOAD 16B4 3D RETURNDATASIZE 16B5 60 PUSH1 0x20 16B7 81 DUP2 16B8 10 LT 16B9 15 ISZERO 16BA 61 PUSH2 0x16c2 16BD 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @16B3 stack[-4] = memory[0x40:0x60] // @16B4 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x16c2, if !(returndata.length < 0x20) label_16BE: // Incoming jump from 0x16BD, if not !(returndata.length < 0x20) // Inputs[1] { @16C1 memory[0x00:0x00] } 16BE 60 PUSH1 0x00 16C0 80 DUP1 16C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @16C1 revert(memory[0x00:0x00]); } // Block terminates label_16C2: // Incoming jump from 0x16BD, if !(returndata.length < 0x20) // Inputs[2] // { // @16C4 stack[-2] // @16C4 memory[stack[-2]:stack[-2] + 0x20] // } 16C2 5B JUMPDEST 16C3 50 POP 16C4 51 MLOAD 16C5 61 PUSH2 0x16ca 16C8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x16ca, if memory[stack[-2]:stack[-2] + 0x20] label_16C9: // Incoming jump from 0x16C8, if not memory[stack[-2]:stack[-2] + 0x20] 16C9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @16C9 assert(); } // Block terminates label_16CA: // Incoming jump from 0x16C8, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @16CE stack[-1] // @16CF stack[-3] // @16D0 address(this) // @16D1 stack[-2] // } 16CA 5B JUMPDEST 16CB 61 PUSH2 0x1293 16CE 81 DUP2 16CF 84 DUP5 16D0 30 ADDRESS 16D1 85 DUP6 16D2 61 PUSH2 0x21d9 16D5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @16CB stack[0] = 0x1293 // @16CE stack[1] = stack[-1] // @16CF stack[2] = stack[-3] // @16D0 stack[3] = address(this) // @16D1 stack[4] = stack[-2] // } // Block ends with call to 0x21d9, returns to 0x1293 label_16D6: // Incoming jump from 0x050C // Inputs[2] // { // @16D9 storage[0x03] // @16E3 msg.sender // } 16D6 5B JUMPDEST 16D7 60 PUSH1 0x03 16D9 54 SLOAD 16DA 60 PUSH1 0x01 16DC 60 PUSH1 0x01 16DE 60 PUSH1 0xa0 16E0 1B SHL 16E1 03 SUB 16E2 16 AND 16E3 33 CALLER 16E4 14 EQ 16E5 61 PUSH2 0x171f 16E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x171f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_16E9: // Incoming jump from 0x16E8, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @16EC memory[0x40:0x60] // @1715 memory[0x40:0x60] // @171E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 16E9 60 PUSH1 0x40 16EB 80 DUP1 16EC 51 MLOAD 16ED 62 PUSH3 0x461bcd 16F1 60 PUSH1 0xe5 16F3 1B SHL 16F4 81 DUP2 16F5 52 MSTORE 16F6 60 PUSH1 0x20 16F8 60 PUSH1 0x04 16FA 82 DUP3 16FB 01 ADD 16FC 52 MSTORE 16FD 60 PUSH1 0x07 16FF 60 PUSH1 0x24 1701 82 DUP3 1702 01 ADD 1703 52 MSTORE 1704 66 PUSH7 0x4f6e6c79204d65 170C 60 PUSH1 0xc8 170E 1B SHL 170F 60 PUSH1 0x44 1711 82 DUP3 1712 01 ADD 1713 52 MSTORE 1714 90 SWAP1 1715 51 MLOAD 1716 90 SWAP1 1717 81 DUP2 1718 90 SWAP1 1719 03 SUB 171A 60 PUSH1 0x64 171C 01 ADD 171D 90 SWAP1 171E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @16F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16FC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1703 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @1713 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79204d65 << 0xc8 // @171E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_171F: // Incoming jump from 0x16E8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @1723 stack[-3] // @1724 stack[-2] // @1725 stack[-1] // } 171F 5B JUMPDEST 1720 61 PUSH2 0x1378 1723 83 DUP4 1724 83 DUP4 1725 83 DUP4 1726 61 PUSH2 0x18b4 1729 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1720 stack[0] = 0x1378 // @1723 stack[1] = stack[-3] // @1724 stack[2] = stack[-2] // @1725 stack[3] = stack[-1] // } // Block ends with call to 0x18b4, returns to 0x1378 label_172A: // Incoming jump from 0x0536 // Inputs[2] // { // @172D storage[0x03] // @1737 msg.sender // } 172A 5B JUMPDEST 172B 60 PUSH1 0x03 172D 54 SLOAD 172E 60 PUSH1 0x01 1730 60 PUSH1 0x01 1732 60 PUSH1 0xa0 1734 1B SHL 1735 03 SUB 1736 16 AND 1737 33 CALLER 1738 14 EQ 1739 61 PUSH2 0x1773 173C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1773, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_173D: // Incoming jump from 0x173C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @1740 memory[0x40:0x60] // @1769 memory[0x40:0x60] // @1772 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 173D 60 PUSH1 0x40 173F 80 DUP1 1740 51 MLOAD 1741 62 PUSH3 0x461bcd 1745 60 PUSH1 0xe5 1747 1B SHL 1748 81 DUP2 1749 52 MSTORE 174A 60 PUSH1 0x20 174C 60 PUSH1 0x04 174E 82 DUP3 174F 01 ADD 1750 52 MSTORE 1751 60 PUSH1 0x07 1753 60 PUSH1 0x24 1755 82 DUP3 1756 01 ADD 1757 52 MSTORE 1758 66 PUSH7 0x4f6e6c79204d65 1760 60 PUSH1 0xc8 1762 1B SHL 1763 60 PUSH1 0x44 1765 82 DUP3 1766 01 ADD 1767 52 MSTORE 1768 90 SWAP1 1769 51 MLOAD 176A 90 SWAP1 176B 81 DUP2 176C 90 SWAP1 176D 03 SUB 176E 60 PUSH1 0x64 1770 01 ADD 1771 90 SWAP1 1772 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1749 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1750 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1757 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @1767 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79204d65 << 0xc8 // @1772 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1773: // Incoming jump from 0x173C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[4] // { // @17A3 stack[-1] // @17A6 memory[0x40:0x60] // @17C4 memory[0x40:0x60] // @17CD address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 1773 5B JUMPDEST 1774 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 1795 60 PUSH1 0x01 1797 60 PUSH1 0x01 1799 60 PUSH1 0xa0 179B 1B SHL 179C 03 SUB 179D 16 AND 179E 63 PUSH4 0x2e1a7d4d 17A3 82 DUP3 17A4 60 PUSH1 0x40 17A6 51 MLOAD 17A7 82 DUP3 17A8 63 PUSH4 0xffffffff 17AD 16 AND 17AE 60 PUSH1 0xe0 17B0 1B SHL 17B1 81 DUP2 17B2 52 MSTORE 17B3 60 PUSH1 0x04 17B5 01 ADD 17B6 80 DUP1 17B7 82 DUP3 17B8 81 DUP2 17B9 52 MSTORE 17BA 60 PUSH1 0x20 17BC 01 ADD 17BD 91 SWAP2 17BE 50 POP 17BF 50 POP 17C0 60 PUSH1 0x00 17C2 60 PUSH1 0x40 17C4 51 MLOAD 17C5 80 DUP1 17C6 83 DUP4 17C7 03 SUB 17C8 81 DUP2 17C9 60 PUSH1 0x00 17CB 87 DUP8 17CC 80 DUP1 17CD 3B EXTCODESIZE 17CE 15 ISZERO 17CF 80 DUP1 17D0 15 ISZERO 17D1 61 PUSH2 0x17d9 17D4 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @179D stack[0] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @179E stack[1] = 0x2e1a7d4d // @17B2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2e1a7d4d) << 0xe0 // @17B9 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @17BD stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @17C0 stack[3] = 0x00 // @17C4 stack[4] = memory[0x40:0x60] // @17C7 stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @17C8 stack[6] = memory[0x40:0x60] // @17C9 stack[7] = 0x00 // @17CB stack[8] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @17CE stack[9] = !address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x17d9, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_17D5: // Incoming jump from 0x17D4, if not !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @17D8 memory[0x00:0x00] } 17D5 60 PUSH1 0x00 17D7 80 DUP1 17D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @17D8 revert(memory[0x00:0x00]); } // Block terminates label_17D9: // Incoming jump from 0x17D4, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @17DB msg.gas // @17DC address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @17DC memory[stack[-4]:stack[-4] + stack[-5]] // @17DC stack[-3] // @17DC stack[-6] // @17DC stack[-5] // @17DC stack[-7] // @17DC stack[-4] // @17DC stack[-2] // } 17D9 5B JUMPDEST 17DA 50 POP 17DB 5A GAS 17DC F1 CALL 17DD 15 ISZERO 17DE 80 DUP1 17DF 15 ISZERO 17E0 61 PUSH2 0x17ed 17E3 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @17DC memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @17DD 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 0x17ed, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_17E4: // Incoming jump from 0x17E3, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @17E4 returndata.length // @17E8 returndata[0x00:0x00 + returndata.length] // @17E9 returndata.length // @17EC memory[0x00:0x00 + returndata.length] // } 17E4 3D RETURNDATASIZE 17E5 60 PUSH1 0x00 17E7 80 DUP1 17E8 3E RETURNDATACOPY 17E9 3D RETURNDATASIZE 17EA 60 PUSH1 0x00 17EC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @17E8 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @17EC revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_17ED: // Incoming jump from 0x2040, if stack[-1] // Incoming jump from 0x17E3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Incoming jump from 0x19CA, if stack[-1] // Inputs[1] { @17F3 stack[-6] } 17ED 5B JUMPDEST 17EE 50 POP 17EF 50 POP 17F0 50 POP 17F1 50 POP 17F2 50 POP 17F3 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_17F4: // Incoming jump from 0x0805 // Inputs[2] // { // @17FD stack[-2] // @17FE stack[-1] // } 17F4 5B JUMPDEST 17F5 60 PUSH1 0x00 17F7 80 DUP1 17F8 60 PUSH1 0x00 17FA 61 PUSH2 0x1803 17FD 85 DUP6 17FE 85 DUP6 17FF 61 PUSH2 0x236c 1802 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @17F5 stack[0] = 0x00 // @17F7 stack[1] = 0x00 // @17F8 stack[2] = 0x00 // @17FA stack[3] = 0x1803 // @17FD stack[4] = stack[-2] // @17FE stack[5] = stack[-1] // } // Block ends with call to 0x236c, returns to 0x1803 label_1803: // Incoming return from call to 0x236C at 0x1802 // Inputs[12] // { // @1807 memory[0x40:0x60] // @1818 stack[-2] // @1826 stack[-1] // @1831 memory[0x40:0x60] // @1841 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1845 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1854 stack[-8] // @1893 memory[0x40:0x60] // @18A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @18A9 stack[-3] // @18AB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @18AC stack[-9] // } 1803 5B JUMPDEST 1804 60 PUSH1 0x40 1806 80 DUP1 1807 51 MLOAD 1808 6B PUSH12 0xffffffffffffffffffffffff 1815 19 NOT 1816 60 PUSH1 0x60 1818 94 SWAP5 1819 85 DUP6 181A 1B SHL 181B 81 DUP2 181C 16 AND 181D 60 PUSH1 0x20 181F 80 DUP1 1820 84 DUP5 1821 01 ADD 1822 91 SWAP2 1823 90 SWAP1 1824 91 SWAP2 1825 52 MSTORE 1826 93 SWAP4 1827 85 DUP6 1828 1B SHL 1829 81 DUP2 182A 16 AND 182B 60 PUSH1 0x34 182D 83 DUP4 182E 01 ADD 182F 52 MSTORE 1830 82 DUP3 1831 51 MLOAD 1832 60 PUSH1 0x28 1834 81 DUP2 1835 84 DUP5 1836 03 SUB 1837 01 ADD 1838 81 DUP2 1839 52 MSTORE 183A 60 PUSH1 0x48 183C 83 DUP4 183D 01 ADD 183E 84 DUP5 183F 52 MSTORE 1840 80 DUP1 1841 51 MLOAD 1842 90 SWAP1 1843 85 DUP6 1844 01 ADD 1845 20 SHA3 1846 60 PUSH1 0x01 1848 60 PUSH1 0x01 184A 60 PUSH1 0xf8 184C 1B SHL 184D 03 SUB 184E 19 NOT 184F 60 PUSH1 0x68 1851 84 DUP5 1852 01 ADD 1853 52 MSTORE 1854 9A SWAP11 1855 90 SWAP1 1856 94 SWAP5 1857 1B SHL 1858 90 SWAP1 1859 93 SWAP4 185A 16 AND 185B 60 PUSH1 0x69 185D 84 DUP5 185E 01 ADD 185F 52 MSTORE 1860 60 PUSH1 0x7d 1862 83 DUP4 1863 01 ADD 1864 98 SWAP9 1865 90 SWAP1 1866 98 SWAP9 1867 52 MSTORE 1868 7F PUSH32 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f 1889 60 PUSH1 0x9d 188B 80 DUP1 188C 84 DUP5 188D 01 ADD 188E 91 SWAP2 188F 90 SWAP1 1890 91 SWAP2 1891 52 MSTORE 1892 88 DUP9 1893 51 MLOAD 1894 80 DUP1 1895 84 DUP5 1896 03 SUB 1897 90 SWAP1 1898 91 SWAP2 1899 01 ADD 189A 81 DUP2 189B 52 MSTORE 189C 60 PUSH1 0xbd 189E 90 SWAP1 189F 92 SWAP3 18A0 01 ADD 18A1 90 SWAP1 18A2 97 SWAP8 18A3 52 MSTORE 18A4 80 DUP1 18A5 51 MLOAD 18A6 96 SWAP7 18A7 01 ADD 18A8 95 SWAP6 18A9 90 SWAP1 18AA 95 SWAP6 18AB 20 SHA3 18AC 95 SWAP6 18AD 94 SWAP5 18AE 50 POP 18AF 50 POP 18B0 50 POP 18B1 50 POP 18B2 50 POP 18B3 56 *JUMP // Stack delta = -8 // Outputs[11] // { // @1825 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = ~0xffffffffffffffffffffffff & (stack[-2] << 0x60) // @182F memory[memory[0x40:0x60] + 0x34:memory[0x40:0x60] + 0x34 + 0x20] = ~0xffffffffffffffffffffffff & (stack[-1] << 0x60) // @1839 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[0x40:0x60] - memory[0x40:0x60] + 0x28 // @183F memory[0x40:0x60] = memory[0x40:0x60] + 0x48 // @1853 memory[memory[0x40:0x60] + 0x68:memory[0x40:0x60] + 0x68 + 0x20] = ~((0x01 << 0xf8) - 0x01) // @185F memory[memory[0x40:0x60] + 0x69:memory[0x40:0x60] + 0x69 + 0x20] = ~0xffffffffffffffffffffffff & (stack[-8] << 0x60) // @1867 memory[memory[0x40:0x60] + 0x7d:memory[0x40:0x60] + 0x7d + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1891 memory[memory[0x40:0x60] + 0x9d:memory[0x40:0x60] + 0x9d + 0x20] = 0x96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f // @189B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x9d + (memory[0x40:0x60] - memory[0x40:0x60]) // @18A3 memory[0x40:0x60] = memory[0x40:0x60] + 0xbd // @18AC stack[-9] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to stack[-9] label_18B4: // Incoming call from 0x1729, returns to 0x1378 // Incoming jump from 0x0864 // Inputs[8] // { // @18B8 memory[0x40:0x60] // @18C1 stack[-2] // @18CE stack[-1] // @18D2 memory[0x40:0x60] // @18E7 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @18FD memory[0x40:0x60] // @18FF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1907 stack[-3] // } 18B4 5B JUMPDEST 18B5 60 PUSH1 0x40 18B7 80 DUP1 18B8 51 MLOAD 18B9 60 PUSH1 0x01 18BB 60 PUSH1 0x01 18BD 60 PUSH1 0xa0 18BF 1B SHL 18C0 03 SUB 18C1 84 DUP5 18C2 81 DUP2 18C3 16 AND 18C4 60 PUSH1 0x24 18C6 83 DUP4 18C7 01 ADD 18C8 52 MSTORE 18C9 60 PUSH1 0x44 18CB 80 DUP1 18CC 83 DUP4 18CD 01 ADD 18CE 85 DUP6 18CF 90 SWAP1 18D0 52 MSTORE 18D1 83 DUP4 18D2 51 MLOAD 18D3 80 DUP1 18D4 84 DUP5 18D5 03 SUB 18D6 90 SWAP1 18D7 91 SWAP2 18D8 01 ADD 18D9 81 DUP2 18DA 52 MSTORE 18DB 60 PUSH1 0x64 18DD 90 SWAP1 18DE 92 SWAP3 18DF 01 ADD 18E0 83 DUP4 18E1 52 MSTORE 18E2 60 PUSH1 0x20 18E4 82 DUP3 18E5 01 ADD 18E6 80 DUP1 18E7 51 MLOAD 18E8 60 PUSH1 0x01 18EA 60 PUSH1 0x01 18EC 60 PUSH1 0xe0 18EE 1B SHL 18EF 03 SUB 18F0 16 AND 18F1 63 PUSH4 0x095ea7b3 18F6 60 PUSH1 0xe0 18F8 1B SHL 18F9 17 OR 18FA 81 DUP2 18FB 52 MSTORE 18FC 92 SWAP3 18FD 51 MLOAD 18FE 82 DUP3 18FF 51 MLOAD 1900 60 PUSH1 0x00 1902 94 SWAP5 1903 60 PUSH1 0x60 1905 94 SWAP5 1906 93 SWAP4 1907 89 DUP10 1908 16 AND 1909 93 SWAP4 190A 92 SWAP3 190B 91 SWAP2 190C 82 DUP3 190D 91 SWAP2 190E 90 SWAP1 190F 80 DUP1 1910 83 DUP4 1911 83 DUP4 1912 5B JUMPDEST 1913 60 PUSH1 0x20 1915 83 DUP4 1916 10 LT 1917 61 PUSH2 0x1931 191A 57 *JUMPI // Stack delta = +11 // Outputs[16] // { // @18C8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @18D0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @18DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x44 + (memory[0x40:0x60] - memory[0x40:0x60]) // @18E1 memory[0x40:0x60] = memory[0x40:0x60] + 0x64 // @18FB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x095ea7b3 << 0xe0) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @1902 stack[0] = 0x00 // @1905 stack[1] = 0x60 // @1909 stack[2] = stack[-3] & (0x01 << 0xa0) - 0x01 // @190A stack[3] = memory[0x40:0x60] // @190B stack[4] = memory[0x40:0x60] // @190D stack[5] = memory[0x40:0x60] // @190E stack[6] = memory[0x40:0x60] + 0x20 // @190E stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @190F stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1910 stack[9] = memory[0x40:0x60] // @1911 stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x1931, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_191B: // Incoming jump from 0x191A, if not stack[-3] < 0x20 // Incoming jump from 0x191A, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @191B stack[-1] // @191C memory[stack[-1]:stack[-1] + 0x20] // @191D stack[-2] // @1923 stack[-3] // } 191B 80 DUP1 191C 51 MLOAD 191D 82 DUP3 191E 52 MSTORE 191F 60 PUSH1 0x1f 1921 19 NOT 1922 90 SWAP1 1923 92 SWAP3 1924 01 ADD 1925 91 SWAP2 1926 60 PUSH1 0x20 1928 91 SWAP2 1929 82 DUP3 192A 01 ADD 192B 91 SWAP2 192C 01 ADD 192D 61 PUSH2 0x1912 1930 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @191E memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1925 stack[-3] = stack[-3] + ~0x1f // @192B stack[-2] = 0x20 + stack[-2] // @192C stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1912 label_1931: // Incoming jump from 0x191A, if stack[-3] < 0x20 // Incoming jump from 0x191A, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[15] // { // @1934 stack[-3] // @193F stack[-1] // @1940 memory[stack[-1]:stack[-1] + 0x20] // @1943 stack[-2] // @1944 memory[stack[-2]:stack[-2] + 0x20] // @1951 stack[-5] // @1951 stack[-4] // @1953 stack[-6] // @1954 stack[-8] // @195B memory[0x40:0x60] // @1962 stack[-9] // @1963 msg.gas // @1964 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @1964 address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1968 returndata.length // } 1931 5B JUMPDEST 1932 60 PUSH1 0x01 1934 83 DUP4 1935 60 PUSH1 0x20 1937 03 SUB 1938 61 PUSH2 0x0100 193B 0A EXP 193C 03 SUB 193D 80 DUP1 193E 19 NOT 193F 82 DUP3 1940 51 MLOAD 1941 16 AND 1942 81 DUP2 1943 84 DUP5 1944 51 MLOAD 1945 16 AND 1946 80 DUP1 1947 82 DUP3 1948 17 OR 1949 85 DUP6 194A 52 MSTORE 194B 50 POP 194C 50 POP 194D 50 POP 194E 50 POP 194F 50 POP 1950 50 POP 1951 90 SWAP1 1952 50 POP 1953 01 ADD 1954 91 SWAP2 1955 50 POP 1956 50 POP 1957 60 PUSH1 0x00 1959 60 PUSH1 0x40 195B 51 MLOAD 195C 80 DUP1 195D 83 DUP4 195E 03 SUB 195F 81 DUP2 1960 60 PUSH1 0x00 1962 86 DUP7 1963 5A GAS 1964 F1 CALL 1965 91 SWAP2 1966 50 POP 1967 50 POP 1968 3D RETURNDATASIZE 1969 80 DUP1 196A 60 PUSH1 0x00 196C 81 DUP2 196D 14 EQ 196E 61 PUSH2 0x1993 1971 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @194A memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1964 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1965 stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1968 stack[-8] = returndata.length // @1969 stack[-7] = returndata.length // } // Block ends with conditional jump to 0x1993, if returndata.length == 0x00 label_1972: // Incoming jump from 0x1971, if not returndata.length == 0x00 // Inputs[6] // { // @1974 memory[0x40:0x60] // @1975 stack[-2] // @197C returndata.length // @1984 returndata.length // @1987 returndata.length // @198E returndata[0x00:0x00 + returndata.length] // } 1972 60 PUSH1 0x40 1974 51 MLOAD 1975 91 SWAP2 1976 50 POP 1977 60 PUSH1 0x1f 1979 19 NOT 197A 60 PUSH1 0x3f 197C 3D RETURNDATASIZE 197D 01 ADD 197E 16 AND 197F 82 DUP3 1980 01 ADD 1981 60 PUSH1 0x40 1983 52 MSTORE 1984 3D RETURNDATASIZE 1985 82 DUP3 1986 52 MSTORE 1987 3D RETURNDATASIZE 1988 60 PUSH1 0x00 198A 60 PUSH1 0x20 198C 84 DUP5 198D 01 ADD 198E 3E RETURNDATACOPY 198F 61 PUSH2 0x1998 1992 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1975 stack[-2] = memory[0x40:0x60] // @1983 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1986 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @198E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1998 label_1993: // Incoming jump from 0x1971, if returndata.length == 0x00 // Inputs[4] // { // @1996 stack[-2] // @199A stack[-4] // @199C stack[-3] // @199C stack[-5] // } 1993 5B JUMPDEST 1994 60 PUSH1 0x60 1996 91 SWAP2 1997 50 POP 1998 5B JUMPDEST 1999 50 POP 199A 91 SWAP2 199B 50 POP 199C 91 SWAP2 199D 50 POP 199E 81 DUP2 199F 80 DUP1 19A0 15 ISZERO 19A1 61 PUSH2 0x19c6 19A4 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @199A stack[-4] = 0x60 // @199C stack[-5] = stack[-3] // @199E stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x19c6, if !stack[-3] label_19A5: // Incoming jump from 0x19A4, if not !stack[-3] // Incoming jump from 0x19A4, if not !stack[-3] // Inputs[2] // { // @19A6 stack[-2] // @19A7 memory[stack[-2]:stack[-2] + 0x20] // } 19A5 50 POP 19A6 80 DUP1 19A7 51 MLOAD 19A8 15 ISZERO 19A9 80 DUP1 19AA 61 PUSH2 0x19c6 19AD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @19A8 stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x19c6, if !memory[stack[-2]:stack[-2] + 0x20] label_19AE: // Incoming jump from 0x19AD, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @19AF stack[-2] // @19B5 memory[stack[-2]:stack[-2] + 0x20] // } 19AE 50 POP 19AF 80 DUP1 19B0 80 DUP1 19B1 60 PUSH1 0x20 19B3 01 ADD 19B4 90 SWAP1 19B5 51 MLOAD 19B6 60 PUSH1 0x20 19B8 81 DUP2 19B9 10 LT 19BA 15 ISZERO 19BB 61 PUSH2 0x19c3 19BE 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @19B4 stack[-1] = 0x20 + stack[-2] // @19B5 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x19c3, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_19BF: // Incoming jump from 0x19BE, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @19C2 memory[0x00:0x00] } 19BF 60 PUSH1 0x00 19C1 80 DUP1 19C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @19C2 revert(memory[0x00:0x00]); } // Block terminates label_19C3: // Incoming jump from 0x19BE, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @19C5 memory[stack[-2]:stack[-2] + 0x20] // @19C5 stack[-2] // } 19C3 5B JUMPDEST 19C4 50 POP 19C5 51 MLOAD // Stack delta = -1 // Outputs[1] { @19C5 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_19C6: // Incoming jump from 0x19A4, if !stack[-3] // Incoming jump from 0x19A4, if !stack[-3] // Incoming jump from 0x19C5 // Incoming jump from 0x19AD, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @19CA stack[-1] } 19C6 5B JUMPDEST 19C7 61 PUSH2 0x17ed 19CA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17ed, if stack[-1] label_19CB: // Incoming jump from 0x19CA, if not stack[-1] // Inputs[3] // { // @19CE memory[0x40:0x60] // @1A0D memory[0x40:0x60] // @1A16 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 19CB 60 PUSH1 0x40 19CD 80 DUP1 19CE 51 MLOAD 19CF 62 PUSH3 0x461bcd 19D3 60 PUSH1 0xe5 19D5 1B SHL 19D6 81 DUP2 19D7 52 MSTORE 19D8 60 PUSH1 0x20 19DA 60 PUSH1 0x04 19DC 82 DUP3 19DD 01 ADD 19DE 52 MSTORE 19DF 60 PUSH1 0x1e 19E1 60 PUSH1 0x24 19E3 82 DUP3 19E4 01 ADD 19E5 52 MSTORE 19E6 7F PUSH32 0x5472616e7366657248656c7065723a20415050524f56455f4641494c45440000 1A07 60 PUSH1 0x44 1A09 82 DUP3 1A0A 01 ADD 1A0B 52 MSTORE 1A0C 90 SWAP1 1A0D 51 MLOAD 1A0E 90 SWAP1 1A0F 81 DUP2 1A10 90 SWAP1 1A11 03 SUB 1A12 60 PUSH1 0x64 1A14 01 ADD 1A15 90 SWAP1 1A16 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @19D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @19DE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @19E5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @1A0B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5472616e7366657248656c7065723a20415050524f56455f4641494c45440000 // @1A16 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1A17: // Incoming jump from 0x08D7 // Incoming jump from 0x1286 // Inputs[9] // { // @1A1B memory[0x40:0x60] // @1A24 stack[-3] // @1A2C stack[-2] // @1A39 stack[-1] // @1A3D memory[0x40:0x60] // @1A52 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @1A68 memory[0x40:0x60] // @1A6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1A72 stack[-4] // } 1A17 5B JUMPDEST 1A18 60 PUSH1 0x40 1A1A 80 DUP1 1A1B 51 MLOAD 1A1C 60 PUSH1 0x01 1A1E 60 PUSH1 0x01 1A20 60 PUSH1 0xa0 1A22 1B SHL 1A23 03 SUB 1A24 85 DUP6 1A25 81 DUP2 1A26 16 AND 1A27 60 PUSH1 0x24 1A29 83 DUP4 1A2A 01 ADD 1A2B 52 MSTORE 1A2C 84 DUP5 1A2D 81 DUP2 1A2E 16 AND 1A2F 60 PUSH1 0x44 1A31 83 DUP4 1A32 01 ADD 1A33 52 MSTORE 1A34 60 PUSH1 0x64 1A36 80 DUP1 1A37 83 DUP4 1A38 01 ADD 1A39 85 DUP6 1A3A 90 SWAP1 1A3B 52 MSTORE 1A3C 83 DUP4 1A3D 51 MLOAD 1A3E 80 DUP1 1A3F 84 DUP5 1A40 03 SUB 1A41 90 SWAP1 1A42 91 SWAP2 1A43 01 ADD 1A44 81 DUP2 1A45 52 MSTORE 1A46 60 PUSH1 0x84 1A48 90 SWAP1 1A49 92 SWAP3 1A4A 01 ADD 1A4B 83 DUP4 1A4C 52 MSTORE 1A4D 60 PUSH1 0x20 1A4F 82 DUP3 1A50 01 ADD 1A51 80 DUP1 1A52 51 MLOAD 1A53 60 PUSH1 0x01 1A55 60 PUSH1 0x01 1A57 60 PUSH1 0xe0 1A59 1B SHL 1A5A 03 SUB 1A5B 16 AND 1A5C 63 PUSH4 0x23b872dd 1A61 60 PUSH1 0xe0 1A63 1B SHL 1A64 17 OR 1A65 81 DUP2 1A66 52 MSTORE 1A67 92 SWAP3 1A68 51 MLOAD 1A69 82 DUP3 1A6A 51 MLOAD 1A6B 60 PUSH1 0x00 1A6D 94 SWAP5 1A6E 60 PUSH1 0x60 1A70 94 SWAP5 1A71 93 SWAP4 1A72 8A DUP11 1A73 16 AND 1A74 93 SWAP4 1A75 92 SWAP3 1A76 91 SWAP2 1A77 82 DUP3 1A78 91 SWAP2 1A79 90 SWAP1 1A7A 80 DUP1 1A7B 83 DUP4 1A7C 83 DUP4 1A7D 5B JUMPDEST 1A7E 60 PUSH1 0x20 1A80 83 DUP4 1A81 10 LT 1A82 61 PUSH2 0x1a9c 1A85 57 *JUMPI // Stack delta = +11 // Outputs[17] // { // @1A2B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1A33 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1A3B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-1] // @1A45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x64 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1A4C memory[0x40:0x60] = memory[0x40:0x60] + 0x84 // @1A66 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x23b872dd << 0xe0) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @1A6D stack[0] = 0x00 // @1A70 stack[1] = 0x60 // @1A74 stack[2] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1A75 stack[3] = memory[0x40:0x60] // @1A76 stack[4] = memory[0x40:0x60] // @1A78 stack[5] = memory[0x40:0x60] // @1A79 stack[6] = memory[0x40:0x60] + 0x20 // @1A79 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1A7A stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1A7B stack[9] = memory[0x40:0x60] // @1A7C stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x1a9c, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_1A86: // Incoming jump from 0x1A85, if not stack[-3] < 0x20 // Incoming jump from 0x1A85, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @1A86 stack[-1] // @1A87 memory[stack[-1]:stack[-1] + 0x20] // @1A88 stack[-2] // @1A8E stack[-3] // } 1A86 80 DUP1 1A87 51 MLOAD 1A88 82 DUP3 1A89 52 MSTORE 1A8A 60 PUSH1 0x1f 1A8C 19 NOT 1A8D 90 SWAP1 1A8E 92 SWAP3 1A8F 01 ADD 1A90 91 SWAP2 1A91 60 PUSH1 0x20 1A93 91 SWAP2 1A94 82 DUP3 1A95 01 ADD 1A96 91 SWAP2 1A97 01 ADD 1A98 61 PUSH2 0x1a7d 1A9B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1A89 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1A90 stack[-3] = stack[-3] + ~0x1f // @1A96 stack[-2] = 0x20 + stack[-2] // @1A97 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1a7d label_1A9C: // Incoming jump from 0x1A85, if stack[-3] < 0x20 // Incoming jump from 0x1A85, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[15] // { // @1A9F stack[-3] // @1AAA stack[-1] // @1AAB memory[stack[-1]:stack[-1] + 0x20] // @1AAE stack[-2] // @1AAF memory[stack[-2]:stack[-2] + 0x20] // @1ABC stack[-4] // @1ABC stack[-5] // @1ABE stack[-6] // @1ABF stack[-8] // @1AC6 memory[0x40:0x60] // @1ACD stack[-9] // @1ACE msg.gas // @1ACF address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1ACF memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @1AD3 returndata.length // } 1A9C 5B JUMPDEST 1A9D 60 PUSH1 0x01 1A9F 83 DUP4 1AA0 60 PUSH1 0x20 1AA2 03 SUB 1AA3 61 PUSH2 0x0100 1AA6 0A EXP 1AA7 03 SUB 1AA8 80 DUP1 1AA9 19 NOT 1AAA 82 DUP3 1AAB 51 MLOAD 1AAC 16 AND 1AAD 81 DUP2 1AAE 84 DUP5 1AAF 51 MLOAD 1AB0 16 AND 1AB1 80 DUP1 1AB2 82 DUP3 1AB3 17 OR 1AB4 85 DUP6 1AB5 52 MSTORE 1AB6 50 POP 1AB7 50 POP 1AB8 50 POP 1AB9 50 POP 1ABA 50 POP 1ABB 50 POP 1ABC 90 SWAP1 1ABD 50 POP 1ABE 01 ADD 1ABF 91 SWAP2 1AC0 50 POP 1AC1 50 POP 1AC2 60 PUSH1 0x00 1AC4 60 PUSH1 0x40 1AC6 51 MLOAD 1AC7 80 DUP1 1AC8 83 DUP4 1AC9 03 SUB 1ACA 81 DUP2 1ACB 60 PUSH1 0x00 1ACD 86 DUP7 1ACE 5A GAS 1ACF F1 CALL 1AD0 91 SWAP2 1AD1 50 POP 1AD2 50 POP 1AD3 3D RETURNDATASIZE 1AD4 80 DUP1 1AD5 60 PUSH1 0x00 1AD7 81 DUP2 1AD8 14 EQ 1AD9 61 PUSH2 0x1afe 1ADC 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @1AB5 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1ACF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1AD0 stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1AD3 stack[-8] = returndata.length // @1AD4 stack[-7] = returndata.length // } // Block ends with conditional jump to 0x1afe, if returndata.length == 0x00 label_1ADD: // Incoming jump from 0x1ADC, if not returndata.length == 0x00 // Inputs[6] // { // @1ADF memory[0x40:0x60] // @1AE0 stack[-2] // @1AE7 returndata.length // @1AEF returndata.length // @1AF2 returndata.length // @1AF9 returndata[0x00:0x00 + returndata.length] // } 1ADD 60 PUSH1 0x40 1ADF 51 MLOAD 1AE0 91 SWAP2 1AE1 50 POP 1AE2 60 PUSH1 0x1f 1AE4 19 NOT 1AE5 60 PUSH1 0x3f 1AE7 3D RETURNDATASIZE 1AE8 01 ADD 1AE9 16 AND 1AEA 82 DUP3 1AEB 01 ADD 1AEC 60 PUSH1 0x40 1AEE 52 MSTORE 1AEF 3D RETURNDATASIZE 1AF0 82 DUP3 1AF1 52 MSTORE 1AF2 3D RETURNDATASIZE 1AF3 60 PUSH1 0x00 1AF5 60 PUSH1 0x20 1AF7 84 DUP5 1AF8 01 ADD 1AF9 3E RETURNDATACOPY 1AFA 61 PUSH2 0x1b03 1AFD 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1AE0 stack[-2] = memory[0x40:0x60] // @1AEE memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1AF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1AF9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1b03 label_1AFE: // Incoming jump from 0x1ADC, if returndata.length == 0x00 // Inputs[4] // { // @1B01 stack[-2] // @1B05 stack[-4] // @1B07 stack[-3] // @1B07 stack[-5] // } 1AFE 5B JUMPDEST 1AFF 60 PUSH1 0x60 1B01 91 SWAP2 1B02 50 POP 1B03 5B JUMPDEST 1B04 50 POP 1B05 91 SWAP2 1B06 50 POP 1B07 91 SWAP2 1B08 50 POP 1B09 81 DUP2 1B0A 80 DUP1 1B0B 15 ISZERO 1B0C 61 PUSH2 0x1b31 1B0F 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @1B05 stack[-4] = 0x60 // @1B07 stack[-5] = stack[-3] // @1B09 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x1b31, if !stack[-3] label_1B10: // Incoming jump from 0x1B0F, if not !stack[-3] // Incoming jump from 0x1B0F, if not !stack[-3] // Inputs[2] // { // @1B11 stack[-2] // @1B12 memory[stack[-2]:stack[-2] + 0x20] // } 1B10 50 POP 1B11 80 DUP1 1B12 51 MLOAD 1B13 15 ISZERO 1B14 80 DUP1 1B15 61 PUSH2 0x1b31 1B18 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B13 stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1b31, if !memory[stack[-2]:stack[-2] + 0x20] label_1B19: // Incoming jump from 0x1B18, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @1B1A stack[-2] // @1B20 memory[stack[-2]:stack[-2] + 0x20] // } 1B19 50 POP 1B1A 80 DUP1 1B1B 80 DUP1 1B1C 60 PUSH1 0x20 1B1E 01 ADD 1B1F 90 SWAP1 1B20 51 MLOAD 1B21 60 PUSH1 0x20 1B23 81 DUP2 1B24 10 LT 1B25 15 ISZERO 1B26 61 PUSH2 0x1b2e 1B29 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1B1F stack[-1] = 0x20 + stack[-2] // @1B20 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1b2e, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_1B2A: // Incoming jump from 0x1B29, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @1B2D memory[0x00:0x00] } 1B2A 60 PUSH1 0x00 1B2C 80 DUP1 1B2D FD *REVERT // Stack delta = +0 // Outputs[1] { @1B2D revert(memory[0x00:0x00]); } // Block terminates label_1B2E: // Incoming jump from 0x1B29, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @1B30 memory[stack[-2]:stack[-2] + 0x20] // @1B30 stack[-2] // } 1B2E 5B JUMPDEST 1B2F 50 POP 1B30 51 MLOAD // Stack delta = -1 // Outputs[1] { @1B30 stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_1B31: // Incoming jump from 0x1B0F, if !stack[-3] // Incoming jump from 0x1B30 // Incoming jump from 0x1B18, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1B0F, if !stack[-3] // Inputs[1] { @1B35 stack[-1] } 1B31 5B JUMPDEST 1B32 61 PUSH2 0x08e3 1B35 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08e3, if stack[-1] label_1B36: // Incoming jump from 0x1B35, if not stack[-1] // Inputs[3] // { // @1B38 memory[0x40:0x60] // @1B66 memory[0x40:0x60] // @1B6B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B36 60 PUSH1 0x40 1B38 51 MLOAD 1B39 62 PUSH3 0x461bcd 1B3D 60 PUSH1 0xe5 1B3F 1B SHL 1B40 81 DUP2 1B41 52 MSTORE 1B42 60 PUSH1 0x04 1B44 01 ADD 1B45 80 DUP1 1B46 80 DUP1 1B47 60 PUSH1 0x20 1B49 01 ADD 1B4A 82 DUP3 1B4B 81 DUP2 1B4C 03 SUB 1B4D 82 DUP3 1B4E 52 MSTORE 1B4F 60 PUSH1 0x24 1B51 81 DUP2 1B52 52 MSTORE 1B53 60 PUSH1 0x20 1B55 01 ADD 1B56 80 DUP1 1B57 61 PUSH2 0x2770 1B5A 60 PUSH1 0x24 1B5C 91 SWAP2 1B5D 39 CODECOPY 1B5E 60 PUSH1 0x40 1B60 01 ADD 1B61 91 SWAP2 1B62 50 POP 1B63 50 POP 1B64 60 PUSH1 0x40 1B66 51 MLOAD 1B67 80 DUP1 1B68 91 SWAP2 1B69 03 SUB 1B6A 90 SWAP1 1B6B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B41 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B4E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1B52 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @1B5D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x2770:0x2794] // @1B6B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B6C: // Incoming call from 0x0E96, returns to 0x0E97 // Incoming call from 0x08E2, returns to 0x08E3 // Inputs[2] // { // @1B70 stack[-3] // @1B74 memory[stack[-3]:stack[-3] + 0x20] // } 1B6C 5B JUMPDEST 1B6D 60 PUSH1 0x00 1B6F 80 DUP1 1B70 84 DUP5 1B71 60 PUSH1 0x00 1B73 81 DUP2 1B74 51 MLOAD 1B75 81 DUP2 1B76 10 LT 1B77 61 PUSH2 0x1b7c 1B7A 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1B6D stack[0] = 0x00 // @1B6F stack[1] = 0x00 // @1B70 stack[2] = stack[-3] // @1B71 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1b7c, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_1B7B: // Incoming jump from 0x1B7A, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 1B7B FE *ASSERT // Stack delta = +0 // Outputs[1] { @1B7B assert(); } // Block terminates label_1B7C: // Incoming jump from 0x1B7A, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @1B7F stack[-1] // @1B83 stack[-2] // @1B84 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1B85 stack[-7] // @1B89 memory[stack[-7]:stack[-7] + 0x20] // } 1B7C 5B JUMPDEST 1B7D 60 PUSH1 0x20 1B7F 02 MUL 1B80 60 PUSH1 0x20 1B82 01 ADD 1B83 01 ADD 1B84 51 MLOAD 1B85 85 DUP6 1B86 60 PUSH1 0x01 1B88 81 DUP2 1B89 51 MLOAD 1B8A 81 DUP2 1B8B 10 LT 1B8C 61 PUSH2 0x1b91 1B8F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1B84 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1B85 stack[-1] = stack[-7] // @1B86 stack[0] = 0x01 // } // Block ends with conditional jump to 0x1b91, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] label_1B90: // Incoming jump from 0x1B8F, if not 0x01 < memory[stack[-7]:stack[-7] + 0x20] 1B90 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1B90 assert(); } // Block terminates label_1B91: // Incoming jump from 0x1B8F, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] // Inputs[6] // { // @1B94 stack[-1] // @1B98 stack[-2] // @1B99 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1B9A stack[-4] // @1B9C stack[-5] // @1B9C stack[-3] // } 1B91 5B JUMPDEST 1B92 60 PUSH1 0x20 1B94 02 MUL 1B95 60 PUSH1 0x20 1B97 01 ADD 1B98 01 ADD 1B99 51 MLOAD 1B9A 91 SWAP2 1B9B 50 POP 1B9C 91 SWAP2 1B9D 50 POP 1B9E 60 PUSH1 0x00 1BA0 61 PUSH2 0x1ba9 1BA3 83 DUP4 1BA4 83 DUP4 1BA5 61 PUSH2 0x236c 1BA8 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1B9A stack[-4] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1B9C stack[-5] = stack[-3] // @1B9E stack[-3] = 0x00 // @1BA0 stack[-2] = 0x1ba9 // @1BA3 stack[-1] = stack[-3] // @1BA4 stack[0] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with call to 0x236c, returns to 0x1BA9 label_1BA9: // Incoming return from call to 0x236C at 0x1BA8 // Inputs[6] // { // @1BAB stack[-3] // @1BAB stack[-2] // @1BAF stack[-6] // @1BC9 memory[0x40:0x60] // @1BDD memory[0x40:0x60] // @1BE4 address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // } 1BA9 5B JUMPDEST 1BAA 50 POP 1BAB 90 SWAP1 1BAC 50 POP 1BAD 60 PUSH1 0x00 1BAF 84 DUP5 1BB0 90 SWAP1 1BB1 50 POP 1BB2 60 PUSH1 0x00 1BB4 80 DUP1 1BB5 60 PUSH1 0x00 1BB7 80 DUP1 1BB8 84 DUP5 1BB9 60 PUSH1 0x01 1BBB 60 PUSH1 0x01 1BBD 60 PUSH1 0xa0 1BBF 1B SHL 1BC0 03 SUB 1BC1 16 AND 1BC2 63 PUSH4 0x0902f1ac 1BC7 60 PUSH1 0x40 1BC9 51 MLOAD 1BCA 81 DUP2 1BCB 63 PUSH4 0xffffffff 1BD0 16 AND 1BD1 60 PUSH1 0xe0 1BD3 1B SHL 1BD4 81 DUP2 1BD5 52 MSTORE 1BD6 60 PUSH1 0x04 1BD8 01 ADD 1BD9 60 PUSH1 0x60 1BDB 60 PUSH1 0x40 1BDD 51 MLOAD 1BDE 80 DUP1 1BDF 83 DUP4 1BE0 03 SUB 1BE1 81 DUP2 1BE2 86 DUP7 1BE3 80 DUP1 1BE4 3B EXTCODESIZE 1BE5 15 ISZERO 1BE6 80 DUP1 1BE7 15 ISZERO 1BE8 61 PUSH2 0x1bf0 1BEB 57 *JUMPI // Stack delta = +12 // Outputs[16] // { // @1BAB stack[-3] = stack[-2] // @1BB0 stack[-2] = stack[-6] // @1BB2 stack[-1] = 0x00 // @1BB4 stack[0] = 0x00 // @1BB5 stack[1] = 0x00 // @1BB7 stack[2] = 0x00 // @1BC1 stack[3] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1BC2 stack[4] = 0x0902f1ac // @1BD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0902f1ac) << 0xe0 // @1BD8 stack[5] = 0x04 + memory[0x40:0x60] // @1BD9 stack[6] = 0x60 // @1BDD stack[7] = memory[0x40:0x60] // @1BE0 stack[8] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1BE1 stack[9] = memory[0x40:0x60] // @1BE2 stack[10] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1BE5 stack[11] = !address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // } // Block ends with conditional jump to 0x1bf0, if !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length label_1BEC: // Incoming jump from 0x1BEB, if not !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // Inputs[1] { @1BEF memory[0x00:0x00] } 1BEC 60 PUSH1 0x00 1BEE 80 DUP1 1BEF FD *REVERT // Stack delta = +0 // Outputs[1] { @1BEF revert(memory[0x00:0x00]); } // Block terminates label_1BF0: // Incoming jump from 0x1BEB, if !!address((0x01 << 0xa0) - 0x01 & stack[-6]).code.length // Inputs[8] // { // @1BF2 msg.gas // @1BF3 stack[-6] // @1BF3 stack[-5] // @1BF3 memory[stack[-3]:stack[-3] + stack[-4]] // @1BF3 stack[-2] // @1BF3 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1BF3 stack[-4] // @1BF3 stack[-3] // } 1BF0 5B JUMPDEST 1BF1 50 POP 1BF2 5A GAS 1BF3 FA STATICCALL 1BF4 15 ISZERO 1BF5 80 DUP1 1BF6 15 ISZERO 1BF7 61 PUSH2 0x1c04 1BFA 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1BF3 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1BF4 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1c04, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1BFB: // Incoming jump from 0x1BFA, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1BFB returndata.length // @1BFF returndata[0x00:0x00 + returndata.length] // @1C00 returndata.length // @1C03 memory[0x00:0x00 + returndata.length] // } 1BFB 3D RETURNDATASIZE 1BFC 60 PUSH1 0x00 1BFE 80 DUP1 1BFF 3E RETURNDATACOPY 1C00 3D RETURNDATASIZE 1C01 60 PUSH1 0x00 1C03 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1BFF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1C03 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1C04: // Incoming jump from 0x1BFA, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1C0B memory[0x40:0x60] // @1C0C returndata.length // } 1C04 5B JUMPDEST 1C05 50 POP 1C06 50 POP 1C07 50 POP 1C08 50 POP 1C09 60 PUSH1 0x40 1C0B 51 MLOAD 1C0C 3D RETURNDATASIZE 1C0D 60 PUSH1 0x60 1C0F 81 DUP2 1C10 10 LT 1C11 15 ISZERO 1C12 61 PUSH2 0x1c1a 1C15 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1C0B stack[-4] = memory[0x40:0x60] // @1C0C stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1c1a, if !(returndata.length < 0x60) label_1C16: // Incoming jump from 0x1C15, if not !(returndata.length < 0x60) // Inputs[1] { @1C19 memory[0x00:0x00] } 1C16 60 PUSH1 0x00 1C18 80 DUP1 1C19 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C19 revert(memory[0x00:0x00]); } // Block terminates label_1C1A: // Incoming jump from 0x1C15, if !(returndata.length < 0x60) // Inputs[7] // { // @1C1C stack[-2] // @1C1D memory[stack[-2]:stack[-2] + 0x20] // @1C23 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @1C2F stack[-4] // @1C32 stack[-3] // @1C3F stack[-10] // @1C43 stack[-8] // } 1C1A 5B JUMPDEST 1C1B 50 POP 1C1C 80 DUP1 1C1D 51 MLOAD 1C1E 60 PUSH1 0x20 1C20 90 SWAP1 1C21 91 SWAP2 1C22 01 ADD 1C23 51 MLOAD 1C24 60 PUSH1 0x01 1C26 60 PUSH1 0x01 1C28 60 PUSH1 0x70 1C2A 1B SHL 1C2B 03 SUB 1C2C 91 SWAP2 1C2D 82 DUP3 1C2E 16 AND 1C2F 93 SWAP4 1C30 50 POP 1C31 16 AND 1C32 90 SWAP1 1C33 50 POP 1C34 60 PUSH1 0x00 1C36 80 DUP1 1C37 60 PUSH1 0x01 1C39 60 PUSH1 0x01 1C3B 60 PUSH1 0xa0 1C3D 1B SHL 1C3E 03 SUB 1C3F 8A DUP11 1C40 81 DUP2 1C41 16 AND 1C42 90 SWAP1 1C43 89 DUP10 1C44 16 AND 1C45 14 EQ 1C46 61 PUSH2 0x1c50 1C49 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1C2F stack[-4] = (0x01 << 0x70) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @1C32 stack[-3] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & (0x01 << 0x70) - 0x01 // @1C34 stack[-2] = 0x00 // @1C36 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x1c50, if stack[-8] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-10] label_1C4A: // Incoming jump from 0x1C49, if not stack[-8] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-10] // Inputs[2] // { // @1C4A stack[-3] // @1C4B stack[-4] // } 1C4A 82 DUP3 1C4B 84 DUP5 1C4C 61 PUSH2 0x1c53 1C4F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C4A stack[0] = stack[-3] // @1C4B stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x1c53 label_1C50: // Incoming jump from 0x1C49, if stack[-8] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-10] // Inputs[9] // { // @1C51 stack[-4] // @1C52 stack[-3] // @1C54 stack[-1] // @1C56 stack[-2] // @1C5C stack[-10] // @1C6B stack[-7] // @1C6E memory[0x40:0x60] // @1C9E memory[0x40:0x60] // @1CA5 address((0x01 << 0xa0) - 0x01 & stack[-10]).code.length // } 1C50 5B JUMPDEST 1C51 83 DUP4 1C52 83 DUP4 1C53 5B JUMPDEST 1C54 91 SWAP2 1C55 50 POP 1C56 91 SWAP2 1C57 50 POP 1C58 61 PUSH2 0x1ce9 1C5B 82 DUP3 1C5C 8B DUP12 1C5D 60 PUSH1 0x01 1C5F 60 PUSH1 0x01 1C61 60 PUSH1 0xa0 1C63 1B SHL 1C64 03 SUB 1C65 16 AND 1C66 63 PUSH4 0x70a08231 1C6B 8A DUP11 1C6C 60 PUSH1 0x40 1C6E 51 MLOAD 1C6F 82 DUP3 1C70 63 PUSH4 0xffffffff 1C75 16 AND 1C76 60 PUSH1 0xe0 1C78 1B SHL 1C79 81 DUP2 1C7A 52 MSTORE 1C7B 60 PUSH1 0x04 1C7D 01 ADD 1C7E 80 DUP1 1C7F 82 DUP3 1C80 60 PUSH1 0x01 1C82 60 PUSH1 0x01 1C84 60 PUSH1 0xa0 1C86 1B SHL 1C87 03 SUB 1C88 16 AND 1C89 60 PUSH1 0x01 1C8B 60 PUSH1 0x01 1C8D 60 PUSH1 0xa0 1C8F 1B SHL 1C90 03 SUB 1C91 16 AND 1C92 81 DUP2 1C93 52 MSTORE 1C94 60 PUSH1 0x20 1C96 01 ADD 1C97 91 SWAP2 1C98 50 POP 1C99 50 POP 1C9A 60 PUSH1 0x20 1C9C 60 PUSH1 0x40 1C9E 51 MLOAD 1C9F 80 DUP1 1CA0 83 DUP4 1CA1 03 SUB 1CA2 81 DUP2 1CA3 86 DUP7 1CA4 80 DUP1 1CA5 3B EXTCODESIZE 1CA6 15 ISZERO 1CA7 80 DUP1 1CA8 15 ISZERO 1CA9 61 PUSH2 0x1cb1 1CAC 57 *JUMPI // Stack delta = +11 // Outputs[15] // { // @1C54 stack[-1] = stack[-3] // @1C56 stack[-2] = stack[-4] // @1C58 stack[0] = 0x1ce9 // @1C5B stack[1] = stack[-4] // @1C65 stack[2] = (0x01 << 0xa0) - 0x01 & stack[-10] // @1C66 stack[3] = 0x70a08231 // @1C7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @1C93 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-7] // @1C97 stack[4] = 0x20 + 0x04 + memory[0x40:0x60] // @1C9A stack[5] = 0x20 // @1C9E stack[6] = memory[0x40:0x60] // @1CA1 stack[7] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1CA2 stack[8] = memory[0x40:0x60] // @1CA3 stack[9] = (0x01 << 0xa0) - 0x01 & stack[-10] // @1CA6 stack[10] = !address((0x01 << 0xa0) - 0x01 & stack[-10]).code.length // } // Block ends with conditional call to 0x1cb1, returns to 0x1CE9, if !!address((0x01 << 0xa0) - 0x01 & stack[-10]).code.length label_1CAD: // Incoming jump from 0x1CAC, if not !!address((0x01 << 0xa0) - 0x01 & stack[-12]).code.length // Incoming jump from 0x1CAC, if not !!address((0x01 << 0xa0) - 0x01 & stack[-10]).code.length // Inputs[1] { @1CB0 memory[0x00:0x00] } 1CAD 60 PUSH1 0x00 1CAF 80 DUP1 1CB0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CB0 revert(memory[0x00:0x00]); } // Block terminates label_1CB1: // Incoming call from 0x1CAC, returns to 0x1CE9, if !!address((0x01 << 0xa0) - 0x01 & stack[-12]).code.length // Incoming call from 0x1CAC, returns to 0x1CE9, if !!address((0x01 << 0xa0) - 0x01 & stack[-10]).code.length // Inputs[8] // { // @1CB3 msg.gas // @1CB4 stack[-4] // @1CB4 stack[-5] // @1CB4 stack[-6] // @1CB4 memory[stack[-3]:stack[-3] + stack[-4]] // @1CB4 stack[-2] // @1CB4 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1CB4 stack[-3] // } 1CB1 5B JUMPDEST 1CB2 50 POP 1CB3 5A GAS 1CB4 FA STATICCALL 1CB5 15 ISZERO 1CB6 80 DUP1 1CB7 15 ISZERO 1CB8 61 PUSH2 0x1cc5 1CBB 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1CB4 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1CB5 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1cc5, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1CBC: // Incoming jump from 0x1CBB, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1CBC returndata.length // @1CC0 returndata[0x00:0x00 + returndata.length] // @1CC1 returndata.length // @1CC4 memory[0x00:0x00 + returndata.length] // } 1CBC 3D RETURNDATASIZE 1CBD 60 PUSH1 0x00 1CBF 80 DUP1 1CC0 3E RETURNDATACOPY 1CC1 3D RETURNDATASIZE 1CC2 60 PUSH1 0x00 1CC4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1CC0 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1CC4 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1CC5: // Incoming jump from 0x1CBB, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1CCC memory[0x40:0x60] // @1CCD returndata.length // } 1CC5 5B JUMPDEST 1CC6 50 POP 1CC7 50 POP 1CC8 50 POP 1CC9 50 POP 1CCA 60 PUSH1 0x40 1CCC 51 MLOAD 1CCD 3D RETURNDATASIZE 1CCE 60 PUSH1 0x20 1CD0 81 DUP2 1CD1 10 LT 1CD2 15 ISZERO 1CD3 61 PUSH2 0x1cdb 1CD6 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1CCC stack[-4] = memory[0x40:0x60] // @1CCD stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1cdb, if !(returndata.length < 0x20) label_1CD7: // Incoming jump from 0x1CD6, if not !(returndata.length < 0x20) // Inputs[1] { @1CDA memory[0x00:0x00] } 1CD7 60 PUSH1 0x00 1CD9 80 DUP1 1CDA FD *REVERT // Stack delta = +0 // Outputs[1] { @1CDA revert(memory[0x00:0x00]); } // Block terminates label_1CDB: // Incoming jump from 0x1CD6, if !(returndata.length < 0x20) // Inputs[3] // { // @1CDD stack[-2] // @1CDD memory[stack[-2]:stack[-2] + 0x20] // @1CDE stack[-3] // } 1CDB 5B JUMPDEST 1CDC 50 POP 1CDD 51 MLOAD 1CDE 90 SWAP1 1CDF 63 PUSH4 0xffffffff 1CE4 61 PUSH2 0x244a 1CE7 16 AND 1CE8 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1CDE stack[-2] = stack[-3] // @1CDE stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x244a & 0xffffffff label_1CE9: // Incoming return from call to 0x1CB1 at 0x1CAC // Incoming return from call to 0x1CB1 at 0x1CAC // Inputs[4] // { // @1CEA stack[-7] // @1CEA stack[-1] // @1CF0 stack[-3] // @1CF1 stack[-2] // } 1CE9 5B JUMPDEST 1CEA 95 SWAP6 1CEB 50 POP 1CEC 61 PUSH2 0x1cf6 1CEF 86 DUP7 1CF0 83 DUP4 1CF1 83 DUP4 1CF2 61 PUSH2 0x24a0 1CF5 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1CEA stack[-7] = stack[-1] // @1CEC stack[-1] = 0x1cf6 // @1CEF stack[0] = stack[-1] // @1CF0 stack[1] = stack[-3] // @1CF1 stack[2] = stack[-2] // } // Block ends with call to 0x24a0, returns to 0x1CF6 label_1CF6: // Incoming return from call to 0x24A0 at 0x1CF5 // Inputs[4] // { // @1CF7 stack[-6] // @1CF7 stack[-1] // @1D00 stack[-9] // @1D0A stack[-11] // } 1CF6 5B JUMPDEST 1CF7 94 SWAP5 1CF8 50 POP 1CF9 50 POP 1CFA 50 POP 1CFB 50 POP 1CFC 50 POP 1CFD 60 PUSH1 0x00 1CFF 80 DUP1 1D00 85 DUP6 1D01 60 PUSH1 0x01 1D03 60 PUSH1 0x01 1D05 60 PUSH1 0xa0 1D07 1B SHL 1D08 03 SUB 1D09 16 AND 1D0A 88 DUP9 1D0B 60 PUSH1 0x01 1D0D 60 PUSH1 0x01 1D0F 60 PUSH1 0xa0 1D11 1B SHL 1D12 03 SUB 1D13 16 AND 1D14 14 EQ 1D15 61 PUSH2 0x1d20 1D18 57 *JUMPI // Stack delta = -3 // Outputs[3] // { // @1CF7 stack[-6] = stack[-1] // @1CFD stack[-5] = 0x00 // @1CFF stack[-4] = 0x00 // } // Block ends with conditional jump to 0x1d20, if (0x01 << 0xa0) - 0x01 & stack[-11] == (0x01 << 0xa0) - 0x01 & stack[-9] label_1D19: // Incoming jump from 0x1D18, if not (0x01 << 0xa0) - 0x01 & stack[-11] == (0x01 << 0xa0) - 0x01 & stack[-9] // Inputs[1] { @1D19 stack[-3] } 1D19 82 DUP3 1D1A 60 PUSH1 0x00 1D1C 61 PUSH2 0x1d24 1D1F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D19 stack[0] = stack[-3] // @1D1A stack[1] = 0x00 // } // Block ends with unconditional jump to 0x1d24 label_1D20: // Incoming jump from 0x1D18, if (0x01 << 0xa0) - 0x01 & stack[-11] == (0x01 << 0xa0) - 0x01 & stack[-9] // Inputs[9] // { // @1D23 stack[-3] // @1D28 memory[0x40:0x60] // @1D36 stack[-2] // @1D39 stack[-1] // @1D43 stack[-5] // @1D50 stack[-10] // @1D56 memory[0x40:0x60] // @1D97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1DA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1D20 5B JUMPDEST 1D21 60 PUSH1 0x00 1D23 83 DUP4 1D24 5B JUMPDEST 1D25 60 PUSH1 0x40 1D27 80 DUP1 1D28 51 MLOAD 1D29 60 PUSH1 0x00 1D2B 80 DUP1 1D2C 82 DUP3 1D2D 52 MSTORE 1D2E 60 PUSH1 0x20 1D30 82 DUP3 1D31 01 ADD 1D32 90 SWAP1 1D33 92 SWAP3 1D34 52 MSTORE 1D35 92 SWAP3 1D36 94 SWAP5 1D37 50 POP 1D38 90 SWAP1 1D39 92 SWAP3 1D3A 50 POP 1D3B 60 PUSH1 0x01 1D3D 60 PUSH1 0x01 1D3F 60 PUSH1 0xa0 1D41 1B SHL 1D42 03 SUB 1D43 87 DUP8 1D44 16 AND 1D45 91 SWAP2 1D46 63 PUSH4 0x022c0d9f 1D4B 91 SWAP2 1D4C 85 DUP6 1D4D 91 SWAP2 1D4E 85 DUP6 1D4F 91 SWAP2 1D50 8F DUP16 1D51 91 SWAP2 1D52 90 SWAP1 1D53 50 POP 1D54 60 PUSH1 0x40 1D56 51 MLOAD 1D57 85 DUP6 1D58 63 PUSH4 0xffffffff 1D5D 16 AND 1D5E 60 PUSH1 0xe0 1D60 1B SHL 1D61 81 DUP2 1D62 52 MSTORE 1D63 60 PUSH1 0x04 1D65 01 ADD 1D66 80 DUP1 1D67 85 DUP6 1D68 81 DUP2 1D69 52 MSTORE 1D6A 60 PUSH1 0x20 1D6C 01 ADD 1D6D 84 DUP5 1D6E 81 DUP2 1D6F 52 MSTORE 1D70 60 PUSH1 0x20 1D72 01 ADD 1D73 83 DUP4 1D74 60 PUSH1 0x01 1D76 60 PUSH1 0x01 1D78 60 PUSH1 0xa0 1D7A 1B SHL 1D7B 03 SUB 1D7C 16 AND 1D7D 60 PUSH1 0x01 1D7F 60 PUSH1 0x01 1D81 60 PUSH1 0xa0 1D83 1B SHL 1D84 03 SUB 1D85 16 AND 1D86 81 DUP2 1D87 52 MSTORE 1D88 60 PUSH1 0x20 1D8A 01 ADD 1D8B 80 DUP1 1D8C 60 PUSH1 0x20 1D8E 01 ADD 1D8F 82 DUP3 1D90 81 DUP2 1D91 03 SUB 1D92 82 DUP3 1D93 52 MSTORE 1D94 83 DUP4 1D95 81 DUP2 1D96 81 DUP2 1D97 51 MLOAD 1D98 81 DUP2 1D99 52 MSTORE 1D9A 60 PUSH1 0x20 1D9C 01 ADD 1D9D 91 SWAP2 1D9E 50 POP 1D9F 80 DUP1 1DA0 51 MLOAD 1DA1 90 SWAP1 1DA2 60 PUSH1 0x20 1DA4 01 ADD 1DA5 90 SWAP1 1DA6 80 DUP1 1DA7 83 DUP4 1DA8 83 DUP4 1DA9 60 PUSH1 0x00 1DAB 5B JUMPDEST 1DAC 83 DUP4 1DAD 81 DUP2 1DAE 10 LT 1DAF 15 ISZERO 1DB0 61 PUSH2 0x1dc3 1DB3 57 *JUMPI // Stack delta = +15 // Outputs[25] // { // @1D2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1D34 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1D36 stack[-2] = 0x00 // @1D39 stack[-1] = stack[-3] // @1D45 stack[0] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1D4B stack[1] = 0x022c0d9f // @1D4D stack[2] = 0x00 // @1D4F stack[3] = stack[-3] // @1D51 stack[4] = stack[-10] // @1D52 stack[5] = memory[0x40:0x60] // @1D62 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x022c0d9f) << 0xe0 // @1D65 stack[6] = 0x04 + memory[0x40:0x60] // @1D69 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0x00 // @1D6F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-3] // @1D87 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-10] // @1D8A stack[7] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1D93 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]) // @1D99 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1D9D stack[8] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1DA5 stack[9] = 0x20 + memory[0x40:0x60] // @1DA5 stack[10] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1DA6 stack[11] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1DA7 stack[12] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1DA8 stack[13] = 0x20 + memory[0x40:0x60] // @1DA9 stack[14] = 0x00 // } // Block ends with conditional jump to 0x1dc3, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) label_1DB4: // Incoming jump from 0x1DB3, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1DB3, if not !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Inputs[4] // { // @1DB4 stack[-2] // @1DB5 stack[-1] // @1DB7 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1DB8 stack[-3] // } 1DB4 81 DUP2 1DB5 81 DUP2 1DB6 01 ADD 1DB7 51 MLOAD 1DB8 83 DUP4 1DB9 82 DUP3 1DBA 01 ADD 1DBB 52 MSTORE 1DBC 60 PUSH1 0x20 1DBE 01 ADD 1DBF 61 PUSH2 0x1dab 1DC2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1DBB memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1DBE stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1dab label_1DC3: // Incoming jump from 0x1DB3, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1DB3, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Inputs[3] // { // @1DC8 stack[-5] // @1DC8 stack[-6] // @1DCA stack[-7] // } 1DC3 5B JUMPDEST 1DC4 50 POP 1DC5 50 POP 1DC6 50 POP 1DC7 50 POP 1DC8 90 SWAP1 1DC9 50 POP 1DCA 90 SWAP1 1DCB 81 DUP2 1DCC 01 ADD 1DCD 90 SWAP1 1DCE 60 PUSH1 0x1f 1DD0 16 AND 1DD1 80 DUP1 1DD2 15 ISZERO 1DD3 61 PUSH2 0x1df0 1DD6 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1DCD stack[-7] = stack[-5] + stack[-7] // @1DD0 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x1df0, if !(0x1f & stack[-5]) label_1DD7: // Incoming jump from 0x1DD6, if not !(0x1f & stack[-5]) // Inputs[7] // { // @1DD7 stack[-1] // @1DD8 stack[-2] // @1DDB memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @1DF2 stack[-8] // @1DFD memory[0x40:0x60] // @1E04 stack[-10] // @1E06 address(stack[-10]).code.length // } 1DD7 80 DUP1 1DD8 82 DUP3 1DD9 03 SUB 1DDA 80 DUP1 1DDB 51 MLOAD 1DDC 60 PUSH1 0x01 1DDE 83 DUP4 1DDF 60 PUSH1 0x20 1DE1 03 SUB 1DE2 61 PUSH2 0x0100 1DE5 0A EXP 1DE6 03 SUB 1DE7 19 NOT 1DE8 16 AND 1DE9 81 DUP2 1DEA 52 MSTORE 1DEB 60 PUSH1 0x20 1DED 01 ADD 1DEE 91 SWAP2 1DEF 50 POP 1DF0 5B JUMPDEST 1DF1 50 POP 1DF2 95 SWAP6 1DF3 50 POP 1DF4 50 POP 1DF5 50 POP 1DF6 50 POP 1DF7 50 POP 1DF8 50 POP 1DF9 60 PUSH1 0x00 1DFB 60 PUSH1 0x40 1DFD 51 MLOAD 1DFE 80 DUP1 1DFF 83 DUP4 1E00 03 SUB 1E01 81 DUP2 1E02 60 PUSH1 0x00 1E04 87 DUP8 1E05 80 DUP1 1E06 3B EXTCODESIZE 1E07 15 ISZERO 1E08 80 DUP1 1E09 15 ISZERO 1E0A 61 PUSH2 0x1e12 1E0D 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @1DEA 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] // @1DF2 stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @1DF9 stack[-7] = 0x00 // @1DFD stack[-6] = memory[0x40:0x60] // @1E00 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @1E01 stack[-4] = memory[0x40:0x60] // @1E02 stack[-3] = 0x00 // @1E04 stack[-2] = stack[-10] // @1E07 stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x1e12, if !!address(stack[-10]).code.length label_1E0E: // Incoming jump from 0x1E0D, if not !!address(stack[-10]).code.length // Incoming jump from 0x1E0D, if not !!address(stack[-10]).code.length // Inputs[1] { @1E11 memory[0x00:0x00] } 1E0E 60 PUSH1 0x00 1E10 80 DUP1 1E11 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E11 revert(memory[0x00:0x00]); } // Block terminates label_1E12: // Incoming jump from 0x1E0D, if !!address(stack[-10]).code.length // Incoming jump from 0x1E0D, if !!address(stack[-10]).code.length // Inputs[9] // { // @1E14 msg.gas // @1E15 stack[-2] // @1E15 stack[-7] // @1E15 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1E15 stack[-6] // @1E15 memory[stack[-4]:stack[-4] + stack[-5]] // @1E15 stack[-3] // @1E15 stack[-5] // @1E15 stack[-4] // } 1E12 5B JUMPDEST 1E13 50 POP 1E14 5A GAS 1E15 F1 CALL 1E16 15 ISZERO 1E17 80 DUP1 1E18 15 ISZERO 1E19 61 PUSH2 0x1e26 1E1C 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1E15 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1E16 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 0x1e26, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1E1D: // Incoming jump from 0x1E1C, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @1E1D returndata.length // @1E21 returndata[0x00:0x00 + returndata.length] // @1E22 returndata.length // @1E25 memory[0x00:0x00 + returndata.length] // } 1E1D 3D RETURNDATASIZE 1E1E 60 PUSH1 0x00 1E20 80 DUP1 1E21 3E RETURNDATACOPY 1E22 3D RETURNDATASIZE 1E23 60 PUSH1 0x00 1E25 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E21 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1E25 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1E26: // Incoming jump from 0x1E1C, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1E36 stack[-16] } 1E26 5B JUMPDEST 1E27 50 POP 1E28 50 POP 1E29 50 POP 1E2A 50 POP 1E2B 50 POP 1E2C 50 POP 1E2D 50 POP 1E2E 50 POP 1E2F 50 POP 1E30 50 POP 1E31 50 POP 1E32 50 POP 1E33 50 POP 1E34 50 POP 1E35 50 POP 1E36 56 *JUMP // Stack delta = -16 // Block ends with unconditional jump to stack[-16] label_1E37: // Incoming call from 0x0955, returns to 0x0956 // Inputs[5] // { // @1E3B memory[0x40:0x60] // @1E50 stack[-2] // @1E53 stack[-1] // @1E57 memory[0x40:0x60] // @1E5B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1E37 5B JUMPDEST 1E38 60 PUSH1 0x40 1E3A 80 DUP1 1E3B 51 MLOAD 1E3C 60 PUSH1 0x00 1E3E 80 DUP1 1E3F 82 DUP3 1E40 52 MSTORE 1E41 60 PUSH1 0x20 1E43 82 DUP3 1E44 01 ADD 1E45 90 SWAP1 1E46 92 SWAP3 1E47 52 MSTORE 1E48 60 PUSH1 0x01 1E4A 60 PUSH1 0x01 1E4C 60 PUSH1 0xa0 1E4E 1B SHL 1E4F 03 SUB 1E50 84 DUP5 1E51 16 AND 1E52 90 SWAP1 1E53 83 DUP4 1E54 90 SWAP1 1E55 60 PUSH1 0x40 1E57 51 MLOAD 1E58 80 DUP1 1E59 82 DUP3 1E5A 80 DUP1 1E5B 51 MLOAD 1E5C 90 SWAP1 1E5D 60 PUSH1 0x20 1E5F 01 ADD 1E60 90 SWAP1 1E61 80 DUP1 1E62 83 DUP4 1E63 83 DUP4 1E64 5B JUMPDEST 1E65 60 PUSH1 0x20 1E67 83 DUP4 1E68 10 LT 1E69 61 PUSH2 0x1e83 1E6C 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @1E40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1E46 stack[0] = 0x00 // @1E47 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1E52 stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1E54 stack[2] = stack[-1] // @1E54 stack[3] = memory[0x40:0x60] // @1E57 stack[4] = memory[0x40:0x60] // @1E58 stack[5] = memory[0x40:0x60] // @1E60 stack[6] = 0x20 + memory[0x40:0x60] // @1E60 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1E61 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1E62 stack[9] = memory[0x40:0x60] // @1E63 stack[10] = 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x1e83, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_1E6D: // Incoming jump from 0x1E6C, if not stack[-3] < 0x20 // Incoming jump from 0x1E6C, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @1E6D stack[-1] // @1E6E memory[stack[-1]:stack[-1] + 0x20] // @1E6F stack[-2] // @1E75 stack[-3] // } 1E6D 80 DUP1 1E6E 51 MLOAD 1E6F 82 DUP3 1E70 52 MSTORE 1E71 60 PUSH1 0x1f 1E73 19 NOT 1E74 90 SWAP1 1E75 92 SWAP3 1E76 01 ADD 1E77 91 SWAP2 1E78 60 PUSH1 0x20 1E7A 91 SWAP2 1E7B 82 DUP3 1E7C 01 ADD 1E7D 91 SWAP2 1E7E 01 ADD 1E7F 61 PUSH2 0x1e64 1E82 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1E70 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1E77 stack[-3] = stack[-3] + ~0x1f // @1E7D stack[-2] = 0x20 + stack[-2] // @1E7E stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1e64 label_1E83: // Incoming jump from 0x1E6C, if stack[-3] < 0x20 // Incoming jump from 0x1E6C, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[16] // { // @1E86 stack[-3] // @1E91 stack[-1] // @1E92 memory[stack[-1]:stack[-1] + 0x20] // @1E95 stack[-2] // @1E96 memory[stack[-2]:stack[-2] + 0x20] // @1EA3 stack[-4] // @1EA3 stack[-5] // @1EA5 stack[-6] // @1EA6 stack[-8] // @1EAD memory[0x40:0x60] // @1EB2 stack[-9] // @1EB3 stack[-10] // @1EB4 msg.gas // @1EB5 address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1EB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @1EBA returndata.length // } 1E83 5B JUMPDEST 1E84 60 PUSH1 0x01 1E86 83 DUP4 1E87 60 PUSH1 0x20 1E89 03 SUB 1E8A 61 PUSH2 0x0100 1E8D 0A EXP 1E8E 03 SUB 1E8F 80 DUP1 1E90 19 NOT 1E91 82 DUP3 1E92 51 MLOAD 1E93 16 AND 1E94 81 DUP2 1E95 84 DUP5 1E96 51 MLOAD 1E97 16 AND 1E98 80 DUP1 1E99 82 DUP3 1E9A 17 OR 1E9B 85 DUP6 1E9C 52 MSTORE 1E9D 50 POP 1E9E 50 POP 1E9F 50 POP 1EA0 50 POP 1EA1 50 POP 1EA2 50 POP 1EA3 90 SWAP1 1EA4 50 POP 1EA5 01 ADD 1EA6 91 SWAP2 1EA7 50 POP 1EA8 50 POP 1EA9 60 PUSH1 0x00 1EAB 60 PUSH1 0x40 1EAD 51 MLOAD 1EAE 80 DUP1 1EAF 83 DUP4 1EB0 03 SUB 1EB1 81 DUP2 1EB2 85 DUP6 1EB3 87 DUP8 1EB4 5A GAS 1EB5 F1 CALL 1EB6 92 SWAP3 1EB7 50 POP 1EB8 50 POP 1EB9 50 POP 1EBA 3D RETURNDATASIZE 1EBB 80 DUP1 1EBC 60 PUSH1 0x00 1EBE 81 DUP2 1EBF 14 EQ 1EC0 61 PUSH2 0x1ee5 1EC3 57 *JUMPI // Stack delta = -7 // Outputs[5] // { // @1E9C memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1EB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1EB6 stack[-10] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1EBA stack[-9] = returndata.length // @1EBB stack[-8] = returndata.length // } // Block ends with conditional jump to 0x1ee5, if returndata.length == 0x00 label_1EC4: // Incoming jump from 0x1EC3, if not returndata.length == 0x00 // Inputs[6] // { // @1EC6 memory[0x40:0x60] // @1EC7 stack[-2] // @1ECE returndata.length // @1ED6 returndata.length // @1ED9 returndata.length // @1EE0 returndata[0x00:0x00 + returndata.length] // } 1EC4 60 PUSH1 0x40 1EC6 51 MLOAD 1EC7 91 SWAP2 1EC8 50 POP 1EC9 60 PUSH1 0x1f 1ECB 19 NOT 1ECC 60 PUSH1 0x3f 1ECE 3D RETURNDATASIZE 1ECF 01 ADD 1ED0 16 AND 1ED1 82 DUP3 1ED2 01 ADD 1ED3 60 PUSH1 0x40 1ED5 52 MSTORE 1ED6 3D RETURNDATASIZE 1ED7 82 DUP3 1ED8 52 MSTORE 1ED9 3D RETURNDATASIZE 1EDA 60 PUSH1 0x00 1EDC 60 PUSH1 0x20 1EDE 84 DUP5 1EDF 01 ADD 1EE0 3E RETURNDATACOPY 1EE1 61 PUSH2 0x1eea 1EE4 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1EC7 stack[-2] = memory[0x40:0x60] // @1ED5 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1ED8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1EE0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1eea label_1EE5: // Incoming jump from 0x1EC3, if returndata.length == 0x00 // Inputs[3] // { // @1EE8 stack[-2] // @1EED stack[-4] // @1EED stack[-3] // } 1EE5 5B JUMPDEST 1EE6 60 PUSH1 0x60 1EE8 91 SWAP2 1EE9 50 POP 1EEA 5B JUMPDEST 1EEB 50 POP 1EEC 50 POP 1EED 90 SWAP1 1EEE 50 POP 1EEF 80 DUP1 1EF0 61 PUSH2 0x1378 1EF3 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1EED stack[-4] = stack[-3] } // Block ends with conditional jump to 0x1378, if stack[-3] label_1EF4: // Incoming jump from 0x1EF3, if not stack[-3] // Incoming jump from 0x1EF3, if not stack[-3] // Inputs[3] // { // @1EF6 memory[0x40:0x60] // @1F24 memory[0x40:0x60] // @1F29 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1EF4 60 PUSH1 0x40 1EF6 51 MLOAD 1EF7 62 PUSH3 0x461bcd 1EFB 60 PUSH1 0xe5 1EFD 1B SHL 1EFE 81 DUP2 1EFF 52 MSTORE 1F00 60 PUSH1 0x04 1F02 01 ADD 1F03 80 DUP1 1F04 80 DUP1 1F05 60 PUSH1 0x20 1F07 01 ADD 1F08 82 DUP3 1F09 81 DUP2 1F0A 03 SUB 1F0B 82 DUP3 1F0C 52 MSTORE 1F0D 60 PUSH1 0x23 1F0F 81 DUP2 1F10 52 MSTORE 1F11 60 PUSH1 0x20 1F13 01 ADD 1F14 80 DUP1 1F15 61 PUSH2 0x274d 1F18 60 PUSH1 0x23 1F1A 91 SWAP2 1F1B 39 CODECOPY 1F1C 60 PUSH1 0x40 1F1E 01 ADD 1F1F 91 SWAP2 1F20 50 POP 1F21 50 POP 1F22 60 PUSH1 0x40 1F24 51 MLOAD 1F25 80 DUP1 1F26 91 SWAP2 1F27 03 SUB 1F28 90 SWAP1 1F29 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1EFF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1F0C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1F10 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x23 // @1F1B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x23] = code[0x274d:0x2770] // @1F29 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1F2A: // Incoming call from 0x09B8, returns to 0x09B9 // Inputs[8] // { // @1F2E memory[0x40:0x60] // @1F37 stack[-2] // @1F44 stack[-1] // @1F48 memory[0x40:0x60] // @1F5D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @1F73 memory[0x40:0x60] // @1F75 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1F7D stack[-3] // } 1F2A 5B JUMPDEST 1F2B 60 PUSH1 0x40 1F2D 80 DUP1 1F2E 51 MLOAD 1F2F 60 PUSH1 0x01 1F31 60 PUSH1 0x01 1F33 60 PUSH1 0xa0 1F35 1B SHL 1F36 03 SUB 1F37 84 DUP5 1F38 81 DUP2 1F39 16 AND 1F3A 60 PUSH1 0x24 1F3C 83 DUP4 1F3D 01 ADD 1F3E 52 MSTORE 1F3F 60 PUSH1 0x44 1F41 80 DUP1 1F42 83 DUP4 1F43 01 ADD 1F44 85 DUP6 1F45 90 SWAP1 1F46 52 MSTORE 1F47 83 DUP4 1F48 51 MLOAD 1F49 80 DUP1 1F4A 84 DUP5 1F4B 03 SUB 1F4C 90 SWAP1 1F4D 91 SWAP2 1F4E 01 ADD 1F4F 81 DUP2 1F50 52 MSTORE 1F51 60 PUSH1 0x64 1F53 90 SWAP1 1F54 92 SWAP3 1F55 01 ADD 1F56 83 DUP4 1F57 52 MSTORE 1F58 60 PUSH1 0x20 1F5A 82 DUP3 1F5B 01 ADD 1F5C 80 DUP1 1F5D 51 MLOAD 1F5E 60 PUSH1 0x01 1F60 60 PUSH1 0x01 1F62 60 PUSH1 0xe0 1F64 1B SHL 1F65 03 SUB 1F66 16 AND 1F67 63 PUSH4 0xa9059cbb 1F6C 60 PUSH1 0xe0 1F6E 1B SHL 1F6F 17 OR 1F70 81 DUP2 1F71 52 MSTORE 1F72 92 SWAP3 1F73 51 MLOAD 1F74 82 DUP3 1F75 51 MLOAD 1F76 60 PUSH1 0x00 1F78 94 SWAP5 1F79 60 PUSH1 0x60 1F7B 94 SWAP5 1F7C 93 SWAP4 1F7D 89 DUP10 1F7E 16 AND 1F7F 93 SWAP4 1F80 92 SWAP3 1F81 91 SWAP2 1F82 82 DUP3 1F83 91 SWAP2 1F84 90 SWAP1 1F85 80 DUP1 1F86 83 DUP4 1F87 83 DUP4 1F88 5B JUMPDEST 1F89 60 PUSH1 0x20 1F8B 83 DUP4 1F8C 10 LT 1F8D 61 PUSH2 0x1fa7 1F90 57 *JUMPI // Stack delta = +11 // Outputs[16] // { // @1F3E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1F46 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @1F50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x44 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1F57 memory[0x40:0x60] = memory[0x40:0x60] + 0x64 // @1F71 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0xa9059cbb << 0xe0) | ((0x01 << 0xe0) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @1F78 stack[0] = 0x00 // @1F7B stack[1] = 0x60 // @1F7F stack[2] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1F80 stack[3] = memory[0x40:0x60] // @1F81 stack[4] = memory[0x40:0x60] // @1F83 stack[5] = memory[0x40:0x60] // @1F84 stack[6] = memory[0x40:0x60] + 0x20 // @1F84 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1F85 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1F86 stack[9] = memory[0x40:0x60] // @1F87 stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x1fa7, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_1F91: // Incoming jump from 0x1F90, if not stack[-3] < 0x20 // Incoming jump from 0x1F90, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @1F91 stack[-1] // @1F92 memory[stack[-1]:stack[-1] + 0x20] // @1F93 stack[-2] // @1F99 stack[-3] // } 1F91 80 DUP1 1F92 51 MLOAD 1F93 82 DUP3 1F94 52 MSTORE 1F95 60 PUSH1 0x1f 1F97 19 NOT 1F98 90 SWAP1 1F99 92 SWAP3 1F9A 01 ADD 1F9B 91 SWAP2 1F9C 60 PUSH1 0x20 1F9E 91 SWAP2 1F9F 82 DUP3 1FA0 01 ADD 1FA1 91 SWAP2 1FA2 01 ADD 1FA3 61 PUSH2 0x1f88 1FA6 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1F94 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1F9B stack[-3] = stack[-3] + ~0x1f // @1FA1 stack[-2] = 0x20 + stack[-2] // @1FA2 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1f88 label_1FA7: // Incoming jump from 0x1F90, if stack[-3] < 0x20 // Incoming jump from 0x1F90, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[15] // { // @1FAA stack[-3] // @1FB5 stack[-1] // @1FB6 memory[stack[-1]:stack[-1] + 0x20] // @1FB9 stack[-2] // @1FBA memory[stack[-2]:stack[-2] + 0x20] // @1FC7 stack[-4] // @1FC7 stack[-5] // @1FC9 stack[-6] // @1FCA stack[-8] // @1FD1 memory[0x40:0x60] // @1FD8 stack[-9] // @1FD9 msg.gas // @1FDA memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @1FDA address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1FDE returndata.length // } 1FA7 5B JUMPDEST 1FA8 60 PUSH1 0x01 1FAA 83 DUP4 1FAB 60 PUSH1 0x20 1FAD 03 SUB 1FAE 61 PUSH2 0x0100 1FB1 0A EXP 1FB2 03 SUB 1FB3 80 DUP1 1FB4 19 NOT 1FB5 82 DUP3 1FB6 51 MLOAD 1FB7 16 AND 1FB8 81 DUP2 1FB9 84 DUP5 1FBA 51 MLOAD 1FBB 16 AND 1FBC 80 DUP1 1FBD 82 DUP3 1FBE 17 OR 1FBF 85 DUP6 1FC0 52 MSTORE 1FC1 50 POP 1FC2 50 POP 1FC3 50 POP 1FC4 50 POP 1FC5 50 POP 1FC6 50 POP 1FC7 90 SWAP1 1FC8 50 POP 1FC9 01 ADD 1FCA 91 SWAP2 1FCB 50 POP 1FCC 50 POP 1FCD 60 PUSH1 0x00 1FCF 60 PUSH1 0x40 1FD1 51 MLOAD 1FD2 80 DUP1 1FD3 83 DUP4 1FD4 03 SUB 1FD5 81 DUP2 1FD6 60 PUSH1 0x00 1FD8 86 DUP7 1FD9 5A GAS 1FDA F1 CALL 1FDB 91 SWAP2 1FDC 50 POP 1FDD 50 POP 1FDE 3D RETURNDATASIZE 1FDF 80 DUP1 1FE0 60 PUSH1 0x00 1FE2 81 DUP2 1FE3 14 EQ 1FE4 61 PUSH2 0x2009 1FE7 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @1FC0 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1FDA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1FDB stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1FDE stack[-8] = returndata.length // @1FDF stack[-7] = returndata.length // } // Block ends with conditional jump to 0x2009, if returndata.length == 0x00 label_1FE8: // Incoming jump from 0x1FE7, if not returndata.length == 0x00 // Inputs[6] // { // @1FEA memory[0x40:0x60] // @1FEB stack[-2] // @1FF2 returndata.length // @1FFA returndata.length // @1FFD returndata.length // @2004 returndata[0x00:0x00 + returndata.length] // } 1FE8 60 PUSH1 0x40 1FEA 51 MLOAD 1FEB 91 SWAP2 1FEC 50 POP 1FED 60 PUSH1 0x1f 1FEF 19 NOT 1FF0 60 PUSH1 0x3f 1FF2 3D RETURNDATASIZE 1FF3 01 ADD 1FF4 16 AND 1FF5 82 DUP3 1FF6 01 ADD 1FF7 60 PUSH1 0x40 1FF9 52 MSTORE 1FFA 3D RETURNDATASIZE 1FFB 82 DUP3 1FFC 52 MSTORE 1FFD 3D RETURNDATASIZE 1FFE 60 PUSH1 0x00 2000 60 PUSH1 0x20 2002 84 DUP5 2003 01 ADD 2004 3E RETURNDATACOPY 2005 61 PUSH2 0x200e 2008 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1FEB stack[-2] = memory[0x40:0x60] // @1FF9 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1FFC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @2004 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x200e label_2009: // Incoming jump from 0x1FE7, if returndata.length == 0x00 // Inputs[4] // { // @200C stack[-2] // @2010 stack[-4] // @2012 stack[-3] // @2012 stack[-5] // } 2009 5B JUMPDEST 200A 60 PUSH1 0x60 200C 91 SWAP2 200D 50 POP 200E 5B JUMPDEST 200F 50 POP 2010 91 SWAP2 2011 50 POP 2012 91 SWAP2 2013 50 POP 2014 81 DUP2 2015 80 DUP1 2016 15 ISZERO 2017 61 PUSH2 0x203c 201A 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @2010 stack[-4] = 0x60 // @2012 stack[-5] = stack[-3] // @2014 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x203c, if !stack[-3] label_201B: // Incoming jump from 0x201A, if not !stack[-3] // Incoming jump from 0x201A, if not !stack[-3] // Inputs[2] // { // @201C stack[-2] // @201D memory[stack[-2]:stack[-2] + 0x20] // } 201B 50 POP 201C 80 DUP1 201D 51 MLOAD 201E 15 ISZERO 201F 80 DUP1 2020 61 PUSH2 0x203c 2023 57 *JUMPI // Stack delta = +0 // Outputs[1] { @201E stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x203c, if !memory[stack[-2]:stack[-2] + 0x20] label_2024: // Incoming jump from 0x2023, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @2025 stack[-2] // @202B memory[stack[-2]:stack[-2] + 0x20] // } 2024 50 POP 2025 80 DUP1 2026 80 DUP1 2027 60 PUSH1 0x20 2029 01 ADD 202A 90 SWAP1 202B 51 MLOAD 202C 60 PUSH1 0x20 202E 81 DUP2 202F 10 LT 2030 15 ISZERO 2031 61 PUSH2 0x2039 2034 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @202A stack[-1] = 0x20 + stack[-2] // @202B stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x2039, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_2035: // Incoming jump from 0x2034, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @2038 memory[0x00:0x00] } 2035 60 PUSH1 0x00 2037 80 DUP1 2038 FD *REVERT // Stack delta = +0 // Outputs[1] { @2038 revert(memory[0x00:0x00]); } // Block terminates label_2039: // Incoming jump from 0x2034, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @203B stack[-2] // @203B memory[stack[-2]:stack[-2] + 0x20] // } 2039 5B JUMPDEST 203A 50 POP 203B 51 MLOAD // Stack delta = -1 // Outputs[1] { @203B stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_203C: // Incoming jump from 0x2023, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x201A, if !stack[-3] // Incoming jump from 0x201A, if !stack[-3] // Incoming jump from 0x203B // Inputs[1] { @2040 stack[-1] } 203C 5B JUMPDEST 203D 61 PUSH2 0x17ed 2040 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17ed, if stack[-1] label_2041: // Incoming jump from 0x2040, if not stack[-1] // Inputs[3] // { // @2044 memory[0x40:0x60] // @2083 memory[0x40:0x60] // @208C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2041 60 PUSH1 0x40 2043 80 DUP1 2044 51 MLOAD 2045 62 PUSH3 0x461bcd 2049 60 PUSH1 0xe5 204B 1B SHL 204C 81 DUP2 204D 52 MSTORE 204E 60 PUSH1 0x20 2050 60 PUSH1 0x04 2052 82 DUP3 2053 01 ADD 2054 52 MSTORE 2055 60 PUSH1 0x1f 2057 60 PUSH1 0x24 2059 82 DUP3 205A 01 ADD 205B 52 MSTORE 205C 7F PUSH32 0x5472616e7366657248656c7065723a205452414e534645525f4641494c454400 207D 60 PUSH1 0x44 207F 82 DUP3 2080 01 ADD 2081 52 MSTORE 2082 90 SWAP1 2083 51 MLOAD 2084 90 SWAP1 2085 81 DUP2 2086 90 SWAP1 2087 03 SUB 2088 60 PUSH1 0x64 208A 01 ADD 208B 90 SWAP1 208C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @204D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2054 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @205B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @2081 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5472616e7366657248656c7065723a205452414e534645525f4641494c454400 // @208C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_208D: // Incoming call from 0x1163, returns to 0x1164 // Incoming call from 0x15B3, returns to 0x15B4 // Inputs[2] // { // @2092 stack[-1] // @2093 memory[stack[-1]:stack[-1] + 0x20] // } 208D 5B JUMPDEST 208E 60 PUSH1 0x60 2090 60 PUSH1 0x02 2092 82 DUP3 2093 51 MLOAD 2094 10 LT 2095 15 ISZERO 2096 61 PUSH2 0x20e6 2099 57 *JUMPI // Stack delta = +1 // Outputs[1] { @208E stack[0] = 0x60 } // Block ends with conditional jump to 0x20e6, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) label_209A: // Incoming jump from 0x2099, if not !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) // Inputs[3] // { // @209D memory[0x40:0x60] // @20DC memory[0x40:0x60] // @20E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 209A 60 PUSH1 0x40 209C 80 DUP1 209D 51 MLOAD 209E 62 PUSH3 0x461bcd 20A2 60 PUSH1 0xe5 20A4 1B SHL 20A5 81 DUP2 20A6 52 MSTORE 20A7 60 PUSH1 0x20 20A9 60 PUSH1 0x04 20AB 82 DUP3 20AC 01 ADD 20AD 52 MSTORE 20AE 60 PUSH1 0x18 20B0 60 PUSH1 0x24 20B2 82 DUP3 20B3 01 ADD 20B4 52 MSTORE 20B5 7F PUSH32 0x514e574c6962726172793a20494e56414c49445f504154480000000000000000 20D6 60 PUSH1 0x44 20D8 82 DUP3 20D9 01 ADD 20DA 52 MSTORE 20DB 90 SWAP1 20DC 51 MLOAD 20DD 90 SWAP1 20DE 81 DUP2 20DF 90 SWAP1 20E0 03 SUB 20E1 60 PUSH1 0x64 20E3 01 ADD 20E4 90 SWAP1 20E5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @20A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @20AD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @20B4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @20DA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x514e574c6962726172793a20494e56414c49445f504154480000000000000000 // @20E5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_20E6: // Incoming jump from 0x2099, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x02) // Inputs[2] // { // @20E7 stack[-2] // @20E8 memory[stack[-2]:stack[-2] + 0x20] // } 20E6 5B JUMPDEST 20E7 81 DUP2 20E8 51 MLOAD 20E9 67 PUSH8 0xffffffffffffffff 20F2 81 DUP2 20F3 11 GT 20F4 80 DUP1 20F5 15 ISZERO 20F6 61 PUSH2 0x20fe 20F9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20E8 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @20F3 stack[1] = memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x20fe, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_20FA: // Incoming jump from 0x20F9, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @20FD memory[0x00:0x00] } 20FA 60 PUSH1 0x00 20FC 80 DUP1 20FD FD *REVERT // Stack delta = +0 // Outputs[1] { @20FD revert(memory[0x00:0x00]); } // Block terminates label_20FE: // Incoming jump from 0x20F9, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2102 memory[0x40:0x60] // @2103 stack[-2] // } 20FE 5B JUMPDEST 20FF 50 POP 2100 60 PUSH1 0x40 2102 51 MLOAD 2103 90 SWAP1 2104 80 DUP1 2105 82 DUP3 2106 52 MSTORE 2107 80 DUP1 2108 60 PUSH1 0x20 210A 02 MUL 210B 60 PUSH1 0x20 210D 01 ADD 210E 82 DUP3 210F 01 ADD 2110 60 PUSH1 0x40 2112 52 MSTORE 2113 80 DUP1 2114 15 ISZERO 2115 61 PUSH2 0x2128 2118 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2103 stack[-2] = memory[0x40:0x60] // @2103 stack[-1] = stack[-2] // @2106 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @2112 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x2128, if !stack[-2] label_2119: // Incoming jump from 0x2118, if not !stack[-2] // Inputs[7] // { // @2119 stack[-2] // @211F stack[-1] // @2122 msg.data.length // @2124 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @212A stack[-3] // @212C stack[-5] // @2131 memory[stack[-2]:stack[-2] + 0x20] // } 2119 81 DUP2 211A 60 PUSH1 0x20 211C 01 ADD 211D 60 PUSH1 0x20 211F 82 DUP3 2120 02 MUL 2121 80 DUP1 2122 36 CALLDATASIZE 2123 83 DUP4 2124 37 CALLDATACOPY 2125 01 ADD 2126 90 SWAP1 2127 50 POP 2128 5B JUMPDEST 2129 50 POP 212A 90 SWAP1 212B 50 POP 212C 82 DUP3 212D 81 DUP2 212E 60 PUSH1 0x00 2130 81 DUP2 2131 51 MLOAD 2132 81 DUP2 2133 10 LT 2134 61 PUSH2 0x2139 2137 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2124 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @212A stack[-3] = stack[-2] // @212C stack[-2] = stack[-5] // @212D stack[-1] = stack[-2] // @212E stack[0] = 0x00 // } // Block ends with conditional jump to 0x2139, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_2138: // Incoming jump from 0x2137, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x2137, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 2138 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2138 assert(); } // Block terminates label_2139: // Incoming jump from 0x2137, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x2137, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @213C stack[-1] // @2140 stack[-2] // @2141 stack[-3] // @214B stack[-5] // @214C memory[stack[-5]:stack[-5] + 0x20] // } 2139 5B JUMPDEST 213A 60 PUSH1 0x20 213C 02 MUL 213D 60 PUSH1 0x20 213F 01 ADD 2140 01 ADD 2141 81 DUP2 2142 81 DUP2 2143 52 MSTORE 2144 50 POP 2145 50 POP 2146 60 PUSH1 0x00 2148 5B JUMPDEST 2149 60 PUSH1 0x01 214B 83 DUP4 214C 51 MLOAD 214D 03 SUB 214E 81 DUP2 214F 10 LT 2150 15 ISZERO 2151 61 PUSH2 0x21d1 2154 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2143 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @2146 stack[-3] = 0x00 // } // Block ends with conditional jump to 0x21d1, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20] - 0x01) label_2155: // Incoming jump from 0x2154, if not !(0x00 < memory[stack[-5]:stack[-5] + 0x20] - 0x01) // Incoming jump from 0x2154, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20] - 0x01) // Inputs[4] // { // @215B stack[-5] // @215C stack[-3] // @215D stack[-1] // @215F memory[stack[-3]:stack[-3] + 0x20] // } 2155 60 PUSH1 0x00 2157 80 DUP1 2158 61 PUSH2 0x218b 215B 87 DUP8 215C 86 DUP7 215D 85 DUP6 215E 81 DUP2 215F 51 MLOAD 2160 81 DUP2 2161 10 LT 2162 61 PUSH2 0x2167 2165 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @2155 stack[0] = 0x00 // @2157 stack[1] = 0x00 // @2158 stack[2] = 0x218b // @215B stack[3] = stack[-5] // @215C stack[4] = stack[-3] // @215D stack[5] = stack[-1] // } // Block ends with conditional call to 0x2167, returns to 0x218B, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_2166: // Incoming jump from 0x2165, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 2166 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2166 assert(); } // Block terminates label_2167: // Incoming call from 0x2165, returns to 0x218B, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @216A stack[-1] // @216E stack[-2] // @216F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2170 stack[-9] // @2171 stack[-7] // @2176 memory[stack[-9]:stack[-9] + 0x20] // } 2167 5B JUMPDEST 2168 60 PUSH1 0x20 216A 02 MUL 216B 60 PUSH1 0x20 216D 01 ADD 216E 01 ADD 216F 51 MLOAD 2170 87 DUP8 2171 86 DUP7 2172 60 PUSH1 0x01 2174 01 ADD 2175 81 DUP2 2176 51 MLOAD 2177 81 DUP2 2178 10 LT 2179 61 PUSH2 0x217e 217C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @216F stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2170 stack[-1] = stack[-9] // @2174 stack[0] = 0x01 + stack[-7] // } // Block ends with conditional jump to 0x217e, if 0x01 + stack[-7] < memory[stack[-9]:stack[-9] + 0x20] label_217D: // Incoming jump from 0x217C, if not 0x01 + stack[-7] < memory[stack[-9]:stack[-9] + 0x20] 217D FE *ASSERT // Stack delta = +0 // Outputs[1] { @217D assert(); } // Block terminates label_217E: // Incoming jump from 0x217C, if 0x01 + stack[-7] < memory[stack[-9]:stack[-9] + 0x20] // Inputs[3] // { // @2181 stack[-1] // @2185 stack[-2] // @2186 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 217E 5B JUMPDEST 217F 60 PUSH1 0x20 2181 02 MUL 2182 60 PUSH1 0x20 2184 01 ADD 2185 01 ADD 2186 51 MLOAD 2187 61 PUSH2 0x2590 218A 56 *JUMP // Stack delta = -1 // Outputs[1] { @2186 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2590 label_218B: // Incoming return from call to 0x2167 at 0x2165 // Inputs[7] // { // @218C stack[-3] // @218C stack[-1] // @218E stack[-2] // @218E stack[-4] // @2193 stack[-6] // @2194 stack[-5] // @2196 memory[stack[-6]:stack[-6] + 0x20] // } 218B 5B JUMPDEST 218C 91 SWAP2 218D 50 POP 218E 91 SWAP2 218F 50 POP 2190 61 PUSH2 0x21ad 2193 84 DUP5 2194 84 DUP5 2195 81 DUP2 2196 51 MLOAD 2197 81 DUP2 2198 10 LT 2199 61 PUSH2 0x219e 219C 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @218C stack[-3] = stack[-1] // @218E stack[-4] = stack[-2] // @2190 stack[-2] = 0x21ad // @2193 stack[-1] = stack[-6] // @2194 stack[0] = stack[-5] // } // Block ends with conditional call to 0x219e, returns to 0x21AD, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] label_219D: // Incoming jump from 0x219C, if not stack[-5] < memory[stack[-6]:stack[-6] + 0x20] 219D FE *ASSERT // Stack delta = +0 // Outputs[1] { @219D assert(); } // Block terminates label_219E: // Incoming call from 0x219C, returns to 0x21AD, if stack[-5] < memory[stack[-6]:stack[-6] + 0x20] // Inputs[5] // { // @21A1 stack[-1] // @21A5 stack[-2] // @21A6 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @21A7 stack[-5] // @21A8 stack[-4] // } 219E 5B JUMPDEST 219F 60 PUSH1 0x20 21A1 02 MUL 21A2 60 PUSH1 0x20 21A4 01 ADD 21A5 01 ADD 21A6 51 MLOAD 21A7 83 DUP4 21A8 83 DUP4 21A9 61 PUSH2 0x24a0 21AC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @21A6 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @21A7 stack[-1] = stack[-5] // @21A8 stack[0] = stack[-4] // } // Block ends with unconditional jump to 0x24a0 label_21AD: // Incoming return from call to 0x219E at 0x219C // Inputs[3] // { // @21AE stack[-5] // @21AF stack[-4] // @21B4 memory[stack[-5]:stack[-5] + 0x20] // } 21AD 5B JUMPDEST 21AE 84 DUP5 21AF 84 DUP5 21B0 60 PUSH1 0x01 21B2 01 ADD 21B3 81 DUP2 21B4 51 MLOAD 21B5 81 DUP2 21B6 10 LT 21B7 61 PUSH2 0x21bc 21BA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21AE stack[0] = stack[-5] // @21B2 stack[1] = 0x01 + stack[-4] // } // Block ends with conditional jump to 0x21bc, if 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_21BB: // Incoming jump from 0x21BA, if not 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] 21BB FE *ASSERT // Stack delta = +0 // Outputs[1] { @21BB assert(); } // Block terminates label_21BC: // Incoming jump from 0x21BA, if 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @21BF stack[-1] // @21C2 stack[-2] // @21C7 stack[-3] // @21CC stack[-6] // } 21BC 5B JUMPDEST 21BD 60 PUSH1 0x20 21BF 90 SWAP1 21C0 81 DUP2 21C1 02 MUL 21C2 91 SWAP2 21C3 90 SWAP1 21C4 91 SWAP2 21C5 01 ADD 21C6 01 ADD 21C7 52 MSTORE 21C8 50 POP 21C9 50 POP 21CA 60 PUSH1 0x01 21CC 01 ADD 21CD 61 PUSH2 0x2148 21D0 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @21C7 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @21CC stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x2148 label_21D1: // Incoming jump from 0x2154, if !(0x00 < memory[stack[-5]:stack[-5] + 0x20] - 0x01) // Incoming jump from 0x2154, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20] - 0x01) // Inputs[3] // { // @21D3 stack[-2] // @21D3 stack[-6] // @21D4 stack[-5] // } 21D1 5B JUMPDEST 21D2 50 POP 21D3 93 SWAP4 21D4 92 SWAP3 21D5 50 POP 21D6 50 POP 21D7 50 POP 21D8 56 *JUMP // Stack delta = -5 // Outputs[1] { @21D3 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_21D9: // Incoming call from 0x16D5, returns to 0x1293 // Incoming call from 0x1292, returns to 0x1293 // Inputs[2] // { // @21DD stack[-3] // @21E1 memory[stack[-3]:stack[-3] + 0x20] // } 21D9 5B JUMPDEST 21DA 60 PUSH1 0x00 21DC 80 DUP1 21DD 84 DUP5 21DE 60 PUSH1 0x00 21E0 81 DUP2 21E1 51 MLOAD 21E2 81 DUP2 21E3 10 LT 21E4 61 PUSH2 0x21e9 21E7 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @21DA stack[0] = 0x00 // @21DC stack[1] = 0x00 // @21DD stack[2] = stack[-3] // @21DE stack[3] = 0x00 // } // Block ends with conditional jump to 0x21e9, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] label_21E8: // Incoming jump from 0x21E7, if not 0x00 < memory[stack[-3]:stack[-3] + 0x20] 21E8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @21E8 assert(); } // Block terminates label_21E9: // Incoming jump from 0x21E7, if 0x00 < memory[stack[-3]:stack[-3] + 0x20] // Inputs[5] // { // @21EC stack[-1] // @21F0 stack[-2] // @21F1 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @21F2 stack[-7] // @21F6 memory[stack[-7]:stack[-7] + 0x20] // } 21E9 5B JUMPDEST 21EA 60 PUSH1 0x20 21EC 02 MUL 21ED 60 PUSH1 0x20 21EF 01 ADD 21F0 01 ADD 21F1 51 MLOAD 21F2 85 DUP6 21F3 60 PUSH1 0x01 21F5 81 DUP2 21F6 51 MLOAD 21F7 81 DUP2 21F8 10 LT 21F9 61 PUSH2 0x21fe 21FC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @21F1 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @21F2 stack[-1] = stack[-7] // @21F3 stack[0] = 0x01 // } // Block ends with conditional jump to 0x21fe, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] label_21FD: // Incoming jump from 0x21FC, if not 0x01 < memory[stack[-7]:stack[-7] + 0x20] 21FD FE *ASSERT // Stack delta = +0 // Outputs[1] { @21FD assert(); } // Block terminates label_21FE: // Incoming jump from 0x21FC, if 0x01 < memory[stack[-7]:stack[-7] + 0x20] // Inputs[6] // { // @2201 stack[-1] // @2205 stack[-2] // @2206 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2207 stack[-4] // @2209 stack[-3] // @2209 stack[-5] // } 21FE 5B JUMPDEST 21FF 60 PUSH1 0x20 2201 02 MUL 2202 60 PUSH1 0x20 2204 01 ADD 2205 01 ADD 2206 51 MLOAD 2207 91 SWAP2 2208 50 POP 2209 91 SWAP2 220A 50 POP 220B 60 PUSH1 0x00 220D 61 PUSH2 0x2216 2210 83 DUP4 2211 83 DUP4 2212 61 PUSH2 0x236c 2215 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2207 stack[-4] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2209 stack[-5] = stack[-3] // @220B stack[-3] = 0x00 // @220D stack[-2] = 0x2216 // @2210 stack[-1] = stack[-3] // @2211 stack[0] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } // Block ends with call to 0x236c, returns to 0x2216 label_2216: // Incoming return from call to 0x236C at 0x2215 // Inputs[4] // { // @2218 stack[-2] // @2218 stack[-3] // @221C stack[-9] // @2220 memory[stack[-9]:stack[-9] + 0x20] // } 2216 5B JUMPDEST 2217 50 POP 2218 90 SWAP1 2219 50 POP 221A 60 PUSH1 0x00 221C 87 DUP8 221D 60 PUSH1 0x01 221F 81 DUP2 2220 51 MLOAD 2221 81 DUP2 2222 10 LT 2223 61 PUSH2 0x2228 2226 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2218 stack[-3] = stack[-2] // @221A stack[-2] = 0x00 // @221C stack[-1] = stack[-9] // @221D stack[0] = 0x01 // } // Block ends with conditional jump to 0x2228, if 0x01 < memory[stack[-9]:stack[-9] + 0x20] label_2227: // Incoming jump from 0x2226, if not 0x01 < memory[stack[-9]:stack[-9] + 0x20] 2227 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2227 assert(); } // Block terminates label_2228: // Incoming jump from 0x2226, if 0x01 < memory[stack[-9]:stack[-9] + 0x20] // Inputs[6] // { // @222B stack[-1] // @222F stack[-2] // @2230 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2231 stack[-3] // @2236 stack[-4] // @2240 stack[-6] // } 2228 5B JUMPDEST 2229 60 PUSH1 0x20 222B 02 MUL 222C 60 PUSH1 0x20 222E 01 ADD 222F 01 ADD 2230 51 MLOAD 2231 90 SWAP1 2232 50 POP 2233 60 PUSH1 0x00 2235 80 DUP1 2236 83 DUP4 2237 60 PUSH1 0x01 2239 60 PUSH1 0x01 223B 60 PUSH1 0xa0 223D 1B SHL 223E 03 SUB 223F 16 AND 2240 86 DUP7 2241 60 PUSH1 0x01 2243 60 PUSH1 0x01 2245 60 PUSH1 0xa0 2247 1B SHL 2248 03 SUB 2249 16 AND 224A 14 EQ 224B 61 PUSH2 0x2256 224E 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2231 stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @2233 stack[-2] = 0x00 // @2235 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2256, if (0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-4] label_224F: // Incoming jump from 0x224E, if not (0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-4] // Inputs[1] { @224F stack[-3] } 224F 82 DUP3 2250 60 PUSH1 0x00 2252 61 PUSH2 0x225a 2255 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @224F stack[0] = stack[-3] // @2250 stack[1] = 0x00 // } // Block ends with unconditional jump to 0x225a label_2256: // Incoming jump from 0x224E, if (0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-4] // Inputs[9] // { // @2259 stack[-3] // @225E memory[0x40:0x60] // @226C stack[-2] // @226F stack[-1] // @2279 stack[-7] // @2286 stack[-8] // @228C memory[0x40:0x60] // @22CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @22D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 2256 5B JUMPDEST 2257 60 PUSH1 0x00 2259 83 DUP4 225A 5B JUMPDEST 225B 60 PUSH1 0x40 225D 80 DUP1 225E 51 MLOAD 225F 60 PUSH1 0x00 2261 80 DUP1 2262 82 DUP3 2263 52 MSTORE 2264 60 PUSH1 0x20 2266 82 DUP3 2267 01 ADD 2268 90 SWAP1 2269 92 SWAP3 226A 52 MSTORE 226B 92 SWAP3 226C 94 SWAP5 226D 50 POP 226E 90 SWAP1 226F 92 SWAP3 2270 50 POP 2271 60 PUSH1 0x01 2273 60 PUSH1 0x01 2275 60 PUSH1 0xa0 2277 1B SHL 2278 03 SUB 2279 89 DUP10 227A 16 AND 227B 91 SWAP2 227C 63 PUSH4 0x022c0d9f 2281 91 SWAP2 2282 85 DUP6 2283 91 SWAP2 2284 85 DUP6 2285 91 SWAP2 2286 8D DUP14 2287 91 SWAP2 2288 90 SWAP1 2289 50 POP 228A 60 PUSH1 0x40 228C 51 MLOAD 228D 85 DUP6 228E 63 PUSH4 0xffffffff 2293 16 AND 2294 60 PUSH1 0xe0 2296 1B SHL 2297 81 DUP2 2298 52 MSTORE 2299 60 PUSH1 0x04 229B 01 ADD 229C 80 DUP1 229D 85 DUP6 229E 81 DUP2 229F 52 MSTORE 22A0 60 PUSH1 0x20 22A2 01 ADD 22A3 84 DUP5 22A4 81 DUP2 22A5 52 MSTORE 22A6 60 PUSH1 0x20 22A8 01 ADD 22A9 83 DUP4 22AA 60 PUSH1 0x01 22AC 60 PUSH1 0x01 22AE 60 PUSH1 0xa0 22B0 1B SHL 22B1 03 SUB 22B2 16 AND 22B3 60 PUSH1 0x01 22B5 60 PUSH1 0x01 22B7 60 PUSH1 0xa0 22B9 1B SHL 22BA 03 SUB 22BB 16 AND 22BC 81 DUP2 22BD 52 MSTORE 22BE 60 PUSH1 0x20 22C0 01 ADD 22C1 80 DUP1 22C2 60 PUSH1 0x20 22C4 01 ADD 22C5 82 DUP3 22C6 81 DUP2 22C7 03 SUB 22C8 82 DUP3 22C9 52 MSTORE 22CA 83 DUP4 22CB 81 DUP2 22CC 81 DUP2 22CD 51 MLOAD 22CE 81 DUP2 22CF 52 MSTORE 22D0 60 PUSH1 0x20 22D2 01 ADD 22D3 91 SWAP2 22D4 50 POP 22D5 80 DUP1 22D6 51 MLOAD 22D7 90 SWAP1 22D8 60 PUSH1 0x20 22DA 01 ADD 22DB 90 SWAP1 22DC 80 DUP1 22DD 83 DUP4 22DE 83 DUP4 22DF 60 PUSH1 0x00 22E1 5B JUMPDEST 22E2 83 DUP4 22E3 81 DUP2 22E4 10 LT 22E5 15 ISZERO 22E6 61 PUSH2 0x22f9 22E9 57 *JUMPI // Stack delta = +15 // Outputs[25] // { // @2263 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @226A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @226C stack[-2] = 0x00 // @226F stack[-1] = stack[-3] // @227B stack[0] = stack[-7] & (0x01 << 0xa0) - 0x01 // @2281 stack[1] = 0x022c0d9f // @2283 stack[2] = 0x00 // @2285 stack[3] = stack[-3] // @2287 stack[4] = stack[-8] // @2288 stack[5] = memory[0x40:0x60] // @2298 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x022c0d9f) << 0xe0 // @229B stack[6] = 0x04 + memory[0x40:0x60] // @229F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0x00 // @22A5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = stack[-3] // @22BD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-8] // @22C0 stack[7] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @22C9 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]) // @22CF memory[0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @22D3 stack[8] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @22DB stack[9] = 0x20 + memory[0x40:0x60] // @22DB stack[10] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @22DC stack[11] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @22DD stack[12] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @22DE stack[13] = 0x20 + memory[0x40:0x60] // @22DF stack[14] = 0x00 // } // Block ends with conditional jump to 0x22f9, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) label_22EA: // Incoming jump from 0x22E9, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x22E9, if not !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Inputs[4] // { // @22EA stack[-2] // @22EB stack[-1] // @22ED memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @22EE stack[-3] // } 22EA 81 DUP2 22EB 81 DUP2 22EC 01 ADD 22ED 51 MLOAD 22EE 83 DUP4 22EF 82 DUP3 22F0 01 ADD 22F1 52 MSTORE 22F2 60 PUSH1 0x20 22F4 01 ADD 22F5 61 PUSH2 0x22e1 22F8 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @22F1 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @22F4 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x22e1 label_22F9: // Incoming jump from 0x22E9, if !(stack[-1] < stack[-4]) // Incoming jump from 0x22E9, if !(0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]) // Inputs[3] // { // @22FE stack[-6] // @22FE stack[-5] // @2300 stack[-7] // } 22F9 5B JUMPDEST 22FA 50 POP 22FB 50 POP 22FC 50 POP 22FD 50 POP 22FE 90 SWAP1 22FF 50 POP 2300 90 SWAP1 2301 81 DUP2 2302 01 ADD 2303 90 SWAP1 2304 60 PUSH1 0x1f 2306 16 AND 2307 80 DUP1 2308 15 ISZERO 2309 61 PUSH2 0x2326 230C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @2303 stack[-7] = stack[-5] + stack[-7] // @2306 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x2326, if !(0x1f & stack[-5]) label_230D: // Incoming jump from 0x230C, if not !(0x1f & stack[-5]) // Inputs[7] // { // @230D stack[-1] // @230E stack[-2] // @2311 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @2328 stack[-8] // @2333 memory[0x40:0x60] // @233A stack[-10] // @233C address(stack[-10]).code.length // } 230D 80 DUP1 230E 82 DUP3 230F 03 SUB 2310 80 DUP1 2311 51 MLOAD 2312 60 PUSH1 0x01 2314 83 DUP4 2315 60 PUSH1 0x20 2317 03 SUB 2318 61 PUSH2 0x0100 231B 0A EXP 231C 03 SUB 231D 19 NOT 231E 16 AND 231F 81 DUP2 2320 52 MSTORE 2321 60 PUSH1 0x20 2323 01 ADD 2324 91 SWAP2 2325 50 POP 2326 5B JUMPDEST 2327 50 POP 2328 95 SWAP6 2329 50 POP 232A 50 POP 232B 50 POP 232C 50 POP 232D 50 POP 232E 50 POP 232F 60 PUSH1 0x00 2331 60 PUSH1 0x40 2333 51 MLOAD 2334 80 DUP1 2335 83 DUP4 2336 03 SUB 2337 81 DUP2 2338 60 PUSH1 0x00 233A 87 DUP8 233B 80 DUP1 233C 3B EXTCODESIZE 233D 15 ISZERO 233E 80 DUP1 233F 15 ISZERO 2340 61 PUSH2 0x2348 2343 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @2320 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] // @2328 stack[-8] = 0x20 + (stack[-2] - stack[-1]) // @232F stack[-7] = 0x00 // @2333 stack[-6] = memory[0x40:0x60] // @2336 stack[-5] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] // @2337 stack[-4] = memory[0x40:0x60] // @2338 stack[-3] = 0x00 // @233A stack[-2] = stack[-10] // @233D stack[-1] = !address(stack[-10]).code.length // } // Block ends with conditional jump to 0x2348, if !!address(stack[-10]).code.length label_2344: // Incoming jump from 0x2343, if not !!address(stack[-10]).code.length // Incoming jump from 0x2343, if not !!address(stack[-10]).code.length // Inputs[1] { @2347 memory[0x00:0x00] } 2344 60 PUSH1 0x00 2346 80 DUP1 2347 FD *REVERT // Stack delta = +0 // Outputs[1] { @2347 revert(memory[0x00:0x00]); } // Block terminates label_2348: // Incoming jump from 0x2343, if !!address(stack[-10]).code.length // Incoming jump from 0x2343, if !!address(stack[-10]).code.length // Inputs[9] // { // @234A msg.gas // @234B stack[-3] // @234B address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @234B stack[-2] // @234B stack[-5] // @234B stack[-7] // @234B memory[stack[-4]:stack[-4] + stack[-5]] // @234B stack[-6] // @234B stack[-4] // } 2348 5B JUMPDEST 2349 50 POP 234A 5A GAS 234B F1 CALL 234C 15 ISZERO 234D 80 DUP1 234E 15 ISZERO 234F 61 PUSH2 0x235c 2352 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @234B memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @234C 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 0x235c, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2353: // Incoming jump from 0x2352, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2353 returndata.length // @2357 returndata[0x00:0x00 + returndata.length] // @2358 returndata.length // @235B memory[0x00:0x00 + returndata.length] // } 2353 3D RETURNDATASIZE 2354 60 PUSH1 0x00 2356 80 DUP1 2357 3E RETURNDATACOPY 2358 3D RETURNDATASIZE 2359 60 PUSH1 0x00 235B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2357 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @235B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_235C: // Incoming jump from 0x2352, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @236B stack[-15] } 235C 5B JUMPDEST 235D 50 POP 235E 50 POP 235F 50 POP 2360 50 POP 2361 50 POP 2362 50 POP 2363 50 POP 2364 50 POP 2365 50 POP 2366 50 POP 2367 50 POP 2368 50 POP 2369 50 POP 236A 50 POP 236B 56 *JUMP // Stack delta = -15 // Block ends with unconditional jump to stack[-15] label_236C: // Incoming call from 0x1BA8, returns to 0x1BA9 // Incoming call from 0x1802, returns to 0x1803 // Incoming call from 0x259E, returns to 0x259F // Incoming call from 0x2215, returns to 0x2216 // Inputs[2] // { // @2370 stack[-1] // @237A stack[-2] // } 236C 5B JUMPDEST 236D 60 PUSH1 0x00 236F 80 DUP1 2370 82 DUP3 2371 60 PUSH1 0x01 2373 60 PUSH1 0x01 2375 60 PUSH1 0xa0 2377 1B SHL 2378 03 SUB 2379 16 AND 237A 84 DUP5 237B 60 PUSH1 0x01 237D 60 PUSH1 0x01 237F 60 PUSH1 0xa0 2381 1B SHL 2382 03 SUB 2383 16 AND 2384 14 EQ 2385 15 ISZERO 2386 61 PUSH2 0x23c0 2389 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @236D stack[0] = 0x00 // @236F stack[1] = 0x00 // } // Block ends with conditional jump to 0x23c0, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_238A: // Incoming jump from 0x2389, if not !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @238C memory[0x40:0x60] // @23BA memory[0x40:0x60] // @23BF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 238A 60 PUSH1 0x40 238C 51 MLOAD 238D 62 PUSH3 0x461bcd 2391 60 PUSH1 0xe5 2393 1B SHL 2394 81 DUP2 2395 52 MSTORE 2396 60 PUSH1 0x04 2398 01 ADD 2399 80 DUP1 239A 80 DUP1 239B 60 PUSH1 0x20 239D 01 ADD 239E 82 DUP3 239F 81 DUP2 23A0 03 SUB 23A1 82 DUP3 23A2 52 MSTORE 23A3 60 PUSH1 0x25 23A5 81 DUP2 23A6 52 MSTORE 23A7 60 PUSH1 0x20 23A9 01 ADD 23AA 80 DUP1 23AB 61 PUSH2 0x2700 23AE 60 PUSH1 0x25 23B0 91 SWAP2 23B1 39 CODECOPY 23B2 60 PUSH1 0x40 23B4 01 ADD 23B5 91 SWAP2 23B6 50 POP 23B7 50 POP 23B8 60 PUSH1 0x40 23BA 51 MLOAD 23BB 80 DUP1 23BC 91 SWAP2 23BD 03 SUB 23BE 90 SWAP1 23BF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2395 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @23A2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @23A6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x25 // @23B1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x25] = code[0x2700:0x2725] // @23BF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_23C0: // Incoming jump from 0x2389, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @23C1 stack[-3] // @23CB stack[-4] // } 23C0 5B JUMPDEST 23C1 82 DUP3 23C2 60 PUSH1 0x01 23C4 60 PUSH1 0x01 23C6 60 PUSH1 0xa0 23C8 1B SHL 23C9 03 SUB 23CA 16 AND 23CB 84 DUP5 23CC 60 PUSH1 0x01 23CE 60 PUSH1 0x01 23D0 60 PUSH1 0xa0 23D2 1B SHL 23D3 03 SUB 23D4 16 AND 23D5 10 LT 23D6 61 PUSH2 0x23e0 23D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x23e0, if (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] label_23DA: // Incoming jump from 0x23D9, if not (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @23DA stack[-3] // @23DB stack[-4] // } 23DA 82 DUP3 23DB 84 DUP5 23DC 61 PUSH2 0x23e3 23DF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23DA stack[0] = stack[-3] // @23DB stack[1] = stack[-4] // } // Block ends with unconditional jump to 0x23e3 label_23E0: // Incoming jump from 0x23D9, if (0x01 << 0xa0) - 0x01 & stack[-4] < (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[4] // { // @23E1 stack[-4] // @23E2 stack[-3] // @23E5 stack[-2] // @23E7 stack[-1] // } 23E0 5B JUMPDEST 23E1 83 DUP4 23E2 83 DUP4 23E3 5B JUMPDEST 23E4 90 SWAP1 23E5 92 SWAP3 23E6 50 POP 23E7 90 SWAP1 23E8 50 POP 23E9 60 PUSH1 0x01 23EB 60 PUSH1 0x01 23ED 60 PUSH1 0xa0 23EF 1B SHL 23F0 03 SUB 23F1 82 DUP3 23F2 16 AND 23F3 61 PUSH2 0x2443 23F6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @23E5 stack[-2] = stack[-4] // @23E7 stack[-1] = stack[-3] // } // Block ends with conditional jump to 0x2443, if stack[-4] & (0x01 << 0xa0) - 0x01 label_23F7: // Incoming jump from 0x23F6, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x23F6, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @23FA memory[0x40:0x60] // @2439 memory[0x40:0x60] // @2442 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 23F7 60 PUSH1 0x40 23F9 80 DUP1 23FA 51 MLOAD 23FB 62 PUSH3 0x461bcd 23FF 60 PUSH1 0xe5 2401 1B SHL 2402 81 DUP2 2403 52 MSTORE 2404 60 PUSH1 0x20 2406 60 PUSH1 0x04 2408 82 DUP3 2409 01 ADD 240A 52 MSTORE 240B 60 PUSH1 0x1e 240D 60 PUSH1 0x24 240F 82 DUP3 2410 01 ADD 2411 52 MSTORE 2412 7F PUSH32 0x556e697377617056324c6962726172793a205a45524f5f414444524553530000 2433 60 PUSH1 0x44 2435 82 DUP3 2436 01 ADD 2437 52 MSTORE 2438 90 SWAP1 2439 51 MLOAD 243A 90 SWAP1 243B 81 DUP2 243C 90 SWAP1 243D 03 SUB 243E 60 PUSH1 0x64 2440 01 ADD 2441 90 SWAP1 2442 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2403 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @240A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2411 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @2437 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x556e697377617056324c6962726172793a205a45524f5f414444524553530000 // @2442 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2443: // Incoming jump from 0x23F6, if stack[-4] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x23F6, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @2444 stack[-1] // @2444 stack[-4] // @2446 stack[-2] // @2446 stack[-5] // @2447 stack[-3] // } 2443 5B JUMPDEST 2444 92 SWAP3 2445 50 POP 2446 92 SWAP3 2447 90 SWAP1 2448 50 POP 2449 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2444 stack[-4] = stack[-1] // @2446 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_244A: // Incoming jump from 0x1CE8 // Inputs[2] // { // @244B stack[-1] // @244C stack[-2] // } 244A 5B JUMPDEST 244B 80 DUP1 244C 82 DUP3 244D 03 SUB 244E 82 DUP3 244F 81 DUP2 2450 11 GT 2451 15 ISZERO 2452 61 PUSH2 0x249a 2455 57 *JUMPI // Stack delta = +1 // Outputs[1] { @244D stack[0] = stack[-2] - stack[-1] } // Block ends with conditional jump to 0x249a, if !(stack[-2] - stack[-1] > stack[-2]) label_2456: // Incoming jump from 0x2455, if not !(stack[-2] - stack[-1] > stack[-2]) // Inputs[3] // { // @2459 memory[0x40:0x60] // @2490 memory[0x40:0x60] // @2499 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2456 60 PUSH1 0x40 2458 80 DUP1 2459 51 MLOAD 245A 62 PUSH3 0x461bcd 245E 60 PUSH1 0xe5 2460 1B SHL 2461 81 DUP2 2462 52 MSTORE 2463 60 PUSH1 0x20 2465 60 PUSH1 0x04 2467 82 DUP3 2468 01 ADD 2469 52 MSTORE 246A 60 PUSH1 0x15 246C 60 PUSH1 0x24 246E 82 DUP3 246F 01 ADD 2470 52 MSTORE 2471 74 PUSH21 0x64732d6d6174682d7375622d756e646572666c6f77 2487 60 PUSH1 0x58 2489 1B SHL 248A 60 PUSH1 0x44 248C 82 DUP3 248D 01 ADD 248E 52 MSTORE 248F 90 SWAP1 2490 51 MLOAD 2491 90 SWAP1 2492 81 DUP2 2493 90 SWAP1 2494 03 SUB 2495 60 PUSH1 0x64 2497 01 ADD 2498 90 SWAP1 2499 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2462 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2469 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2470 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @248E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d7375622d756e646572666c6f77 << 0x58 // @2499 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_249A: // Incoming jump from 0x266C, if stack[-1] // Incoming jump from 0x2455, if !(stack[-2] - stack[-1] > stack[-2]) // Incoming jump from 0x26BB, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @249B stack[-4] // @249B stack[-1] // @249C stack[-3] // } 249A 5B JUMPDEST 249B 92 SWAP3 249C 91 SWAP2 249D 50 POP 249E 50 POP 249F 56 *JUMP // Stack delta = -3 // Outputs[1] { @249B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_24A0: // Incoming call from 0x1CF5, returns to 0x1CF6 // Incoming jump from 0x21AC // Inputs[1] { @24A4 stack[-3] } 24A0 5B JUMPDEST 24A1 60 PUSH1 0x00 24A3 80 DUP1 24A4 84 DUP5 24A5 11 GT 24A6 61 PUSH2 0x24e0 24A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24A1 stack[0] = 0x00 } // Block ends with conditional jump to 0x24e0, if stack[-3] > 0x00 label_24AA: // Incoming jump from 0x24A9, if not stack[-3] > 0x00 // Inputs[3] // { // @24AC memory[0x40:0x60] // @24DA memory[0x40:0x60] // @24DF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 24AA 60 PUSH1 0x40 24AC 51 MLOAD 24AD 62 PUSH3 0x461bcd 24B1 60 PUSH1 0xe5 24B3 1B SHL 24B4 81 DUP2 24B5 52 MSTORE 24B6 60 PUSH1 0x04 24B8 01 ADD 24B9 80 DUP1 24BA 80 DUP1 24BB 60 PUSH1 0x20 24BD 01 ADD 24BE 82 DUP3 24BF 81 DUP2 24C0 03 SUB 24C1 82 DUP3 24C2 52 MSTORE 24C3 60 PUSH1 0x2b 24C5 81 DUP2 24C6 52 MSTORE 24C7 60 PUSH1 0x20 24C9 01 ADD 24CA 80 DUP1 24CB 61 PUSH2 0x2794 24CE 60 PUSH1 0x2b 24D0 91 SWAP2 24D1 39 CODECOPY 24D2 60 PUSH1 0x40 24D4 01 ADD 24D5 91 SWAP2 24D6 50 POP 24D7 50 POP 24D8 60 PUSH1 0x40 24DA 51 MLOAD 24DB 80 DUP1 24DC 91 SWAP2 24DD 03 SUB 24DE 90 SWAP1 24DF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @24B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @24C2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @24C6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2b // @24D1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2b] = code[0x2794:0x27bf] // @24DF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_24E0: // Incoming jump from 0x24A9, if stack[-3] > 0x00 // Inputs[1] { @24E3 stack[-3] } 24E0 5B JUMPDEST 24E1 60 PUSH1 0x00 24E3 83 DUP4 24E4 11 GT 24E5 80 DUP1 24E6 15 ISZERO 24E7 61 PUSH2 0x24f0 24EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24E4 stack[0] = stack[-3] > 0x00 } // Block ends with conditional jump to 0x24f0, if !(stack[-3] > 0x00) label_24EB: // Incoming jump from 0x24EA, if not !(stack[-3] > 0x00) // Inputs[1] { @24EE stack[-3] } 24EB 50 POP 24EC 60 PUSH1 0x00 24EE 82 DUP3 24EF 11 GT 24F0 5B JUMPDEST 24F1 61 PUSH2 0x252b 24F4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x252b, if stack[-3] > 0x00 label_24F5: // Incoming jump from 0x24F4, if not stack[-1] // Incoming jump from 0x24F4, if not stack[-3] > 0x00 // Inputs[3] // { // @24F7 memory[0x40:0x60] // @2525 memory[0x40:0x60] // @252A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 24F5 60 PUSH1 0x40 24F7 51 MLOAD 24F8 62 PUSH3 0x461bcd 24FC 60 PUSH1 0xe5 24FE 1B SHL 24FF 81 DUP2 2500 52 MSTORE 2501 60 PUSH1 0x04 2503 01 ADD 2504 80 DUP1 2505 80 DUP1 2506 60 PUSH1 0x20 2508 01 ADD 2509 82 DUP3 250A 81 DUP2 250B 03 SUB 250C 82 DUP3 250D 52 MSTORE 250E 60 PUSH1 0x28 2510 81 DUP2 2511 52 MSTORE 2512 60 PUSH1 0x20 2514 01 ADD 2515 80 DUP1 2516 61 PUSH2 0x2725 2519 60 PUSH1 0x28 251B 91 SWAP2 251C 39 CODECOPY 251D 60 PUSH1 0x40 251F 01 ADD 2520 91 SWAP2 2521 50 POP 2522 50 POP 2523 60 PUSH1 0x40 2525 51 MLOAD 2526 80 DUP1 2527 91 SWAP2 2528 03 SUB 2529 90 SWAP1 252A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2500 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @250D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2511 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @251C memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x2725:0x274d] // @252A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_252B: // Incoming jump from 0x24F4, if stack[-1] // Incoming jump from 0x24F4, if stack[-3] > 0x00 // Inputs[1] { @2531 stack[-4] } 252B 5B JUMPDEST 252C 60 PUSH1 0x00 252E 61 PUSH2 0x253f 2531 85 DUP6 2532 61 PUSH2 0x03e5 2535 63 PUSH4 0xffffffff 253A 61 PUSH2 0x264d 253D 16 AND 253E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @252C stack[0] = 0x00 // @252E stack[1] = 0x253f // @2531 stack[2] = stack[-4] // @2532 stack[3] = 0x03e5 // } // Block ends with call to 0x264d & 0xffffffff, returns to 0x253F label_253F: // Incoming return from call to 0x264D at 0x253E // Inputs[3] // { // @2540 stack[-1] // @2540 stack[-2] // @2548 stack[-4] // } 253F 5B JUMPDEST 2540 90 SWAP1 2541 50 POP 2542 60 PUSH1 0x00 2544 61 PUSH2 0x2553 2547 82 DUP3 2548 85 DUP6 2549 63 PUSH4 0xffffffff 254E 61 PUSH2 0x264d 2551 16 AND 2552 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2540 stack[-2] = stack[-1] // @2542 stack[-1] = 0x00 // @2544 stack[0] = 0x2553 // @2547 stack[1] = stack[-1] // @2548 stack[2] = stack[-4] // } // Block ends with call to 0x264d & 0xffffffff, returns to 0x2553 label_2553: // Incoming return from call to 0x264D at 0x2552 // Inputs[4] // { // @2554 stack[-2] // @2554 stack[-1] // @255B stack[-3] // @255F stack[-6] // } 2553 5B JUMPDEST 2554 90 SWAP1 2555 50 POP 2556 60 PUSH1 0x00 2558 61 PUSH2 0x2579 255B 83 DUP4 255C 61 PUSH2 0x256d 255F 88 DUP9 2560 61 PUSH2 0x03e8 2563 63 PUSH4 0xffffffff 2568 61 PUSH2 0x264d 256B 16 AND 256C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @2554 stack[-2] = stack[-1] // @2556 stack[-1] = 0x00 // @2558 stack[0] = 0x2579 // @255B stack[1] = stack[-3] // @255C stack[2] = 0x256d // @255F stack[3] = stack[-6] // @2560 stack[4] = 0x03e8 // } // Block ends with call to 0x264d & 0xffffffff, returns to 0x256D label_256D: // Incoming return from call to 0x264D at 0x256C // Inputs[2] // { // @256E stack[-2] // @256E stack[-1] // } 256D 5B JUMPDEST 256E 90 SWAP1 256F 63 PUSH4 0xffffffff 2574 61 PUSH2 0x26b0 2577 16 AND 2578 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @256E stack[-1] = stack[-2] // @256E stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x26b0 & 0xffffffff label_2579: // Incoming return from call to 0x256D at 0x256C // Inputs[3] // { // @257A stack[-1] // @257A stack[-2] // @257D stack[-3] // } 2579 5B JUMPDEST 257A 90 SWAP1 257B 50 POP 257C 80 DUP1 257D 82 DUP3 257E 81 DUP2 257F 61 PUSH2 0x2584 2582 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @257A stack[-2] = stack[-1] // @257C stack[-1] = stack[-1] // @257D stack[0] = stack[-3] // } // Block ends with conditional jump to 0x2584, if stack[-1] label_2583: // Incoming jump from 0x2582, if not stack[-1] 2583 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2583 assert(); } // Block terminates label_2584: // Incoming jump from 0x2582, if stack[-1] // Inputs[4] // { // @2585 stack[-1] // @2585 stack[-2] // @2586 stack[-10] // @2587 stack[-9] // } 2584 5B JUMPDEST 2585 04 DIV 2586 97 SWAP8 2587 96 SWAP7 2588 50 POP 2589 50 POP 258A 50 POP 258B 50 POP 258C 50 POP 258D 50 POP 258E 50 POP 258F 56 *JUMP // Stack delta = -9 // Outputs[1] { @2586 stack[-10] = stack[-1] / stack[-2] } // Block ends with unconditional jump to stack[-10] label_2590: // Incoming jump from 0x218A // Inputs[2] // { // @2599 stack[-2] // @259A stack[-1] // } 2590 5B JUMPDEST 2591 60 PUSH1 0x00 2593 80 DUP1 2594 60 PUSH1 0x00 2596 61 PUSH2 0x259f 2599 85 DUP6 259A 85 DUP6 259B 61 PUSH2 0x236c 259E 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2591 stack[0] = 0x00 // @2593 stack[1] = 0x00 // @2594 stack[2] = 0x00 // @2596 stack[3] = 0x259f // @2599 stack[4] = stack[-2] // @259A stack[5] = stack[-1] // } // Block ends with call to 0x236c, returns to 0x259F label_259F: // Incoming return from call to 0x236C at 0x259E // Inputs[6] // { // @25A1 stack[-3] // @25A1 stack[-2] // @25A6 stack[-8] // @25B7 memory[0x40:0x60] // @25CB memory[0x40:0x60] // @25D2 address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // } 259F 5B JUMPDEST 25A0 50 POP 25A1 90 SWAP1 25A2 50 POP 25A3 60 PUSH1 0x00 25A5 80 DUP1 25A6 87 DUP8 25A7 60 PUSH1 0x01 25A9 60 PUSH1 0x01 25AB 60 PUSH1 0xa0 25AD 1B SHL 25AE 03 SUB 25AF 16 AND 25B0 63 PUSH4 0x0902f1ac 25B5 60 PUSH1 0x40 25B7 51 MLOAD 25B8 81 DUP2 25B9 63 PUSH4 0xffffffff 25BE 16 AND 25BF 60 PUSH1 0xe0 25C1 1B SHL 25C2 81 DUP2 25C3 52 MSTORE 25C4 60 PUSH1 0x04 25C6 01 ADD 25C7 60 PUSH1 0x60 25C9 60 PUSH1 0x40 25CB 51 MLOAD 25CC 80 DUP1 25CD 83 DUP4 25CE 03 SUB 25CF 81 DUP2 25D0 86 DUP7 25D1 80 DUP1 25D2 3B EXTCODESIZE 25D3 15 ISZERO 25D4 80 DUP1 25D5 15 ISZERO 25D6 61 PUSH2 0x25de 25D9 57 *JUMPI // Stack delta = +9 // Outputs[13] // { // @25A1 stack[-3] = stack[-2] // @25A3 stack[-2] = 0x00 // @25A5 stack[-1] = 0x00 // @25AF stack[0] = (0x01 << 0xa0) - 0x01 & stack[-8] // @25B0 stack[1] = 0x0902f1ac // @25C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x0902f1ac) << 0xe0 // @25C6 stack[2] = 0x04 + memory[0x40:0x60] // @25C7 stack[3] = 0x60 // @25CB stack[4] = memory[0x40:0x60] // @25CE stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @25CF stack[6] = memory[0x40:0x60] // @25D0 stack[7] = (0x01 << 0xa0) - 0x01 & stack[-8] // @25D3 stack[8] = !address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // } // Block ends with conditional jump to 0x25de, if !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length label_25DA: // Incoming jump from 0x25D9, if not !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // Inputs[1] { @25DD memory[0x00:0x00] } 25DA 60 PUSH1 0x00 25DC 80 DUP1 25DD FD *REVERT // Stack delta = +0 // Outputs[1] { @25DD revert(memory[0x00:0x00]); } // Block terminates label_25DE: // Incoming jump from 0x25D9, if !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // Inputs[8] // { // @25E0 msg.gas // @25E1 stack[-2] // @25E1 stack[-6] // @25E1 stack[-5] // @25E1 stack[-4] // @25E1 memory[stack[-3]:stack[-3] + stack[-4]] // @25E1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @25E1 stack[-3] // } 25DE 5B JUMPDEST 25DF 50 POP 25E0 5A GAS 25E1 FA STATICCALL 25E2 15 ISZERO 25E3 80 DUP1 25E4 15 ISZERO 25E5 61 PUSH2 0x25f2 25E8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @25E1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @25E2 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x25f2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_25E9: // Incoming jump from 0x25E8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @25E9 returndata.length // @25ED returndata[0x00:0x00 + returndata.length] // @25EE returndata.length // @25F1 memory[0x00:0x00 + returndata.length] // } 25E9 3D RETURNDATASIZE 25EA 60 PUSH1 0x00 25EC 80 DUP1 25ED 3E RETURNDATACOPY 25EE 3D RETURNDATASIZE 25EF 60 PUSH1 0x00 25F1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @25ED memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @25F1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_25F2: // Incoming jump from 0x25E8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @25F9 memory[0x40:0x60] // @25FA returndata.length // } 25F2 5B JUMPDEST 25F3 50 POP 25F4 50 POP 25F5 50 POP 25F6 50 POP 25F7 60 PUSH1 0x40 25F9 51 MLOAD 25FA 3D RETURNDATASIZE 25FB 60 PUSH1 0x60 25FD 81 DUP2 25FE 10 LT 25FF 15 ISZERO 2600 61 PUSH2 0x2608 2603 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @25F9 stack[-4] = memory[0x40:0x60] // @25FA stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2608, if !(returndata.length < 0x60) label_2604: // Incoming jump from 0x2603, if not !(returndata.length < 0x60) // Inputs[1] { @2607 memory[0x00:0x00] } 2604 60 PUSH1 0x00 2606 80 DUP1 2607 FD *REVERT // Stack delta = +0 // Outputs[1] { @2607 revert(memory[0x00:0x00]); } // Block terminates label_2608: // Incoming jump from 0x2603, if !(returndata.length < 0x60) // Inputs[7] // { // @260A stack[-2] // @260B memory[stack[-2]:stack[-2] + 0x20] // @2611 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @261D stack[-4] // @2620 stack[-3] // @262A stack[-9] // @262E stack[-5] // } 2608 5B JUMPDEST 2609 50 POP 260A 80 DUP1 260B 51 MLOAD 260C 60 PUSH1 0x20 260E 90 SWAP1 260F 91 SWAP2 2610 01 ADD 2611 51 MLOAD 2612 60 PUSH1 0x01 2614 60 PUSH1 0x01 2616 60 PUSH1 0x70 2618 1B SHL 2619 03 SUB 261A 91 SWAP2 261B 82 DUP3 261C 16 AND 261D 93 SWAP4 261E 50 POP 261F 16 AND 2620 90 SWAP1 2621 50 POP 2622 60 PUSH1 0x01 2624 60 PUSH1 0x01 2626 60 PUSH1 0xa0 2628 1B SHL 2629 03 SUB 262A 87 DUP8 262B 81 DUP2 262C 16 AND 262D 90 SWAP1 262E 84 DUP5 262F 16 AND 2630 14 EQ 2631 61 PUSH2 0x263b 2634 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @261D stack[-4] = (0x01 << 0x70) - 0x01 & memory[stack[-2]:stack[-2] + 0x20] // @2620 stack[-3] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & (0x01 << 0x70) - 0x01 // } // Block ends with conditional jump to 0x263b, if stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-9] label_2635: // Incoming jump from 0x2634, if not stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-9] // Inputs[2] // { // @2635 stack[-1] // @2636 stack[-2] // } 2635 80 DUP1 2636 82 DUP3 2637 61 PUSH2 0x263e 263A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2635 stack[0] = stack[-1] // @2636 stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x263e label_263B: // Incoming jump from 0x2634, if stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-9] // Inputs[5] // { // @263C stack[-2] // @263D stack[-1] // @2640 stack[-9] // @2642 stack[-8] // @2644 stack[-7] // } 263B 5B JUMPDEST 263C 81 DUP2 263D 81 DUP2 263E 5B JUMPDEST 263F 90 SWAP1 2640 99 SWAP10 2641 90 SWAP1 2642 98 SWAP9 2643 50 POP 2644 96 SWAP7 2645 50 POP 2646 50 POP 2647 50 POP 2648 50 POP 2649 50 POP 264A 50 POP 264B 50 POP 264C 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @2640 stack[-9] = stack[-2] // @2642 stack[-8] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_264D: // Incoming call from 0x256C, returns to 0x256D // Incoming call from 0x2552, returns to 0x2553 // Incoming call from 0x253E, returns to 0x253F // Inputs[1] { @2650 stack[-1] } 264D 5B JUMPDEST 264E 60 PUSH1 0x00 2650 81 DUP2 2651 15 ISZERO 2652 80 DUP1 2653 61 PUSH2 0x2668 2656 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @264E stack[0] = 0x00 // @2651 stack[1] = !stack[-1] // } // Block ends with conditional jump to 0x2668, if !stack[-1] label_2657: // Incoming jump from 0x2656, if not !stack[-1] // Inputs[2] // { // @2659 stack[-3] // @265A stack[-4] // } 2657 50 POP 2658 50 POP 2659 80 DUP1 265A 82 DUP3 265B 02 MUL 265C 82 DUP3 265D 82 DUP3 265E 82 DUP3 265F 81 DUP2 2660 61 PUSH2 0x2665 2663 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @265B stack[-2] = stack[-4] * stack[-3] // @265C stack[-1] = stack[-4] // @265D stack[0] = stack[-3] // @265E stack[1] = stack[-4] * stack[-3] // } // Block ends with conditional jump to 0x2665, if stack[-3] label_2664: // Incoming jump from 0x2663, if not stack[-3] 2664 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2664 assert(); } // Block terminates label_2665: // Incoming jump from 0x2663, if stack[-3] // Inputs[3] // { // @2666 stack[-1] // @2666 stack[-2] // @2667 stack[-3] // } 2665 5B JUMPDEST 2666 04 DIV 2667 14 EQ // Stack delta = -2 // Outputs[1] { @2667 stack[-3] = stack[-1] / stack[-2] == stack[-3] } // Block continues label_2668: // Incoming jump from 0x2656, if !stack[-1] // Incoming jump from 0x2667 // Inputs[1] { @266C stack[-1] } 2668 5B JUMPDEST 2669 61 PUSH2 0x249a 266C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x249a, if stack[-1] label_266D: // Incoming jump from 0x266C, if not stack[-1] // Inputs[3] // { // @2670 memory[0x40:0x60] // @26A6 memory[0x40:0x60] // @26AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 266D 60 PUSH1 0x40 266F 80 DUP1 2670 51 MLOAD 2671 62 PUSH3 0x461bcd 2675 60 PUSH1 0xe5 2677 1B SHL 2678 81 DUP2 2679 52 MSTORE 267A 60 PUSH1 0x20 267C 60 PUSH1 0x04 267E 82 DUP3 267F 01 ADD 2680 52 MSTORE 2681 60 PUSH1 0x14 2683 60 PUSH1 0x24 2685 82 DUP3 2686 01 ADD 2687 52 MSTORE 2688 73 PUSH20 0x64732d6d6174682d6d756c2d6f766572666c6f77 269D 60 PUSH1 0x60 269F 1B SHL 26A0 60 PUSH1 0x44 26A2 82 DUP3 26A3 01 ADD 26A4 52 MSTORE 26A5 90 SWAP1 26A6 51 MLOAD 26A7 90 SWAP1 26A8 81 DUP2 26A9 90 SWAP1 26AA 03 SUB 26AB 60 PUSH1 0x64 26AD 01 ADD 26AE 90 SWAP1 26AF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2679 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2680 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2687 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @26A4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d6d756c2d6f766572666c6f77 << 0x60 // @26AF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_26B0: // Incoming jump from 0x2578 // Inputs[2] // { // @26B1 stack[-1] // @26B2 stack[-2] // } 26B0 5B JUMPDEST 26B1 80 DUP1 26B2 82 DUP3 26B3 01 ADD 26B4 82 DUP3 26B5 81 DUP2 26B6 10 LT 26B7 15 ISZERO 26B8 61 PUSH2 0x249a 26BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26B3 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x249a, if !(stack[-2] + stack[-1] < stack[-2]) label_26BC: // Incoming jump from 0x26BB, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @26BF memory[0x40:0x60] // @26F5 memory[0x40:0x60] // @26FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 26BC 60 PUSH1 0x40 26BE 80 DUP1 26BF 51 MLOAD 26C0 62 PUSH3 0x461bcd 26C4 60 PUSH1 0xe5 26C6 1B SHL 26C7 81 DUP2 26C8 52 MSTORE 26C9 60 PUSH1 0x20 26CB 60 PUSH1 0x04 26CD 82 DUP3 26CE 01 ADD 26CF 52 MSTORE 26D0 60 PUSH1 0x14 26D2 60 PUSH1 0x24 26D4 82 DUP3 26D5 01 ADD 26D6 52 MSTORE 26D7 73 PUSH20 0x64732d6d6174682d6164642d6f766572666c6f77 26EC 60 PUSH1 0x60 26EE 1B SHL 26EF 60 PUSH1 0x44 26F1 82 DUP3 26F2 01 ADD 26F3 52 MSTORE 26F4 90 SWAP1 26F5 51 MLOAD 26F6 90 SWAP1 26F7 81 DUP2 26F8 90 SWAP1 26F9 03 SUB 26FA 60 PUSH1 0x64 26FC 01 ADD 26FD 90 SWAP1 26FE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @26C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @26CF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @26D6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @26F3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x64732d6d6174682d6164642d6f766572666c6f77 << 0x60 // @26FE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates 26FF FE *ASSERT 2700 55 SSTORE 2701 6E PUSH15 0x697377617056324c6962726172793a 2711 20 SHA3 2712 49 49 2713 44 DIFFICULTY 2714 45 GASLIMIT 2715 4E 4E 2716 54 SLOAD 2717 49 49 2718 43 NUMBER 2719 41 COINBASE 271A 4C 4C 271B 5F PUSH0 271C 41 COINBASE 271D 44 DIFFICULTY 271E 44 DIFFICULTY 271F 52 MSTORE 2720 45 GASLIMIT 2721 53 MSTORE8 2722 53 MSTORE8 2723 45 GASLIMIT 2724 53 MSTORE8 2725 55 SSTORE 2726 6E PUSH15 0x697377617056324c6962726172793a 2736 20 SHA3 2737 49 49 2738 4E 4E 2739 53 MSTORE8 273A 55 SSTORE 273B 46 CHAINID 273C 46 CHAINID 273D 49 49 273E 43 NUMBER 273F 49 49 2740 45 GASLIMIT 2741 4E 4E 2742 54 SLOAD 2743 5F PUSH0 2744 4C 4C 2745 49 49 2746 51 MLOAD 2747 55 SSTORE 2748 49 49 2749 44 DIFFICULTY 274A 49 49 274B 54 SLOAD 274C 59 MSIZE 274D 54 SLOAD 274E 72 PUSH19 0x616e7366657248656c7065723a204554485f54 2762 52 MSTORE 2763 41 COINBASE 2764 4E 4E 2765 53 MSTORE8 2766 46 CHAINID 2767 45 GASLIMIT 2768 52 MSTORE 2769 5F PUSH0 276A 46 CHAINID 276B 41 COINBASE 276C 49 49 276D 4C 4C 276E 45 GASLIMIT 276F 44 DIFFICULTY 2770 54 SLOAD 2771 72 PUSH19 0x616e7366657248656c7065723a205452414e53 2785 46 CHAINID 2786 45 GASLIMIT 2787 52 MSTORE 2788 5F PUSH0 2789 46 CHAINID 278A 52 MSTORE 278B 4F 4F 278C 4D 4D 278D 5F PUSH0 278E 46 CHAINID 278F 41 COINBASE 2790 49 49 2791 4C 4C 2792 45 GASLIMIT 2793 44 DIFFICULTY 2794 55 SSTORE 2795 6E PUSH15 0x697377617056324c6962726172793a 27A5 20 SHA3 27A6 49 49 27A7 4E 4E 27A8 53 MSTORE8 27A9 55 SSTORE 27AA 46 CHAINID 27AB 46 CHAINID 27AC 49 49 27AD 43 NUMBER 27AE 49 49 27AF 45 GASLIMIT 27B0 4E 4E 27B1 54 SLOAD 27B2 5F PUSH0 27B3 49 49 27B4 4E 4E 27B5 50 POP 27B6 55 SSTORE 27B7 54 SLOAD 27B8 5F PUSH0 27B9 41 COINBASE 27BA 4D 4D 27BB 4F 4F 27BC 55 SSTORE 27BD 4E 4E 27BE 54 SLOAD 27BF A2 LOG2 27C0 64 PUSH5 0x6970667358 27C6 22 22 27C7 12 SLT 27C8 20 SHA3 27C9 5B JUMPDEST 27CA 23 23 27CB 3B EXTCODESIZE 27CC AF AF 27CD 2D 2D 27CE 0B SIGNEXTEND 27CF D3 D3 27D0 DE DE 27D1 D0 D0 27D2 2B 2B 27D3 5B JUMPDEST 27D4 A3 LOG3 27D5 F0 CREATE 27D6 5B JUMPDEST 27D7 F1 CALL 27D8 D6 D6 27D9 D8 D8 27DA 96 SWAP7 27DB 5D 5D 27DC 6B PUSH12 0x9e6cee09f89ddc149cab6d0d 27E9 64 PUSH5 0x736f6c6343 27EF 00 *STOP 27F0 06 MOD 27F1 06 MOD 27F2 00 *STOP 27F3 33 CALLER