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 0x0246 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0246, 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 0x6352211e 0019 11 GT 001A 61 PUSH2 0x0139 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0139, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa22cb465 0024 11 GT 0025 61 PUSH2 0x00b6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b6, if 0xa22cb465 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc6275255 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xc6275255 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc6275255 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xc6275255 003A 14 EQ 003B 61 PUSH2 0x0717 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0717, if 0xc6275255 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xc6275255 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xc87b56dd 0045 14 EQ 0046 61 PUSH2 0x0737 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0737, if 0xc87b56dd == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xc87b56dd == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xd547cfb7 0050 14 EQ 0051 61 PUSH2 0x0757 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0757, if 0xd547cfb7 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xd547cfb7 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x076c 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x076c, if 0xe985e9c5 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xeb12d61e 0066 14 EQ 0067 61 PUSH2 0x078c 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x078c, if 0xeb12d61e == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xeb12d61e == stack[-1] // Inputs[1] { @006B stack[-1] } 006B 80 DUP1 006C 63 PUSH4 0xf2fde38b 0071 14 EQ 0072 61 PUSH2 0x07ac 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07ac, if 0xf2fde38b == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0079 memory[0x00:0x00] } 0076 60 PUSH1 0x00 0078 80 DUP1 0079 FD *REVERT // Stack delta = +0 // Outputs[1] { @0079 revert(memory[0x00:0x00]); } // Block terminates label_007A: // Incoming jump from 0x0033, if 0xc6275255 > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0xa22cb465 0081 14 EQ 0082 61 PUSH2 0x0616 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0616, if 0xa22cb465 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xa945bf80 008C 14 EQ 008D 61 PUSH2 0x0636 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0636, if 0xa945bf80 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xa945bf80 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xb88d4fde 0097 14 EQ 0098 61 PUSH2 0x064c 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064c, if 0xb88d4fde == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xb88d4fde == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xbb69b7ef 00A2 14 EQ 00A3 61 PUSH2 0x066c 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066c, if 0xbb69b7ef == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xbb69b7ef == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xbf62e21d 00AD 14 EQ 00AE 61 PUSH2 0x06f7 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f7, if 0xbf62e21d == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xbf62e21d == stack[-1] // Inputs[1] { @00B5 memory[0x00:0x00] } 00B2 60 PUSH1 0x00 00B4 80 DUP1 00B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B5 revert(memory[0x00:0x00]); } // Block terminates label_00B6: // Incoming jump from 0x0028, if 0xa22cb465 > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B6 5B JUMPDEST 00B7 80 DUP1 00B8 63 PUSH4 0x9106d7ba 00BD 11 GT 00BE 61 PUSH2 0x00fd 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fd, if 0x9106d7ba > stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x9106d7ba > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x9106d7ba 00C8 14 EQ 00C9 61 PUSH2 0x05a6 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a6, if 0x9106d7ba == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x9106d7ba == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x9437bfa0 00D3 14 EQ 00D4 61 PUSH2 0x05bb 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bb, if 0x9437bfa0 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x9437bfa0 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x95d89b41 00DE 14 EQ 00DF 61 PUSH2 0x05db 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05db, if 0x95d89b41 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0x96d66de0 00E9 14 EQ 00EA 61 PUSH2 0x05f0 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f0, if 0x96d66de0 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0x96d66de0 == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0x9f93f779 00F4 14 EQ 00F5 61 PUSH2 0x0603 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0603, if 0x9f93f779 == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0x9f93f779 == stack[-1] // Inputs[1] { @00FC memory[0x00:0x00] } 00F9 60 PUSH1 0x00 00FB 80 DUP1 00FC FD *REVERT // Stack delta = +0 // Outputs[1] { @00FC revert(memory[0x00:0x00]); } // Block terminates label_00FD: // Incoming jump from 0x00C1, if 0x9106d7ba > stack[-1] // Inputs[1] { @00FE stack[-1] } 00FD 5B JUMPDEST 00FE 80 DUP1 00FF 63 PUSH4 0x6352211e 0104 14 EQ 0105 61 PUSH2 0x051e 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051e, if 0x6352211e == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x6352211e == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x70a08231 010F 14 EQ 0110 61 PUSH2 0x053e 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053e, if 0x70a08231 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x70a08231 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x715018a6 011A 14 EQ 011B 61 PUSH2 0x055e 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055e, if 0x715018a6 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x715018a6 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x8456cb59 0125 14 EQ 0126 61 PUSH2 0x0573 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0573, if 0x8456cb59 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x8456cb59 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x8da5cb5b 0130 14 EQ 0131 61 PUSH2 0x0588 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0588, if 0x8da5cb5b == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0138 memory[0x00:0x00] } 0135 60 PUSH1 0x00 0137 80 DUP1 0138 FD *REVERT // Stack delta = +0 // Outputs[1] { @0138 revert(memory[0x00:0x00]); } // Block terminates label_0139: // Incoming jump from 0x001D, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @013A stack[-1] } 0139 5B JUMPDEST 013A 80 DUP1 013B 63 PUSH4 0x2a55205a 0140 11 GT 0141 61 PUSH2 0x01c7 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c7, if 0x2a55205a > stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x2a55205a > stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x3f4ba83a 014B 11 GT 014C 61 PUSH2 0x018b 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x018b, if 0x3f4ba83a > stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x3f4ba83a > stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x3f4ba83a 0156 14 EQ 0157 61 PUSH2 0x0480 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0480, if 0x3f4ba83a == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x42842e0e 0161 14 EQ 0162 61 PUSH2 0x0495 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0495, if 0x42842e0e == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x42842e0e == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x53ac010a 016C 14 EQ 016D 61 PUSH2 0x04b5 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b5, if 0x53ac010a == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x53ac010a == stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x5a028400 0177 14 EQ 0178 61 PUSH2 0x04cf 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cf, if 0x5a028400 == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x5a028400 == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x5c975abb 0182 14 EQ 0183 61 PUSH2 0x04ff 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ff, if 0x5c975abb == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x5c975abb == stack[-1] // Inputs[1] { @018A memory[0x00:0x00] } 0187 60 PUSH1 0x00 0189 80 DUP1 018A FD *REVERT // Stack delta = +0 // Outputs[1] { @018A revert(memory[0x00:0x00]); } // Block terminates label_018B: // Incoming jump from 0x014F, if 0x3f4ba83a > stack[-1] // Inputs[1] { @018C stack[-1] } 018B 5B JUMPDEST 018C 80 DUP1 018D 63 PUSH4 0x2a55205a 0192 14 EQ 0193 61 PUSH2 0x03c1 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c1, if 0x2a55205a == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x2a55205a == stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x2f274bd4 019D 14 EQ 019E 61 PUSH2 0x0400 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0400, if 0x2f274bd4 == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x2f274bd4 == stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A2 80 DUP1 01A3 63 PUSH4 0x30176e13 01A8 14 EQ 01A9 61 PUSH2 0x0420 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0420, if 0x30176e13 == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x30176e13 == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x38af3eed 01B3 14 EQ 01B4 61 PUSH2 0x0440 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0440, if 0x38af3eed == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x38af3eed == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x3ec02e14 01BE 14 EQ 01BF 61 PUSH2 0x0460 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0460, if 0x3ec02e14 == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x3ec02e14 == stack[-1] // Inputs[1] { @01C6 memory[0x00:0x00] } 01C3 60 PUSH1 0x00 01C5 80 DUP1 01C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C6 revert(memory[0x00:0x00]); } // Block terminates label_01C7: // Incoming jump from 0x0144, if 0x2a55205a > stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C7 5B JUMPDEST 01C8 80 DUP1 01C9 63 PUSH4 0x0e316ab7 01CE 11 GT 01CF 61 PUSH2 0x020e 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020e, if 0x0e316ab7 > stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x0e316ab7 > stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x0e316ab7 01D9 14 EQ 01DA 61 PUSH2 0x031c 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031c, if 0x0e316ab7 == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x0e316ab7 == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x18160ddd 01E4 14 EQ 01E5 61 PUSH2 0x033c 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033c, if 0x18160ddd == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x18160ddd == stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x1c31f710 01EF 14 EQ 01F0 61 PUSH2 0x0361 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0361, if 0x1c31f710 == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x1c31f710 == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x23b872dd 01FA 14 EQ 01FB 61 PUSH2 0x0381 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0381, if 0x23b872dd == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x23b872dd == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x254a4737 0205 14 EQ 0206 61 PUSH2 0x03a1 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a1, if 0x254a4737 == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x254a4737 == stack[-1] // Inputs[1] { @020D memory[0x00:0x00] } 020A 60 PUSH1 0x00 020C 80 DUP1 020D FD *REVERT // Stack delta = +0 // Outputs[1] { @020D revert(memory[0x00:0x00]); } // Block terminates label_020E: // Incoming jump from 0x01D2, if 0x0e316ab7 > stack[-1] // Inputs[1] { @020F stack[-1] } 020E 5B JUMPDEST 020F 80 DUP1 0210 63 PUSH4 0x01ffc9a7 0215 14 EQ 0216 61 PUSH2 0x024b 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024b, if 0x01ffc9a7 == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @021A stack[-1] } 021A 80 DUP1 021B 63 PUSH4 0x02fa7c47 0220 14 EQ 0221 61 PUSH2 0x0280 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0280, if 0x02fa7c47 == stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x02fa7c47 == stack[-1] // Inputs[1] { @0225 stack[-1] } 0225 80 DUP1 0226 63 PUSH4 0x06fdde03 022B 14 EQ 022C 61 PUSH2 0x02a2 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a2, if 0x06fdde03 == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0230 stack[-1] } 0230 80 DUP1 0231 63 PUSH4 0x081812fc 0236 14 EQ 0237 61 PUSH2 0x02c4 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c4, if 0x081812fc == stack[-1] label_023B: // Incoming jump from 0x023A, if not 0x081812fc == stack[-1] // Inputs[1] { @023B stack[-1] } 023B 80 DUP1 023C 63 PUSH4 0x095ea7b3 0241 14 EQ 0242 61 PUSH2 0x02fc 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fc, if 0x095ea7b3 == stack[-1] label_0246: // Incoming jump from 0x0245, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @024A memory[0x00:0x00] } 0246 5B JUMPDEST 0247 60 PUSH1 0x00 0249 80 DUP1 024A FD *REVERT // Stack delta = +0 // Outputs[1] { @024A revert(memory[0x00:0x00]); } // Block terminates label_024B: // Incoming jump from 0x0219, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @024C msg.value } 024B 5B JUMPDEST 024C 34 CALLVALUE 024D 80 DUP1 024E 15 ISZERO 024F 61 PUSH2 0x0257 0252 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024C stack[0] = msg.value } // Block ends with conditional jump to 0x0257, if !msg.value label_0253: // Incoming jump from 0x0252, if not !msg.value // Inputs[1] { @0256 memory[0x00:0x00] } 0253 60 PUSH1 0x00 0255 80 DUP1 0256 FD *REVERT // Stack delta = +0 // Outputs[1] { @0256 revert(memory[0x00:0x00]); } // Block terminates label_0257: // Incoming jump from 0x0252, if !msg.value // Inputs[1] { @025F msg.data.length } 0257 5B JUMPDEST 0258 50 POP 0259 61 PUSH2 0x026b 025C 61 PUSH2 0x0266 025F 36 CALLDATASIZE 0260 60 PUSH1 0x04 0262 61 PUSH2 0x31fc 0265 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0259 stack[-1] = 0x026b // @025C stack[0] = 0x0266 // @025F stack[1] = msg.data.length // @0260 stack[2] = 0x04 // } // Block ends with call to 0x31fc, returns to 0x0266 label_0266: // Incoming return from call to 0x31FC at 0x0265 0266 5B JUMPDEST 0267 61 PUSH2 0x07cc 026A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07cc label_026B: // Incoming jump from 0x051D // Incoming jump from 0x04CE // Incoming return from call to 0x0266 at 0x0265 // Incoming return from call to 0x04EA at 0x04E9 // Inputs[2] // { // @026E memory[0x40:0x60] // @026F stack[-1] // } 026B 5B JUMPDEST 026C 60 PUSH1 0x40 026E 51 MLOAD 026F 90 SWAP1 0270 15 ISZERO 0271 15 ISZERO 0272 81 DUP2 0273 52 MSTORE 0274 60 PUSH1 0x20 0276 01 ADD // Stack delta = +0 // Outputs[2] // { // @0273 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0276 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0277: // Incoming jump from 0x06F6 // Incoming jump from 0x0276 // Incoming jump from 0x03FF // Incoming jump from 0x0360 // Incoming jump from 0x02FB // Inputs[3] // { // @027A memory[0x40:0x60] // @027C stack[-1] // @027F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0277 5B JUMPDEST 0278 60 PUSH1 0x40 027A 51 MLOAD 027B 80 DUP1 027C 91 SWAP2 027D 03 SUB 027E 90 SWAP1 027F F3 *RETURN // Stack delta = -1 // Outputs[1] { @027F return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0280: // Incoming jump from 0x0224, if 0x02fa7c47 == stack[-1] // Inputs[1] { @0281 msg.value } 0280 5B JUMPDEST 0281 34 CALLVALUE 0282 80 DUP1 0283 15 ISZERO 0284 61 PUSH2 0x028c 0287 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0281 stack[0] = msg.value } // Block ends with conditional jump to 0x028c, if !msg.value label_0288: // Incoming jump from 0x0287, if not !msg.value // Inputs[1] { @028B memory[0x00:0x00] } 0288 60 PUSH1 0x00 028A 80 DUP1 028B FD *REVERT // Stack delta = +0 // Outputs[1] { @028B revert(memory[0x00:0x00]); } // Block terminates label_028C: // Incoming jump from 0x0287, if !msg.value // Inputs[1] { @0294 msg.data.length } 028C 5B JUMPDEST 028D 50 POP 028E 61 PUSH2 0x02a0 0291 61 PUSH2 0x029b 0294 36 CALLDATASIZE 0295 60 PUSH1 0x04 0297 61 PUSH2 0x322e 029A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @028E stack[-1] = 0x02a0 // @0291 stack[0] = 0x029b // @0294 stack[1] = msg.data.length // @0295 stack[2] = 0x04 // } // Block ends with call to 0x322e, returns to 0x029B label_029B: // Incoming return from call to 0x322E at 0x029A 029B 5B JUMPDEST 029C 61 PUSH2 0x07dd 029F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07dd label_02A0: // Incoming return from call to 0x041B at 0x041A // Incoming return from call to 0x03BC at 0x03BB // Incoming return from call to 0x0F83 at 0x0572 // Incoming return from call to 0x0317 at 0x0316 // Incoming return from call to 0x0732 at 0x0731 // Incoming return from call to 0x037C at 0x037B // Incoming return from call to 0x029B at 0x029A // Incoming return from call to 0x0FB7 at 0x0587 // Incoming return from call to 0x0E36 at 0x0494 02A0 5B JUMPDEST 02A1 00 *STOP // Stack delta = +0 // Outputs[1] { @02A1 stop(); } // Block terminates label_02A2: // Incoming jump from 0x022F, if 0x06fdde03 == stack[-1] // Inputs[1] { @02A3 msg.value } 02A2 5B JUMPDEST 02A3 34 CALLVALUE 02A4 80 DUP1 02A5 15 ISZERO 02A6 61 PUSH2 0x02ae 02A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A3 stack[0] = msg.value } // Block ends with conditional jump to 0x02ae, if !msg.value label_02AA: // Incoming jump from 0x02A9, if not !msg.value // Inputs[1] { @02AD memory[0x00:0x00] } 02AA 60 PUSH1 0x00 02AC 80 DUP1 02AD FD *REVERT // Stack delta = +0 // Outputs[1] { @02AD revert(memory[0x00:0x00]); } // Block terminates label_02AE: // Incoming jump from 0x02A9, if !msg.value 02AE 5B JUMPDEST 02AF 50 POP 02B0 61 PUSH2 0x02b7 02B3 61 PUSH2 0x081e 02B6 56 *JUMP // Stack delta = +0 // Outputs[1] { @02B0 stack[-1] = 0x02b7 } // Block ends with call to 0x081e, returns to 0x02B7 label_02B7: // Incoming return from call to 0x102E at 0x05EF // Incoming return from call to 0x137A at 0x076B // Incoming return from call to 0x081E at 0x02B6 // Inputs[2] // { // @02BA memory[0x40:0x60] // @02BE stack[-1] // } 02B7 5B JUMPDEST 02B8 60 PUSH1 0x40 02BA 51 MLOAD 02BB 61 PUSH2 0x0277 02BE 91 SWAP2 02BF 90 SWAP1 02C0 61 PUSH2 0x32cb 02C3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02BE stack[-1] = 0x0277 // @02BF stack[1] = memory[0x40:0x60] // @02BF stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x32cb label_02C4: // Incoming jump from 0x023A, if 0x081812fc == stack[-1] // Inputs[1] { @02C5 msg.value } 02C4 5B JUMPDEST 02C5 34 CALLVALUE 02C6 80 DUP1 02C7 15 ISZERO 02C8 61 PUSH2 0x02d0 02CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C5 stack[0] = msg.value } // Block ends with conditional jump to 0x02d0, if !msg.value label_02CC: // Incoming jump from 0x02CB, if not !msg.value // Inputs[1] { @02CF memory[0x00:0x00] } 02CC 60 PUSH1 0x00 02CE 80 DUP1 02CF FD *REVERT // Stack delta = +0 // Outputs[1] { @02CF revert(memory[0x00:0x00]); } // Block terminates label_02D0: // Incoming jump from 0x02CB, if !msg.value // Inputs[1] { @02D8 msg.data.length } 02D0 5B JUMPDEST 02D1 50 POP 02D2 61 PUSH2 0x02e4 02D5 61 PUSH2 0x02df 02D8 36 CALLDATASIZE 02D9 60 PUSH1 0x04 02DB 61 PUSH2 0x32de 02DE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02D2 stack[-1] = 0x02e4 // @02D5 stack[0] = 0x02df // @02D8 stack[1] = msg.data.length // @02D9 stack[2] = 0x04 // } // Block ends with call to 0x32de, returns to 0x02DF label_02DF: // Incoming return from call to 0x32DE at 0x02DE 02DF 5B JUMPDEST 02E0 61 PUSH2 0x08b0 02E3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08b0 label_02E4: // Incoming return from call to 0x0539 at 0x0538 // Incoming return from call to 0x02DF at 0x02DE // Incoming jump from 0x045F // Incoming jump from 0x05A5 // Inputs[2] // { // @02E7 memory[0x40:0x60] // @02F1 stack[-1] // } 02E4 5B JUMPDEST 02E5 60 PUSH1 0x40 02E7 51 MLOAD 02E8 60 PUSH1 0x01 02EA 60 PUSH1 0x01 02EC 60 PUSH1 0xa0 02EE 1B SHL 02EF 03 SUB 02F0 90 SWAP1 02F1 91 SWAP2 02F2 16 AND 02F3 81 DUP2 02F4 52 MSTORE 02F5 60 PUSH1 0x20 02F7 01 ADD 02F8 61 PUSH2 0x0277 02FB 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02F7 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0277 label_02FC: // Incoming jump from 0x0245, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02FD msg.value } 02FC 5B JUMPDEST 02FD 34 CALLVALUE 02FE 80 DUP1 02FF 15 ISZERO 0300 61 PUSH2 0x0308 0303 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02FD stack[0] = msg.value } // Block ends with conditional jump to 0x0308, if !msg.value label_0304: // Incoming jump from 0x0303, if not !msg.value // Inputs[1] { @0307 memory[0x00:0x00] } 0304 60 PUSH1 0x00 0306 80 DUP1 0307 FD *REVERT // Stack delta = +0 // Outputs[1] { @0307 revert(memory[0x00:0x00]); } // Block terminates label_0308: // Incoming jump from 0x0303, if !msg.value // Inputs[1] { @0310 msg.data.length } 0308 5B JUMPDEST 0309 50 POP 030A 61 PUSH2 0x02a0 030D 61 PUSH2 0x0317 0310 36 CALLDATASIZE 0311 60 PUSH1 0x04 0313 61 PUSH2 0x32f7 0316 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @030A stack[-1] = 0x02a0 // @030D stack[0] = 0x0317 // @0310 stack[1] = msg.data.length // @0311 stack[2] = 0x04 // } // Block ends with call to 0x32f7, returns to 0x0317 label_0317: // Incoming return from call to 0x32F7 at 0x0316 0317 5B JUMPDEST 0318 61 PUSH2 0x0945 031B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0945 label_031C: // Incoming jump from 0x01DD, if 0x0e316ab7 == stack[-1] // Inputs[1] { @031D msg.value } 031C 5B JUMPDEST 031D 34 CALLVALUE 031E 80 DUP1 031F 15 ISZERO 0320 61 PUSH2 0x0328 0323 57 *JUMPI // Stack delta = +1 // Outputs[1] { @031D stack[0] = msg.value } // Block ends with conditional jump to 0x0328, if !msg.value label_0324: // Incoming jump from 0x0323, if not !msg.value // Inputs[1] { @0327 memory[0x00:0x00] } 0324 60 PUSH1 0x00 0326 80 DUP1 0327 FD *REVERT // Stack delta = +0 // Outputs[1] { @0327 revert(memory[0x00:0x00]); } // Block terminates label_0328: // Incoming jump from 0x0323, if !msg.value // Inputs[1] { @0330 msg.data.length } 0328 5B JUMPDEST 0329 50 POP 032A 61 PUSH2 0x02a0 032D 61 PUSH2 0x0337 0330 36 CALLDATASIZE 0331 60 PUSH1 0x04 0333 61 PUSH2 0x3323 0336 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @032A stack[-1] = 0x02a0 // @032D stack[0] = 0x0337 // @0330 stack[1] = msg.data.length // @0331 stack[2] = 0x04 // } // Block ends with call to 0x3323, returns to 0x0337 label_0337: // Incoming return from call to 0x3323 at 0x0336 0337 5B JUMPDEST 0338 61 PUSH2 0x0a5b 033B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a5b label_033C: // Incoming jump from 0x01E8, if 0x18160ddd == stack[-1] // Inputs[1] { @033D msg.value } 033C 5B JUMPDEST 033D 34 CALLVALUE 033E 80 DUP1 033F 15 ISZERO 0340 61 PUSH2 0x0348 0343 57 *JUMPI // Stack delta = +1 // Outputs[1] { @033D stack[0] = msg.value } // Block ends with conditional jump to 0x0348, if !msg.value label_0344: // Incoming jump from 0x0343, if not !msg.value // Inputs[1] { @0347 memory[0x00:0x00] } 0344 60 PUSH1 0x00 0346 80 DUP1 0347 FD *REVERT // Stack delta = +0 // Outputs[1] { @0347 revert(memory[0x00:0x00]); } // Block terminates label_0348: // Incoming jump from 0x0343, if !msg.value // Inputs[1] { @034C storage[0x08] } 0348 5B JUMPDEST 0349 50 POP 034A 60 PUSH1 0x08 034C 54 SLOAD 034D 61 PUSH2 0x0353 0350 90 SWAP1 0351 81 DUP2 0352 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0350 stack[0] = storage[0x08] // @0350 stack[-1] = 0x0353 // } // Block ends with unconditional jump to 0x0353 label_0353: // Incoming return from call to 0x0559 at 0x0558 // Incoming return from call to 0x047B at 0x047A // Incoming return from call to 0x0FE9 at 0x05BA // Incoming jump from 0x0352 // Incoming jump from 0x064B // Inputs[2] // { // @0356 memory[0x40:0x60] // @0357 stack[-1] // } 0353 5B JUMPDEST 0354 60 PUSH1 0x40 0356 51 MLOAD 0357 90 SWAP1 0358 81 DUP2 0359 52 MSTORE 035A 60 PUSH1 0x20 035C 01 ADD 035D 61 PUSH2 0x0277 0360 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0359 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @035C stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0277 label_0361: // Incoming jump from 0x01F3, if 0x1c31f710 == stack[-1] // Inputs[1] { @0362 msg.value } 0361 5B JUMPDEST 0362 34 CALLVALUE 0363 80 DUP1 0364 15 ISZERO 0365 61 PUSH2 0x036d 0368 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0362 stack[0] = msg.value } // Block ends with conditional jump to 0x036d, if !msg.value label_0369: // Incoming jump from 0x0368, if not !msg.value // Inputs[1] { @036C memory[0x00:0x00] } 0369 60 PUSH1 0x00 036B 80 DUP1 036C FD *REVERT // Stack delta = +0 // Outputs[1] { @036C revert(memory[0x00:0x00]); } // Block terminates label_036D: // Incoming jump from 0x0368, if !msg.value // Inputs[1] { @0375 msg.data.length } 036D 5B JUMPDEST 036E 50 POP 036F 61 PUSH2 0x02a0 0372 61 PUSH2 0x037c 0375 36 CALLDATASIZE 0376 60 PUSH1 0x04 0378 61 PUSH2 0x3323 037B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @036F stack[-1] = 0x02a0 // @0372 stack[0] = 0x037c // @0375 stack[1] = msg.data.length // @0376 stack[2] = 0x04 // } // Block ends with call to 0x3323, returns to 0x037C label_037C: // Incoming return from call to 0x3323 at 0x037B 037C 5B JUMPDEST 037D 61 PUSH2 0x0a90 0380 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a90 label_0381: // Incoming jump from 0x01FE, if 0x23b872dd == stack[-1] // Inputs[1] { @0382 msg.value } 0381 5B JUMPDEST 0382 34 CALLVALUE 0383 80 DUP1 0384 15 ISZERO 0385 61 PUSH2 0x038d 0388 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0382 stack[0] = msg.value } // Block ends with conditional jump to 0x038d, if !msg.value label_0389: // Incoming jump from 0x0388, if not !msg.value // Inputs[1] { @038C memory[0x00:0x00] } 0389 60 PUSH1 0x00 038B 80 DUP1 038C FD *REVERT // Stack delta = +0 // Outputs[1] { @038C revert(memory[0x00:0x00]); } // Block terminates label_038D: // Incoming jump from 0x0388, if !msg.value // Inputs[1] { @0395 msg.data.length } 038D 5B JUMPDEST 038E 50 POP 038F 61 PUSH2 0x02a0 0392 61 PUSH2 0x039c 0395 36 CALLDATASIZE 0396 60 PUSH1 0x04 0398 61 PUSH2 0x3340 039B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @038F stack[-1] = 0x02a0 // @0392 stack[0] = 0x039c // @0395 stack[1] = msg.data.length // @0396 stack[2] = 0x04 // } // Block ends with call to 0x3340, returns to 0x039C label_039C: // Incoming return from call to 0x3340 at 0x039B 039C 5B JUMPDEST 039D 61 PUSH2 0x0adc 03A0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0adc label_03A1: // Incoming jump from 0x0209, if 0x254a4737 == stack[-1] // Inputs[1] { @03A2 msg.value } 03A1 5B JUMPDEST 03A2 34 CALLVALUE 03A3 80 DUP1 03A4 15 ISZERO 03A5 61 PUSH2 0x03ad 03A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A2 stack[0] = msg.value } // Block ends with conditional jump to 0x03ad, if !msg.value label_03A9: // Incoming jump from 0x03A8, if not !msg.value // Inputs[1] { @03AC memory[0x00:0x00] } 03A9 60 PUSH1 0x00 03AB 80 DUP1 03AC FD *REVERT // Stack delta = +0 // Outputs[1] { @03AC revert(memory[0x00:0x00]); } // Block terminates label_03AD: // Incoming jump from 0x03A8, if !msg.value // Inputs[1] { @03B5 msg.data.length } 03AD 5B JUMPDEST 03AE 50 POP 03AF 61 PUSH2 0x02a0 03B2 61 PUSH2 0x03bc 03B5 36 CALLDATASIZE 03B6 60 PUSH1 0x04 03B8 61 PUSH2 0x3396 03BB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03AF stack[-1] = 0x02a0 // @03B2 stack[0] = 0x03bc // @03B5 stack[1] = msg.data.length // @03B6 stack[2] = 0x04 // } // Block ends with call to 0x3396, returns to 0x03BC label_03BC: // Incoming return from call to 0x3396 at 0x03BB 03BC 5B JUMPDEST 03BD 61 PUSH2 0x0b0d 03C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b0d label_03C1: // Incoming jump from 0x0196, if 0x2a55205a == stack[-1] // Inputs[1] { @03C2 msg.value } 03C1 5B JUMPDEST 03C2 34 CALLVALUE 03C3 80 DUP1 03C4 15 ISZERO 03C5 61 PUSH2 0x03cd 03C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C2 stack[0] = msg.value } // Block ends with conditional jump to 0x03cd, if !msg.value label_03C9: // Incoming jump from 0x03C8, if not !msg.value // Inputs[1] { @03CC memory[0x00:0x00] } 03C9 60 PUSH1 0x00 03CB 80 DUP1 03CC FD *REVERT // Stack delta = +0 // Outputs[1] { @03CC revert(memory[0x00:0x00]); } // Block terminates label_03CD: // Incoming jump from 0x03C8, if !msg.value // Inputs[1] { @03D5 msg.data.length } 03CD 5B JUMPDEST 03CE 50 POP 03CF 61 PUSH2 0x03e1 03D2 61 PUSH2 0x03dc 03D5 36 CALLDATASIZE 03D6 60 PUSH1 0x04 03D8 61 PUSH2 0x33b1 03DB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03CF stack[-1] = 0x03e1 // @03D2 stack[0] = 0x03dc // @03D5 stack[1] = msg.data.length // @03D6 stack[2] = 0x04 // } // Block ends with call to 0x33b1, returns to 0x03DC label_03DC: // Incoming return from call to 0x33B1 at 0x03DB 03DC 5B JUMPDEST 03DD 61 PUSH2 0x0b4a 03E0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b4a label_03E1: // Incoming return from call to 0x03DC at 0x03DB // Inputs[3] // { // @03E5 memory[0x40:0x60] // @03EF stack[-2] // @03F7 stack[-1] // } 03E1 5B JUMPDEST 03E2 60 PUSH1 0x40 03E4 80 DUP1 03E5 51 MLOAD 03E6 60 PUSH1 0x01 03E8 60 PUSH1 0x01 03EA 60 PUSH1 0xa0 03EC 1B SHL 03ED 03 SUB 03EE 90 SWAP1 03EF 93 SWAP4 03F0 16 AND 03F1 83 DUP4 03F2 52 MSTORE 03F3 60 PUSH1 0x20 03F5 83 DUP4 03F6 01 ADD 03F7 91 SWAP2 03F8 90 SWAP1 03F9 91 SWAP2 03FA 52 MSTORE 03FB 01 ADD 03FC 61 PUSH2 0x0277 03FF 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @03F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @03FA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @03FB stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0277 label_0400: // Incoming jump from 0x01A1, if 0x2f274bd4 == stack[-1] // Inputs[1] { @0401 msg.value } 0400 5B JUMPDEST 0401 34 CALLVALUE 0402 80 DUP1 0403 15 ISZERO 0404 61 PUSH2 0x040c 0407 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0401 stack[0] = msg.value } // Block ends with conditional jump to 0x040c, if !msg.value label_0408: // Incoming jump from 0x0407, if not !msg.value // Inputs[1] { @040B memory[0x00:0x00] } 0408 60 PUSH1 0x00 040A 80 DUP1 040B FD *REVERT // Stack delta = +0 // Outputs[1] { @040B revert(memory[0x00:0x00]); } // Block terminates label_040C: // Incoming jump from 0x0407, if !msg.value // Inputs[1] { @0414 msg.data.length } 040C 5B JUMPDEST 040D 50 POP 040E 61 PUSH2 0x02a0 0411 61 PUSH2 0x041b 0414 36 CALLDATASIZE 0415 60 PUSH1 0x04 0417 61 PUSH2 0x3412 041A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @040E stack[-1] = 0x02a0 // @0411 stack[0] = 0x041b // @0414 stack[1] = msg.data.length // @0415 stack[2] = 0x04 // } // Block ends with call to 0x3412, returns to 0x041B label_041B: // Incoming return from call to 0x3412 at 0x041A 041B 5B JUMPDEST 041C 61 PUSH2 0x0bf8 041F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bf8 label_0420: // Incoming jump from 0x01AC, if 0x30176e13 == stack[-1] // Inputs[1] { @0421 msg.value } 0420 5B JUMPDEST 0421 34 CALLVALUE 0422 80 DUP1 0423 15 ISZERO 0424 61 PUSH2 0x042c 0427 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0421 stack[0] = msg.value } // Block ends with conditional jump to 0x042c, if !msg.value label_0428: // Incoming jump from 0x0427, if not !msg.value // Inputs[1] { @042B memory[0x00:0x00] } 0428 60 PUSH1 0x00 042A 80 DUP1 042B FD *REVERT // Stack delta = +0 // Outputs[1] { @042B revert(memory[0x00:0x00]); } // Block terminates label_042C: // Incoming jump from 0x0427, if !msg.value // Inputs[1] { @0434 msg.data.length } 042C 5B JUMPDEST 042D 50 POP 042E 61 PUSH2 0x02a0 0431 61 PUSH2 0x043b 0434 36 CALLDATASIZE 0435 60 PUSH1 0x04 0437 61 PUSH2 0x3513 043A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @042E stack[-1] = 0x02a0 // @0431 stack[0] = 0x043b // @0434 stack[1] = msg.data.length // @0435 stack[2] = 0x04 // } // Block ends with call to 0x3513, returns to 0x043B label_043B: // Incoming return from call to 0x3513 at 0x043A 043B 5B JUMPDEST 043C 61 PUSH2 0x0de6 043F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0de6 label_0440: // Incoming jump from 0x01B7, if 0x38af3eed == stack[-1] // Inputs[1] { @0441 msg.value } 0440 5B JUMPDEST 0441 34 CALLVALUE 0442 80 DUP1 0443 15 ISZERO 0444 61 PUSH2 0x044c 0447 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0441 stack[0] = msg.value } // Block ends with conditional jump to 0x044c, if !msg.value label_0448: // Incoming jump from 0x0447, if not !msg.value // Inputs[1] { @044B memory[0x00:0x00] } 0448 60 PUSH1 0x00 044A 80 DUP1 044B FD *REVERT // Stack delta = +0 // Outputs[1] { @044B revert(memory[0x00:0x00]); } // Block terminates label_044C: // Incoming jump from 0x0447, if !msg.value // Inputs[1] { @0450 storage[0x10] } 044C 5B JUMPDEST 044D 50 POP 044E 60 PUSH1 0x10 0450 54 SLOAD 0451 61 PUSH2 0x02e4 0454 90 SWAP1 0455 60 PUSH1 0x01 0457 60 PUSH1 0x01 0459 60 PUSH1 0xa0 045B 1B SHL 045C 03 SUB 045D 16 AND 045E 81 DUP2 045F 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0454 stack[-1] = 0x02e4 // @045D stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x10] // } // Block ends with unconditional jump to 0x02e4 label_0460: // Incoming jump from 0x01C2, if 0x3ec02e14 == stack[-1] // Inputs[1] { @0461 msg.value } 0460 5B JUMPDEST 0461 34 CALLVALUE 0462 80 DUP1 0463 15 ISZERO 0464 61 PUSH2 0x046c 0467 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0461 stack[0] = msg.value } // Block ends with conditional jump to 0x046c, if !msg.value label_0468: // Incoming jump from 0x0467, if not !msg.value // Inputs[1] { @046B memory[0x00:0x00] } 0468 60 PUSH1 0x00 046A 80 DUP1 046B FD *REVERT // Stack delta = +0 // Outputs[1] { @046B revert(memory[0x00:0x00]); } // Block terminates label_046C: // Incoming jump from 0x0467, if !msg.value // Inputs[1] { @0474 msg.data.length } 046C 5B JUMPDEST 046D 50 POP 046E 61 PUSH2 0x0353 0471 61 PUSH2 0x047b 0474 36 CALLDATASIZE 0475 60 PUSH1 0x04 0477 61 PUSH2 0x33b1 047A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @046E stack[-1] = 0x0353 // @0471 stack[0] = 0x047b // @0474 stack[1] = msg.data.length // @0475 stack[2] = 0x04 // } // Block ends with call to 0x33b1, returns to 0x047B label_047B: // Incoming return from call to 0x33B1 at 0x047A 047B 5B JUMPDEST 047C 61 PUSH2 0x0e23 047F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e23 label_0480: // Incoming jump from 0x015A, if 0x3f4ba83a == stack[-1] // Inputs[1] { @0481 msg.value } 0480 5B JUMPDEST 0481 34 CALLVALUE 0482 80 DUP1 0483 15 ISZERO 0484 61 PUSH2 0x048c 0487 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0481 stack[0] = msg.value } // Block ends with conditional jump to 0x048c, if !msg.value label_0488: // Incoming jump from 0x0487, if not !msg.value // Inputs[1] { @048B memory[0x00:0x00] } 0488 60 PUSH1 0x00 048A 80 DUP1 048B FD *REVERT // Stack delta = +0 // Outputs[1] { @048B revert(memory[0x00:0x00]); } // Block terminates label_048C: // Incoming jump from 0x0487, if !msg.value 048C 5B JUMPDEST 048D 50 POP 048E 61 PUSH2 0x02a0 0491 61 PUSH2 0x0e36 0494 56 *JUMP // Stack delta = +0 // Outputs[1] { @048E stack[-1] = 0x02a0 } // Block ends with call to 0x0e36, returns to 0x02A0 label_0495: // Incoming jump from 0x0165, if 0x42842e0e == stack[-1] // Inputs[1] { @0496 msg.value } 0495 5B JUMPDEST 0496 34 CALLVALUE 0497 80 DUP1 0498 15 ISZERO 0499 61 PUSH2 0x04a1 049C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0496 stack[0] = msg.value } // Block ends with conditional jump to 0x04a1, if !msg.value label_049D: // Incoming jump from 0x049C, if not !msg.value // Inputs[1] { @04A0 memory[0x00:0x00] } 049D 60 PUSH1 0x00 049F 80 DUP1 04A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A0 revert(memory[0x00:0x00]); } // Block terminates label_04A1: // Incoming jump from 0x049C, if !msg.value // Inputs[1] { @04A9 msg.data.length } 04A1 5B JUMPDEST 04A2 50 POP 04A3 61 PUSH2 0x02a0 04A6 61 PUSH2 0x04b0 04A9 36 CALLDATASIZE 04AA 60 PUSH1 0x04 04AC 61 PUSH2 0x3340 04AF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04A3 stack[-1] = 0x02a0 // @04A6 stack[0] = 0x04b0 // @04A9 stack[1] = msg.data.length // @04AA stack[2] = 0x04 // } // Block ends with call to 0x3340, returns to 0x04B0 label_04B0: // Incoming return from call to 0x3340 at 0x04AF 04B0 5B JUMPDEST 04B1 61 PUSH2 0x0e6a 04B4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e6a label_04B5: // Incoming jump from 0x0170, if 0x53ac010a == stack[-1] // Inputs[1] { @04B6 msg.value } 04B5 5B JUMPDEST 04B6 34 CALLVALUE 04B7 80 DUP1 04B8 15 ISZERO 04B9 61 PUSH2 0x04c1 04BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B6 stack[0] = msg.value } // Block ends with conditional jump to 0x04c1, if !msg.value label_04BD: // Incoming jump from 0x04BC, if not !msg.value // Inputs[1] { @04C0 memory[0x00:0x00] } 04BD 60 PUSH1 0x00 04BF 80 DUP1 04C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C0 revert(memory[0x00:0x00]); } // Block terminates label_04C1: // Incoming jump from 0x04BC, if !msg.value // Inputs[1] { @04C5 storage[0x19] } 04C1 5B JUMPDEST 04C2 50 POP 04C3 60 PUSH1 0x19 04C5 54 SLOAD 04C6 61 PUSH2 0x026b 04C9 90 SWAP1 04CA 60 PUSH1 0xff 04CC 16 AND 04CD 81 DUP2 04CE 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04C9 stack[-1] = 0x026b // @04CC stack[0] = 0xff & storage[0x19] // } // Block ends with unconditional jump to 0x026b label_04CF: // Incoming jump from 0x017B, if 0x5a028400 == stack[-1] // Inputs[1] { @04D0 msg.value } 04CF 5B JUMPDEST 04D0 34 CALLVALUE 04D1 80 DUP1 04D2 15 ISZERO 04D3 61 PUSH2 0x04db 04D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D0 stack[0] = msg.value } // Block ends with conditional jump to 0x04db, if !msg.value label_04D7: // Incoming jump from 0x04D6, if not !msg.value // Inputs[1] { @04DA memory[0x00:0x00] } 04D7 60 PUSH1 0x00 04D9 80 DUP1 04DA FD *REVERT // Stack delta = +0 // Outputs[1] { @04DA revert(memory[0x00:0x00]); } // Block terminates label_04DB: // Incoming jump from 0x04D6, if !msg.value // Inputs[1] { @04E3 msg.data.length } 04DB 5B JUMPDEST 04DC 50 POP 04DD 61 PUSH2 0x026b 04E0 61 PUSH2 0x04ea 04E3 36 CALLDATASIZE 04E4 60 PUSH1 0x04 04E6 61 PUSH2 0x32de 04E9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04DD stack[-1] = 0x026b // @04E0 stack[0] = 0x04ea // @04E3 stack[1] = msg.data.length // @04E4 stack[2] = 0x04 // } // Block ends with call to 0x32de, returns to 0x04EA label_04EA: // Incoming return from call to 0x32DE at 0x04E9 // Inputs[4] // { // @04F2 stack[-1] // @04F8 memory[0x00:0x40] // @04F9 storage[keccak256(memory[0x00:0x40])] // @04FD stack[-2] // } 04EA 5B JUMPDEST 04EB 60 PUSH1 0x18 04ED 60 PUSH1 0x20 04EF 52 MSTORE 04F0 60 PUSH1 0x00 04F2 90 SWAP1 04F3 81 DUP2 04F4 52 MSTORE 04F5 60 PUSH1 0x40 04F7 90 SWAP1 04F8 20 SHA3 04F9 54 SLOAD 04FA 60 PUSH1 0xff 04FC 16 AND 04FD 81 DUP2 04FE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04EF memory[0x20:0x40] = 0x18 // @04F4 memory[0x00:0x20] = stack[-1] // @04FC stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_04FF: // Incoming jump from 0x0186, if 0x5c975abb == stack[-1] // Inputs[1] { @0500 msg.value } 04FF 5B JUMPDEST 0500 34 CALLVALUE 0501 80 DUP1 0502 15 ISZERO 0503 61 PUSH2 0x050b 0506 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0500 stack[0] = msg.value } // Block ends with conditional jump to 0x050b, if !msg.value label_0507: // Incoming jump from 0x0506, if not !msg.value // Inputs[1] { @050A memory[0x00:0x00] } 0507 60 PUSH1 0x00 0509 80 DUP1 050A FD *REVERT // Stack delta = +0 // Outputs[1] { @050A revert(memory[0x00:0x00]); } // Block terminates label_050B: // Incoming jump from 0x0506, if !msg.value // Inputs[1] { @050F storage[0x06] } 050B 5B JUMPDEST 050C 50 POP 050D 60 PUSH1 0x06 050F 54 SLOAD 0510 60 PUSH1 0x01 0512 60 PUSH1 0xa0 0514 1B SHL 0515 90 SWAP1 0516 04 DIV 0517 60 PUSH1 0xff 0519 16 AND 051A 61 PUSH2 0x026b 051D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0519 stack[-1] = 0xff & storage[0x06] / (0x01 << 0xa0) } // Block ends with unconditional jump to 0x026b label_051E: // Incoming jump from 0x0108, if 0x6352211e == stack[-1] // Inputs[1] { @051F msg.value } 051E 5B JUMPDEST 051F 34 CALLVALUE 0520 80 DUP1 0521 15 ISZERO 0522 61 PUSH2 0x052a 0525 57 *JUMPI // Stack delta = +1 // Outputs[1] { @051F stack[0] = msg.value } // Block ends with conditional jump to 0x052a, if !msg.value label_0526: // Incoming jump from 0x0525, if not !msg.value // Inputs[1] { @0529 memory[0x00:0x00] } 0526 60 PUSH1 0x00 0528 80 DUP1 0529 FD *REVERT // Stack delta = +0 // Outputs[1] { @0529 revert(memory[0x00:0x00]); } // Block terminates label_052A: // Incoming jump from 0x0525, if !msg.value // Inputs[1] { @0532 msg.data.length } 052A 5B JUMPDEST 052B 50 POP 052C 61 PUSH2 0x02e4 052F 61 PUSH2 0x0539 0532 36 CALLDATASIZE 0533 60 PUSH1 0x04 0535 61 PUSH2 0x32de 0538 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @052C stack[-1] = 0x02e4 // @052F stack[0] = 0x0539 // @0532 stack[1] = msg.data.length // @0533 stack[2] = 0x04 // } // Block ends with call to 0x32de, returns to 0x0539 label_0539: // Incoming return from call to 0x32DE at 0x0538 0539 5B JUMPDEST 053A 61 PUSH2 0x0e85 053D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e85 label_053E: // Incoming jump from 0x0113, if 0x70a08231 == stack[-1] // Inputs[1] { @053F msg.value } 053E 5B JUMPDEST 053F 34 CALLVALUE 0540 80 DUP1 0541 15 ISZERO 0542 61 PUSH2 0x054a 0545 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053F stack[0] = msg.value } // Block ends with conditional jump to 0x054a, if !msg.value label_0546: // Incoming jump from 0x0545, if not !msg.value // Inputs[1] { @0549 memory[0x00:0x00] } 0546 60 PUSH1 0x00 0548 80 DUP1 0549 FD *REVERT // Stack delta = +0 // Outputs[1] { @0549 revert(memory[0x00:0x00]); } // Block terminates label_054A: // Incoming jump from 0x0545, if !msg.value // Inputs[1] { @0552 msg.data.length } 054A 5B JUMPDEST 054B 50 POP 054C 61 PUSH2 0x0353 054F 61 PUSH2 0x0559 0552 36 CALLDATASIZE 0553 60 PUSH1 0x04 0555 61 PUSH2 0x3323 0558 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @054C stack[-1] = 0x0353 // @054F stack[0] = 0x0559 // @0552 stack[1] = msg.data.length // @0553 stack[2] = 0x04 // } // Block ends with call to 0x3323, returns to 0x0559 label_0559: // Incoming return from call to 0x3323 at 0x0558 0559 5B JUMPDEST 055A 61 PUSH2 0x0efc 055D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0efc label_055E: // Incoming jump from 0x011E, if 0x715018a6 == stack[-1] // Inputs[1] { @055F msg.value } 055E 5B JUMPDEST 055F 34 CALLVALUE 0560 80 DUP1 0561 15 ISZERO 0562 61 PUSH2 0x056a 0565 57 *JUMPI // Stack delta = +1 // Outputs[1] { @055F stack[0] = msg.value } // Block ends with conditional jump to 0x056a, if !msg.value label_0566: // Incoming jump from 0x0565, if not !msg.value // Inputs[1] { @0569 memory[0x00:0x00] } 0566 60 PUSH1 0x00 0568 80 DUP1 0569 FD *REVERT // Stack delta = +0 // Outputs[1] { @0569 revert(memory[0x00:0x00]); } // Block terminates label_056A: // Incoming jump from 0x0565, if !msg.value 056A 5B JUMPDEST 056B 50 POP 056C 61 PUSH2 0x02a0 056F 61 PUSH2 0x0f83 0572 56 *JUMP // Stack delta = +0 // Outputs[1] { @056C stack[-1] = 0x02a0 } // Block ends with call to 0x0f83, returns to 0x02A0 label_0573: // Incoming jump from 0x0129, if 0x8456cb59 == stack[-1] // Inputs[1] { @0574 msg.value } 0573 5B JUMPDEST 0574 34 CALLVALUE 0575 80 DUP1 0576 15 ISZERO 0577 61 PUSH2 0x057f 057A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0574 stack[0] = msg.value } // Block ends with conditional jump to 0x057f, if !msg.value label_057B: // Incoming jump from 0x057A, if not !msg.value // Inputs[1] { @057E memory[0x00:0x00] } 057B 60 PUSH1 0x00 057D 80 DUP1 057E FD *REVERT // Stack delta = +0 // Outputs[1] { @057E revert(memory[0x00:0x00]); } // Block terminates label_057F: // Incoming jump from 0x057A, if !msg.value 057F 5B JUMPDEST 0580 50 POP 0581 61 PUSH2 0x02a0 0584 61 PUSH2 0x0fb7 0587 56 *JUMP // Stack delta = +0 // Outputs[1] { @0581 stack[-1] = 0x02a0 } // Block ends with call to 0x0fb7, returns to 0x02A0 label_0588: // Incoming jump from 0x0134, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0589 msg.value } 0588 5B JUMPDEST 0589 34 CALLVALUE 058A 80 DUP1 058B 15 ISZERO 058C 61 PUSH2 0x0594 058F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0589 stack[0] = msg.value } // Block ends with conditional jump to 0x0594, if !msg.value label_0590: // Incoming jump from 0x058F, if not !msg.value // Inputs[1] { @0593 memory[0x00:0x00] } 0590 60 PUSH1 0x00 0592 80 DUP1 0593 FD *REVERT // Stack delta = +0 // Outputs[1] { @0593 revert(memory[0x00:0x00]); } // Block terminates label_0594: // Incoming jump from 0x058F, if !msg.value // Inputs[1] { @0598 storage[0x06] } 0594 5B JUMPDEST 0595 50 POP 0596 60 PUSH1 0x06 0598 54 SLOAD 0599 60 PUSH1 0x01 059B 60 PUSH1 0x01 059D 60 PUSH1 0xa0 059F 1B SHL 05A0 03 SUB 05A1 16 AND 05A2 61 PUSH2 0x02e4 05A5 56 *JUMP // Stack delta = +0 // Outputs[1] { @05A1 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x06] } // Block ends with unconditional jump to 0x02e4 label_05A6: // Incoming jump from 0x00CC, if 0x9106d7ba == stack[-1] // Inputs[1] { @05A7 msg.value } 05A6 5B JUMPDEST 05A7 34 CALLVALUE 05A8 80 DUP1 05A9 15 ISZERO 05AA 61 PUSH2 0x05b2 05AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A7 stack[0] = msg.value } // Block ends with conditional jump to 0x05b2, if !msg.value label_05AE: // Incoming jump from 0x05AD, if not !msg.value // Inputs[1] { @05B1 memory[0x00:0x00] } 05AE 60 PUSH1 0x00 05B0 80 DUP1 05B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B1 revert(memory[0x00:0x00]); } // Block terminates label_05B2: // Incoming jump from 0x05AD, if !msg.value 05B2 5B JUMPDEST 05B3 50 POP 05B4 61 PUSH2 0x0353 05B7 61 PUSH2 0x0fe9 05BA 56 *JUMP // Stack delta = +0 // Outputs[1] { @05B4 stack[-1] = 0x0353 } // Block ends with call to 0x0fe9, returns to 0x0353 label_05BB: // Incoming jump from 0x00D7, if 0x9437bfa0 == stack[-1] // Inputs[1] { @05BC msg.value } 05BB 5B JUMPDEST 05BC 34 CALLVALUE 05BD 80 DUP1 05BE 15 ISZERO 05BF 61 PUSH2 0x05c7 05C2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05BC stack[0] = msg.value } // Block ends with conditional jump to 0x05c7, if !msg.value label_05C3: // Incoming jump from 0x05C2, if not !msg.value // Inputs[1] { @05C6 memory[0x00:0x00] } 05C3 60 PUSH1 0x00 05C5 80 DUP1 05C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C6 revert(memory[0x00:0x00]); } // Block terminates label_05C7: // Incoming jump from 0x05C2, if !msg.value // Inputs[1] { @05CF msg.data.length } 05C7 5B JUMPDEST 05C8 50 POP 05C9 61 PUSH2 0x026b 05CC 61 PUSH2 0x05d6 05CF 36 CALLDATASIZE 05D0 60 PUSH1 0x04 05D2 61 PUSH2 0x355c 05D5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C9 stack[-1] = 0x026b // @05CC stack[0] = 0x05d6 // @05CF stack[1] = msg.data.length // @05D0 stack[2] = 0x04 // } // Block ends with call to 0x355c, returns to 0x05D6 label_05D6: // Incoming return from call to 0x355C at 0x05D5 05D6 5B JUMPDEST 05D7 61 PUSH2 0x0ff9 05DA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ff9 label_05DB: // Incoming jump from 0x00E2, if 0x95d89b41 == stack[-1] // Inputs[1] { @05DC msg.value } 05DB 5B JUMPDEST 05DC 34 CALLVALUE 05DD 80 DUP1 05DE 15 ISZERO 05DF 61 PUSH2 0x05e7 05E2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05DC stack[0] = msg.value } // Block ends with conditional jump to 0x05e7, if !msg.value label_05E3: // Incoming jump from 0x05E2, if not !msg.value // Inputs[1] { @05E6 memory[0x00:0x00] } 05E3 60 PUSH1 0x00 05E5 80 DUP1 05E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E6 revert(memory[0x00:0x00]); } // Block terminates label_05E7: // Incoming jump from 0x05E2, if !msg.value 05E7 5B JUMPDEST 05E8 50 POP 05E9 61 PUSH2 0x02b7 05EC 61 PUSH2 0x102e 05EF 56 *JUMP // Stack delta = +0 // Outputs[1] { @05E9 stack[-1] = 0x02b7 } // Block ends with call to 0x102e, returns to 0x02B7 label_05F0: // Incoming jump from 0x00ED, if 0x96d66de0 == stack[-1] // Inputs[1] { @05F7 msg.data.length } 05F0 5B JUMPDEST 05F1 61 PUSH2 0x02a0 05F4 61 PUSH2 0x05fe 05F7 36 CALLDATASIZE 05F8 60 PUSH1 0x04 05FA 61 PUSH2 0x3591 05FD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05F1 stack[0] = 0x02a0 // @05F4 stack[1] = 0x05fe // @05F7 stack[2] = msg.data.length // @05F8 stack[3] = 0x04 // } // Block ends with call to 0x3591, returns to 0x05FE label_05FE: // Incoming return from call to 0x3591 at 0x05FD 05FE 5B JUMPDEST 05FF 61 PUSH2 0x103d 0602 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x103d label_0603: // Incoming jump from 0x00F8, if 0x9f93f779 == stack[-1] // Inputs[1] { @060A msg.data.length } 0603 5B JUMPDEST 0604 61 PUSH2 0x02a0 0607 61 PUSH2 0x0611 060A 36 CALLDATASIZE 060B 60 PUSH1 0x04 060D 61 PUSH2 0x32f7 0610 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0604 stack[0] = 0x02a0 // @0607 stack[1] = 0x0611 // @060A stack[2] = msg.data.length // @060B stack[3] = 0x04 // } // Block ends with call to 0x32f7, returns to 0x0611 label_0611: // Incoming return from call to 0x32F7 at 0x0610 0611 5B JUMPDEST 0612 61 PUSH2 0x106a 0615 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x106a label_0616: // Incoming jump from 0x0085, if 0xa22cb465 == stack[-1] // Inputs[1] { @0617 msg.value } 0616 5B JUMPDEST 0617 34 CALLVALUE 0618 80 DUP1 0619 15 ISZERO 061A 61 PUSH2 0x0622 061D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0617 stack[0] = msg.value } // Block ends with conditional jump to 0x0622, if !msg.value label_061E: // Incoming jump from 0x061D, if not !msg.value // Inputs[1] { @0621 memory[0x00:0x00] } 061E 60 PUSH1 0x00 0620 80 DUP1 0621 FD *REVERT // Stack delta = +0 // Outputs[1] { @0621 revert(memory[0x00:0x00]); } // Block terminates label_0622: // Incoming jump from 0x061D, if !msg.value // Inputs[1] { @062A msg.data.length } 0622 5B JUMPDEST 0623 50 POP 0624 61 PUSH2 0x02a0 0627 61 PUSH2 0x0631 062A 36 CALLDATASIZE 062B 60 PUSH1 0x04 062D 61 PUSH2 0x3627 0630 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0624 stack[-1] = 0x02a0 // @0627 stack[0] = 0x0631 // @062A stack[1] = msg.data.length // @062B stack[2] = 0x04 // } // Block ends with call to 0x3627, returns to 0x0631 label_0631: // Incoming return from call to 0x3627 at 0x0630 0631 5B JUMPDEST 0632 61 PUSH2 0x10ba 0635 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10ba label_0636: // Incoming jump from 0x0090, if 0xa945bf80 == stack[-1] // Inputs[1] { @0637 msg.value } 0636 5B JUMPDEST 0637 34 CALLVALUE 0638 80 DUP1 0639 15 ISZERO 063A 61 PUSH2 0x0642 063D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0637 stack[0] = msg.value } // Block ends with conditional jump to 0x0642, if !msg.value label_063E: // Incoming jump from 0x063D, if not !msg.value // Inputs[1] { @0641 memory[0x00:0x00] } 063E 60 PUSH1 0x00 0640 80 DUP1 0641 FD *REVERT // Stack delta = +0 // Outputs[1] { @0641 revert(memory[0x00:0x00]); } // Block terminates label_0642: // Incoming jump from 0x063D, if !msg.value // Inputs[1] { @0649 storage[0x1a] } 0642 5B JUMPDEST 0643 50 POP 0644 61 PUSH2 0x0353 0647 60 PUSH1 0x1a 0649 54 SLOAD 064A 81 DUP2 064B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0644 stack[-1] = 0x0353 // @0649 stack[0] = storage[0x1a] // } // Block ends with unconditional jump to 0x0353 label_064C: // Incoming jump from 0x009B, if 0xb88d4fde == stack[-1] // Inputs[1] { @064D msg.value } 064C 5B JUMPDEST 064D 34 CALLVALUE 064E 80 DUP1 064F 15 ISZERO 0650 61 PUSH2 0x0658 0653 57 *JUMPI // Stack delta = +1 // Outputs[1] { @064D stack[0] = msg.value } // Block ends with conditional jump to 0x0658, if !msg.value label_0654: // Incoming jump from 0x0653, if not !msg.value // Inputs[1] { @0657 memory[0x00:0x00] } 0654 60 PUSH1 0x00 0656 80 DUP1 0657 FD *REVERT // Stack delta = +0 // Outputs[1] { @0657 revert(memory[0x00:0x00]); } // Block terminates label_0658: // Incoming jump from 0x0653, if !msg.value // Inputs[1] { @0660 msg.data.length } 0658 5B JUMPDEST 0659 50 POP 065A 61 PUSH2 0x02a0 065D 61 PUSH2 0x0667 0660 36 CALLDATASIZE 0661 60 PUSH1 0x04 0663 61 PUSH2 0x365c 0666 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @065A stack[-1] = 0x02a0 // @065D stack[0] = 0x0667 // @0660 stack[1] = msg.data.length // @0661 stack[2] = 0x04 // } // Block ends with call to 0x365c, returns to 0x0667 label_0667: // Incoming return from call to 0x365C at 0x0666 0667 5B JUMPDEST 0668 61 PUSH2 0x10c4 066B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10c4 label_066C: // Incoming jump from 0x00A6, if 0xbb69b7ef == stack[-1] // Inputs[1] { @066D msg.value } 066C 5B JUMPDEST 066D 34 CALLVALUE 066E 80 DUP1 066F 15 ISZERO 0670 61 PUSH2 0x0678 0673 57 *JUMPI // Stack delta = +1 // Outputs[1] { @066D stack[0] = msg.value } // Block ends with conditional jump to 0x0678, if !msg.value label_0674: // Incoming jump from 0x0673, if not !msg.value // Inputs[1] { @0677 memory[0x00:0x00] } 0674 60 PUSH1 0x00 0676 80 DUP1 0677 FD *REVERT // Stack delta = +0 // Outputs[1] { @0677 revert(memory[0x00:0x00]); } // Block terminates label_0678: // Incoming jump from 0x0673, if !msg.value // Inputs[5] // { // @067C storage[0x0b] // @067F storage[0x0c] // @0682 storage[0x0d] // @0685 storage[0x0e] // @0688 storage[0x0f] // } 0678 5B JUMPDEST 0679 50 POP 067A 60 PUSH1 0x0b 067C 54 SLOAD 067D 60 PUSH1 0x0c 067F 54 SLOAD 0680 60 PUSH1 0x0d 0682 54 SLOAD 0683 60 PUSH1 0x0e 0685 54 SLOAD 0686 60 PUSH1 0x0f 0688 54 SLOAD 0689 61 PUSH2 0x06b4 068C 94 SWAP5 068D 93 SWAP4 068E 92 SWAP3 068F 91 SWAP2 0690 60 PUSH1 0x01 0692 60 PUSH1 0x01 0694 60 PUSH1 0xf8 0696 1B SHL 0697 03 SUB 0698 81 DUP2 0699 16 AND 069A 91 SWAP2 069B 60 PUSH1 0xff 069D 60 PUSH1 0x01 069F 60 PUSH1 0xf8 06A1 1B SHL 06A2 90 SWAP1 06A3 92 SWAP3 06A4 04 DIV 06A5 82 DUP3 06A6 16 AND 06A7 91 SWAP2 06A8 81 DUP2 06A9 81 DUP2 06AA 16 AND 06AB 91 SWAP2 06AC 61 PUSH2 0x0100 06AF 90 SWAP1 06B0 04 DIV 06B1 16 AND 06B2 87 DUP8 06B3 56 *JUMP // Stack delta = +7 // Outputs[8] // { // @068C stack[-1] = 0x06b4 // @068D stack[0] = storage[0x0b] // @068E stack[1] = storage[0x0c] // @068F stack[2] = storage[0x0d] // @069A stack[3] = storage[0x0e] & (0x01 << 0xf8) - 0x01 // @06A7 stack[4] = 0xff & storage[0x0e] / (0x01 << 0xf8) // @06AB stack[5] = 0xff & storage[0x0f] // @06B1 stack[6] = storage[0x0f] / 0x0100 & 0xff // } // Block ends with unconditional jump to 0x06b4 label_06B4: // Incoming jump from 0x06B3 // Inputs[8] // { // @06B8 memory[0x40:0x60] // @06B9 stack[-7] // @06C0 stack[-6] // @06C4 stack[-1] // @06C7 stack[-5] // @06C8 stack[-2] // @06D3 stack[-3] // @06D4 stack[-4] // } 06B4 5B JUMPDEST 06B5 60 PUSH1 0x40 06B7 80 DUP1 06B8 51 MLOAD 06B9 97 SWAP8 06BA 88 DUP9 06BB 52 MSTORE 06BC 60 PUSH1 0x20 06BE 88 DUP9 06BF 01 ADD 06C0 96 SWAP7 06C1 90 SWAP1 06C2 96 SWAP7 06C3 52 MSTORE 06C4 94 SWAP5 06C5 86 DUP7 06C6 01 ADD 06C7 93 SWAP4 06C8 90 SWAP1 06C9 93 SWAP4 06CA 52 MSTORE 06CB 60 PUSH1 0x01 06CD 60 PUSH1 0x01 06CF 60 PUSH1 0xf8 06D1 1B SHL 06D2 03 SUB 06D3 90 SWAP1 06D4 91 SWAP2 06D5 16 AND 06D6 60 PUSH1 0x60 06D8 85 DUP6 06D9 01 ADD 06DA 52 MSTORE 06DB 15 ISZERO 06DC 15 ISZERO 06DD 60 PUSH1 0x80 06DF 84 DUP5 06E0 01 ADD 06E1 52 MSTORE 06E2 15 ISZERO 06E3 15 ISZERO 06E4 60 PUSH1 0xa0 06E6 83 DUP4 06E7 01 ADD 06E8 52 MSTORE 06E9 15 ISZERO 06EA 15 ISZERO 06EB 60 PUSH1 0xc0 06ED 82 DUP3 06EE 01 ADD 06EF 52 MSTORE 06F0 60 PUSH1 0xe0 06F2 01 ADD 06F3 61 PUSH2 0x0277 06F6 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @06BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-7] // @06C3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-6] // @06CA memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-5] // @06DA memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-4] & (0x01 << 0xf8) - 0x01 // @06E1 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = !!stack[-3] // @06E8 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = !!stack[-2] // @06EF memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = !!stack[-1] // @06F2 stack[-7] = 0xe0 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0277 label_06F7: // Incoming jump from 0x00B1, if 0xbf62e21d == stack[-1] // Inputs[1] { @06F8 msg.value } 06F7 5B JUMPDEST 06F8 34 CALLVALUE 06F9 80 DUP1 06FA 15 ISZERO 06FB 61 PUSH2 0x0703 06FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0703, if !msg.value label_06FF: // Incoming jump from 0x06FE, if not !msg.value // Inputs[1] { @0702 memory[0x00:0x00] } 06FF 60 PUSH1 0x00 0701 80 DUP1 0702 FD *REVERT // Stack delta = +0 // Outputs[1] { @0702 revert(memory[0x00:0x00]); } // Block terminates label_0703: // Incoming jump from 0x06FE, if !msg.value // Inputs[1] { @070B msg.data.length } 0703 5B JUMPDEST 0704 50 POP 0705 61 PUSH2 0x02a0 0708 61 PUSH2 0x0712 070B 36 CALLDATASIZE 070C 60 PUSH1 0x04 070E 61 PUSH2 0x32f7 0711 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0705 stack[-1] = 0x02a0 // @0708 stack[0] = 0x0712 // @070B stack[1] = msg.data.length // @070C stack[2] = 0x04 // } // Block ends with call to 0x32f7, returns to 0x0712 label_0712: // Incoming return from call to 0x32F7 at 0x0711 0712 5B JUMPDEST 0713 61 PUSH2 0x10fc 0716 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10fc label_0717: // Incoming jump from 0x003E, if 0xc6275255 == stack[-1] // Inputs[1] { @0718 msg.value } 0717 5B JUMPDEST 0718 34 CALLVALUE 0719 80 DUP1 071A 15 ISZERO 071B 61 PUSH2 0x0723 071E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0718 stack[0] = msg.value } // Block ends with conditional jump to 0x0723, if !msg.value label_071F: // Incoming jump from 0x071E, if not !msg.value // Inputs[1] { @0722 memory[0x00:0x00] } 071F 60 PUSH1 0x00 0721 80 DUP1 0722 FD *REVERT // Stack delta = +0 // Outputs[1] { @0722 revert(memory[0x00:0x00]); } // Block terminates label_0723: // Incoming jump from 0x071E, if !msg.value // Inputs[1] { @072B msg.data.length } 0723 5B JUMPDEST 0724 50 POP 0725 61 PUSH2 0x02a0 0728 61 PUSH2 0x0732 072B 36 CALLDATASIZE 072C 60 PUSH1 0x04 072E 61 PUSH2 0x32de 0731 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0725 stack[-1] = 0x02a0 // @0728 stack[0] = 0x0732 // @072B stack[1] = msg.data.length // @072C stack[2] = 0x04 // } // Block ends with call to 0x32de, returns to 0x0732 label_0732: // Incoming return from call to 0x32DE at 0x0731 0732 5B JUMPDEST 0733 61 PUSH2 0x1271 0736 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1271 label_0737: // Incoming jump from 0x0049, if 0xc87b56dd == stack[-1] // Inputs[1] { @0738 msg.value } 0737 5B JUMPDEST 0738 34 CALLVALUE 0739 80 DUP1 073A 15 ISZERO 073B 61 PUSH2 0x0743 073E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0738 stack[0] = msg.value } // Block ends with conditional jump to 0x0743, if !msg.value label_073F: // Incoming jump from 0x073E, if not !msg.value // Inputs[1] { @0742 memory[0x00:0x00] } 073F 60 PUSH1 0x00 0741 80 DUP1 0742 FD *REVERT // Stack delta = +0 // Outputs[1] { @0742 revert(memory[0x00:0x00]); } // Block terminates label_0743: // Incoming jump from 0x073E, if !msg.value // Inputs[1] { @074B msg.data.length } 0743 5B JUMPDEST 0744 50 POP 0745 61 PUSH2 0x02b7 0748 61 PUSH2 0x0752 074B 36 CALLDATASIZE 074C 60 PUSH1 0x04 074E 61 PUSH2 0x32de 0751 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0745 stack[-1] = 0x02b7 // @0748 stack[0] = 0x0752 // @074B stack[1] = msg.data.length // @074C stack[2] = 0x04 // } // Block ends with call to 0x32de, returns to 0x0752 label_0752: // Incoming return from call to 0x32DE at 0x0751 0752 5B JUMPDEST 0753 61 PUSH2 0x12a0 0756 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x12a0 label_0757: // Incoming jump from 0x0054, if 0xd547cfb7 == stack[-1] // Inputs[1] { @0758 msg.value } 0757 5B JUMPDEST 0758 34 CALLVALUE 0759 80 DUP1 075A 15 ISZERO 075B 61 PUSH2 0x0763 075E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0758 stack[0] = msg.value } // Block ends with conditional jump to 0x0763, if !msg.value label_075F: // Incoming jump from 0x075E, if not !msg.value // Inputs[1] { @0762 memory[0x00:0x00] } 075F 60 PUSH1 0x00 0761 80 DUP1 0762 FD *REVERT // Stack delta = +0 // Outputs[1] { @0762 revert(memory[0x00:0x00]); } // Block terminates label_0763: // Incoming jump from 0x075E, if !msg.value 0763 5B JUMPDEST 0764 50 POP 0765 61 PUSH2 0x02b7 0768 61 PUSH2 0x137a 076B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0765 stack[-1] = 0x02b7 } // Block ends with call to 0x137a, returns to 0x02B7 label_076C: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @076D msg.value } 076C 5B JUMPDEST 076D 34 CALLVALUE 076E 80 DUP1 076F 15 ISZERO 0770 61 PUSH2 0x0778 0773 57 *JUMPI // Stack delta = +1 // Outputs[1] { @076D stack[0] = msg.value } // Block ends with conditional jump to 0x0778, if !msg.value label_0774: // Incoming jump from 0x0773, if not !msg.value // Inputs[1] { @0777 memory[0x00:0x00] } 0774 60 PUSH1 0x00 0776 80 DUP1 0777 FD *REVERT // Stack delta = +0 // Outputs[1] { @0777 revert(memory[0x00:0x00]); } // Block terminates label_0778: // Incoming jump from 0x0773, if !msg.value // Inputs[1] { @0780 msg.data.length } 0778 5B JUMPDEST 0779 50 POP 077A 61 PUSH2 0x026b 077D 61 PUSH2 0x0787 0780 36 CALLDATASIZE 0781 60 PUSH1 0x04 0783 61 PUSH2 0x36dc 0786 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @077A stack[-1] = 0x026b // @077D stack[0] = 0x0787 // @0780 stack[1] = msg.data.length // @0781 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x36dc 0787 5B JUMPDEST 0788 61 PUSH2 0x1408 078B 56 *JUMP label_078C: // Incoming jump from 0x006A, if 0xeb12d61e == stack[-1] // Inputs[1] { @078D msg.value } 078C 5B JUMPDEST 078D 34 CALLVALUE 078E 80 DUP1 078F 15 ISZERO 0790 61 PUSH2 0x0798 0793 57 *JUMPI // Stack delta = +1 // Outputs[1] { @078D stack[0] = msg.value } // Block ends with conditional jump to 0x0798, if !msg.value label_0794: // Incoming jump from 0x0793, if not !msg.value // Inputs[1] { @0797 memory[0x00:0x00] } 0794 60 PUSH1 0x00 0796 80 DUP1 0797 FD *REVERT // Stack delta = +0 // Outputs[1] { @0797 revert(memory[0x00:0x00]); } // Block terminates label_0798: // Incoming jump from 0x0793, if !msg.value // Inputs[1] { @07A0 msg.data.length } 0798 5B JUMPDEST 0799 50 POP 079A 61 PUSH2 0x02a0 079D 61 PUSH2 0x07a7 07A0 36 CALLDATASIZE 07A1 60 PUSH1 0x04 07A3 61 PUSH2 0x3323 07A6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @079A stack[-1] = 0x02a0 // @079D stack[0] = 0x07a7 // @07A0 stack[1] = msg.data.length // @07A1 stack[2] = 0x04 // } // Block ends with call to 0x3323, returns to 0x07A7 label_07A7: // Incoming return from call to 0x3323 at 0x07A6 07A7 5B JUMPDEST 07A8 61 PUSH2 0x1414 07AB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1414 label_07AC: // Incoming jump from 0x0075, if 0xf2fde38b == stack[-1] // Inputs[1] { @07AD msg.value } 07AC 5B JUMPDEST 07AD 34 CALLVALUE 07AE 80 DUP1 07AF 15 ISZERO 07B0 61 PUSH2 0x07b8 07B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07AD stack[0] = msg.value } // Block ends with conditional jump to 0x07b8, if !msg.value label_07B4: // Incoming jump from 0x07B3, if not !msg.value // Inputs[1] { @07B7 memory[0x00:0x00] } 07B4 60 PUSH1 0x00 07B6 80 DUP1 07B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B7 revert(memory[0x00:0x00]); } // Block terminates label_07B8: // Incoming jump from 0x07B3, if !msg.value // Inputs[1] { @07C0 msg.data.length } 07B8 5B JUMPDEST 07B9 50 POP 07BA 61 PUSH2 0x02a0 07BD 61 PUSH2 0x07c7 07C0 36 CALLDATASIZE 07C1 60 PUSH1 0x04 07C3 61 PUSH2 0x3323 07C6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07BA stack[-1] = 0x02a0 // @07BD stack[0] = 0x07c7 // @07C0 stack[1] = msg.data.length // @07C1 stack[2] = 0x04 // } // Block ends with call to 0x3323, returns to 0x07C7 label_07C7: // Incoming return from call to 0x3323 at 0x07C6 07C7 5B JUMPDEST 07C8 61 PUSH2 0x1449 07CB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1449 label_07CC: // Incoming jump from 0x026A // Inputs[1] { @07D2 stack[-1] } 07CC 5B JUMPDEST 07CD 60 PUSH1 0x00 07CF 61 PUSH2 0x07d7 07D2 82 DUP3 07D3 61 PUSH2 0x14e8 07D6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07CD stack[0] = 0x00 // @07CF stack[1] = 0x07d7 // @07D2 stack[2] = stack[-1] // } // Block ends with call to 0x14e8, returns to 0x07D7 label_07D7: // Incoming jump from 0x23F5 // Incoming jump from 0x29DF // Incoming jump from 0x2A1E, if stack[-1] // Incoming return from call to 0x14E8 at 0x07D6 // Incoming return from call to 0x2302 at 0x150C // Incoming jump from 0x2A37 // Incoming return from call to 0x29E8 at 0x230C // Incoming jump from 0x2A1E, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x240B at 0x1AAF // Incoming jump from 0x29E7 // Incoming jump from 0x22AD // Incoming jump from 0x0EA2, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x23FF // Incoming jump from 0x1503, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[3] // { // @07D8 stack[-1] // @07D8 stack[-4] // @07D9 stack[-3] // } 07D7 5B JUMPDEST 07D8 92 SWAP3 07D9 91 SWAP2 07DA 50 POP 07DB 50 POP 07DC 56 *JUMP // Stack delta = -3 // Outputs[1] { @07D8 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_07DD: // Incoming jump from 0x029F // Inputs[2] // { // @07E0 storage[0x06] // @07EA msg.sender // } 07DD 5B JUMPDEST 07DE 60 PUSH1 0x06 07E0 54 SLOAD 07E1 60 PUSH1 0x01 07E3 60 PUSH1 0x01 07E5 60 PUSH1 0xa0 07E7 1B SHL 07E8 03 SUB 07E9 16 AND 07EA 33 CALLER 07EB 14 EQ 07EC 61 PUSH2 0x0810 07EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0810, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_07F0: // Incoming jump from 0x07EF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @07F2 memory[0x40:0x60] } 07F0 60 PUSH1 0x40 07F2 51 MLOAD 07F3 62 PUSH3 0x461bcd 07F7 60 PUSH1 0xe5 07F9 1B SHL 07FA 81 DUP2 07FB 52 MSTORE 07FC 60 PUSH1 0x04 07FE 01 ADD 07FF 61 PUSH2 0x0807 0802 90 SWAP1 0803 61 PUSH2 0x370a 0806 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0802 stack[0] = 0x0807 // @0802 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0807: // Incoming return from call to 0x370A at 0x0E0F // Incoming return from call to 0x370A at 0x143D // Incoming return from call to 0x377A at 0x10E9 // Incoming jump from 0x1D02 // Incoming jump from 0x17DA // Incoming return from call to 0x370A at 0x1472 // Incoming jump from 0x10AC // Incoming return from call to 0x370A at 0x1125 // Incoming return from call to 0x370A at 0x0A84 // Incoming jump from 0x0CD5 // Incoming jump from 0x131E // Incoming jump from 0x1BAB // Incoming return from call to 0x370A at 0x0C21 // Incoming jump from 0x11C9 // Incoming jump from 0x121E // Incoming jump from 0x1705 // Incoming return from call to 0x382A at 0x114F // Incoming jump from 0x2F93 // Incoming jump from 0x157A // Incoming jump from 0x2F2E // Incoming jump from 0x195A // Incoming jump from 0x15D0 // Incoming return from call to 0x382A at 0x1BDA // Incoming jump from 0x0EFB // Incoming jump from 0x0D3E // Incoming return from call to 0x370A at 0x0AB9 // Incoming return from call to 0x370A at 0x0E5F // Incoming return from call to 0x382A at 0x1A23 // Incoming jump from 0x183C // Incoming return from call to 0x370A at 0x0B36 // Incoming jump from 0x09BD // Incoming jump from 0x0C82 // Incoming jump from 0x2C37 // Incoming jump from 0x14D7 // Incoming return from call to 0x370A at 0x129A // Incoming return from call to 0x377A at 0x0B01 // Incoming jump from 0x0F66 // Incoming jump from 0x0928 // Incoming return from call to 0x370A at 0x0FAC // Incoming return from call to 0x370A at 0x0806 // Incoming return from call to 0x370A at 0x0FE0 // Incoming jump from 0x0A4B // Incoming jump from 0x27CD // Inputs[3] // { // @080A memory[0x40:0x60] // @080C stack[-1] // @080F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0807 5B JUMPDEST 0808 60 PUSH1 0x40 080A 51 MLOAD 080B 80 DUP1 080C 91 SWAP2 080D 03 SUB 080E 90 SWAP1 080F FD *REVERT // Stack delta = -1 // Outputs[1] { @080F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0810: // Incoming jump from 0x07EF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @0814 stack[-2] // @0815 stack[-1] // } 0810 5B JUMPDEST 0811 61 PUSH2 0x081a 0814 82 DUP3 0815 82 DUP3 0816 61 PUSH2 0x150d 0819 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0811 stack[0] = 0x081a // @0814 stack[1] = stack[-2] // @0815 stack[2] = stack[-1] // } // Block ends with call to 0x150d, returns to 0x081A label_081A: // Incoming return from call to 0x1678 at 0x0A8F // Incoming return from call to 0x2037 at 0x10C3 // Incoming return from call to 0x2037 at 0x10C3 // Incoming return from call to 0x150D at 0x0819 // Incoming return from call to 0x2B80 at 0x294A // Incoming return from call to 0x22ED at 0x1448 // Inputs[1] { @081D stack[-3] } 081A 5B JUMPDEST 081B 50 POP 081C 50 POP 081D 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_081E: // Incoming call from 0x02B6, returns to 0x02B7 // Inputs[1] { @0824 storage[0x00] } 081E 5B JUMPDEST 081F 60 PUSH1 0x60 0821 60 PUSH1 0x00 0823 80 DUP1 0824 54 SLOAD 0825 61 PUSH2 0x082d 0828 90 SWAP1 0829 61 PUSH2 0x373f 082C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @081F stack[0] = 0x60 // @0821 stack[1] = 0x00 // @0828 stack[2] = 0x082d // @0828 stack[3] = storage[0x00] // } // Block ends with call to 0x373f, returns to 0x082D label_082D: // Incoming return from call to 0x373F at 0x082C // Incoming return from call to 0x373F at 0x103C // Incoming return from call to 0x373F at 0x2959 // Inputs[4] // { // @082E stack[-1] // @083D memory[0x40:0x60] // @0845 stack[-2] // @0850 storage[stack[-2]] // } 082D 5B JUMPDEST 082E 80 DUP1 082F 60 PUSH1 0x1f 0831 01 ADD 0832 60 PUSH1 0x20 0834 80 DUP1 0835 91 SWAP2 0836 04 DIV 0837 02 MUL 0838 60 PUSH1 0x20 083A 01 ADD 083B 60 PUSH1 0x40 083D 51 MLOAD 083E 90 SWAP1 083F 81 DUP2 0840 01 ADD 0841 60 PUSH1 0x40 0843 52 MSTORE 0844 80 DUP1 0845 92 SWAP3 0846 91 SWAP2 0847 90 SWAP1 0848 81 DUP2 0849 81 DUP2 084A 52 MSTORE 084B 60 PUSH1 0x20 084D 01 ADD 084E 82 DUP3 084F 80 DUP1 0850 54 SLOAD 0851 61 PUSH2 0x0859 0854 90 SWAP1 0855 61 PUSH2 0x373f 0858 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0843 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0845 stack[-2] = memory[0x40:0x60] // @0846 stack[-1] = stack[-2] // @0847 stack[0] = stack[-1] // @084A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @084D stack[1] = 0x20 + memory[0x40:0x60] // @084E stack[2] = stack[-2] // @0854 stack[4] = storage[stack[-2]] // @0854 stack[3] = 0x0859 // } // Block ends with call to 0x373f, returns to 0x0859 label_0859: // Incoming return from call to 0x373F at 0x0858 // Inputs[1] { @085A stack[-1] } 0859 5B JUMPDEST 085A 80 DUP1 085B 15 ISZERO 085C 61 PUSH2 0x08a6 085F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08a6, if !stack[-1] label_0860: // Incoming jump from 0x085F, if not !stack[-1] // Inputs[1] { @0860 stack[-1] } 0860 80 DUP1 0861 60 PUSH1 0x1f 0863 10 LT 0864 61 PUSH2 0x087b 0867 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x087b, if 0x1f < stack[-1] label_0868: // Incoming jump from 0x0867, if not 0x1f < stack[-1] // Inputs[4] // { // @086C stack[-2] // @086D storage[stack[-2]] // @0870 stack[-3] // @0872 stack[-1] // } 0868 61 PUSH2 0x0100 086B 80 DUP1 086C 83 DUP4 086D 54 SLOAD 086E 04 DIV 086F 02 MUL 0870 83 DUP4 0871 52 MSTORE 0872 91 SWAP2 0873 60 PUSH1 0x20 0875 01 ADD 0876 91 SWAP2 0877 61 PUSH2 0x08a6 087A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0871 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0876 stack[-1] = stack[-1] // @0876 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x08a6 label_087B: // Incoming jump from 0x0867, if 0x1f < stack[-1] // Inputs[5] // { // @087C stack[-3] // @087D stack[-1] // @087F stack[-2] // @0887 memory[0x00:0x20] // @088B storage[keccak256(memory[0x00:0x20])] // } 087B 5B JUMPDEST 087C 82 DUP3 087D 01 ADD 087E 91 SWAP2 087F 90 SWAP1 0880 60 PUSH1 0x00 0882 52 MSTORE 0883 60 PUSH1 0x20 0885 60 PUSH1 0x00 0887 20 SHA3 0888 90 SWAP1 0889 5B JUMPDEST 088A 81 DUP2 088B 54 SLOAD 088C 81 DUP2 088D 52 MSTORE 088E 90 SWAP1 088F 60 PUSH1 0x01 0891 01 ADD 0892 90 SWAP1 0893 60 PUSH1 0x20 0895 01 ADD 0896 80 DUP1 0897 83 DUP4 0898 11 GT 0899 61 PUSH2 0x0889 089C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @087E stack[-3] = stack[-3] + stack[-1] // @0882 memory[0x00:0x20] = stack[-2] // @088D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0892 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0895 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0889, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_089D: // Incoming jump from 0x089C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x089C, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @089D stack[-3] // @089E stack[-1] // } 089D 82 DUP3 089E 90 SWAP1 089F 03 SUB 08A0 60 PUSH1 0x1f 08A2 16 AND 08A3 82 DUP3 08A4 01 ADD 08A5 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @08A5 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @08A5 stack[-1] = stack[-3] // } // Block continues label_08A6: // Incoming jump from 0x085F, if !stack[-1] // Incoming jump from 0x08A5 // Incoming jump from 0x087A // Inputs[3] // { // @08AC stack[-7] // @08AC stack[-6] // @08AE stack[-8] // } 08A6 5B JUMPDEST 08A7 50 POP 08A8 50 POP 08A9 50 POP 08AA 50 POP 08AB 50 POP 08AC 90 SWAP1 08AD 50 POP 08AE 90 SWAP1 08AF 56 *JUMP // Stack delta = -7 // Outputs[1] { @08AE stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_08B0: // Incoming call from 0x1740, returns to 0x1741 // Incoming jump from 0x02E3 // Inputs[3] // { // @08B3 stack[-1] // @08BE memory[0x00:0x40] // @08BF storage[keccak256(memory[0x00:0x40])] // } 08B0 5B JUMPDEST 08B1 60 PUSH1 0x00 08B3 81 DUP2 08B4 81 DUP2 08B5 52 MSTORE 08B6 60 PUSH1 0x02 08B8 60 PUSH1 0x20 08BA 52 MSTORE 08BB 60 PUSH1 0x40 08BD 81 DUP2 08BE 20 SHA3 08BF 54 SLOAD 08C0 60 PUSH1 0x01 08C2 60 PUSH1 0x01 08C4 60 PUSH1 0xa0 08C6 1B SHL 08C7 03 SUB 08C8 16 AND 08C9 61 PUSH2 0x0929 08CC 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @08B1 stack[0] = 0x00 // @08B5 memory[0x00:0x20] = stack[-1] // @08BA memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x0929, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_08CD: // Incoming jump from 0x08CC, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @08CF memory[0x40:0x60] } 08CD 60 PUSH1 0x40 08CF 51 MLOAD 08D0 62 PUSH3 0x461bcd 08D4 60 PUSH1 0xe5 08D6 1B SHL 08D7 81 DUP2 08D8 52 MSTORE 08D9 60 PUSH1 0x20 08DB 60 PUSH1 0x04 08DD 82 DUP3 08DE 01 ADD 08DF 52 MSTORE 08E0 60 PUSH1 0x2c 08E2 60 PUSH1 0x24 08E4 82 DUP3 08E5 01 ADD 08E6 52 MSTORE 08E7 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 0908 60 PUSH1 0x44 090A 82 DUP3 090B 01 ADD 090C 52 MSTORE 090D 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 091A 60 PUSH1 0xa1 091C 1B SHL 091D 60 PUSH1 0x64 091F 82 DUP3 0920 01 ADD 0921 52 MSTORE 0922 60 PUSH1 0x84 0924 01 ADD 0925 61 PUSH2 0x0807 0928 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @08D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08DF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08E6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @090C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @0921 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @0924 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_0929: // Incoming jump from 0x08CC, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @092D stack[-2] // @0938 memory[0x00:0x40] // @0939 storage[keccak256(memory[0x00:0x40])] // @0943 stack[-3] // } 0929 5B JUMPDEST 092A 50 POP 092B 60 PUSH1 0x00 092D 90 SWAP1 092E 81 DUP2 092F 52 MSTORE 0930 60 PUSH1 0x04 0932 60 PUSH1 0x20 0934 52 MSTORE 0935 60 PUSH1 0x40 0937 90 SWAP1 0938 20 SHA3 0939 54 SLOAD 093A 60 PUSH1 0x01 093C 60 PUSH1 0x01 093E 60 PUSH1 0xa0 0940 1B SHL 0941 03 SUB 0942 16 AND 0943 90 SWAP1 0944 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @092F memory[0x00:0x20] = stack[-2] // @0934 memory[0x20:0x40] = 0x04 // @0943 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0945: // Incoming jump from 0x031B // Inputs[1] { @094B stack[-1] } 0945 5B JUMPDEST 0946 60 PUSH1 0x00 0948 61 PUSH2 0x0950 094B 82 DUP3 094C 61 PUSH2 0x0e85 094F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0946 stack[0] = 0x00 // @0948 stack[1] = 0x0950 // @094B stack[2] = stack[-1] // } // Block ends with call to 0x0e85, returns to 0x0950 label_0950: // Incoming return from call to 0x0E85 at 0x094F // Inputs[3] // { // @0951 stack[-2] // @0951 stack[-1] // @095D stack[-4] // } 0950 5B JUMPDEST 0951 90 SWAP1 0952 50 POP 0953 80 DUP1 0954 60 PUSH1 0x01 0956 60 PUSH1 0x01 0958 60 PUSH1 0xa0 095A 1B SHL 095B 03 SUB 095C 16 AND 095D 83 DUP4 095E 60 PUSH1 0x01 0960 60 PUSH1 0x01 0962 60 PUSH1 0xa0 0964 1B SHL 0965 03 SUB 0966 16 AND 0967 14 EQ 0968 15 ISZERO 0969 61 PUSH2 0x09be 096C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0951 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x09be, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_096D: // Incoming jump from 0x096C, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @096F memory[0x40:0x60] } 096D 60 PUSH1 0x40 096F 51 MLOAD 0970 62 PUSH3 0x461bcd 0974 60 PUSH1 0xe5 0976 1B SHL 0977 81 DUP2 0978 52 MSTORE 0979 60 PUSH1 0x20 097B 60 PUSH1 0x04 097D 82 DUP3 097E 01 ADD 097F 52 MSTORE 0980 60 PUSH1 0x21 0982 60 PUSH1 0x24 0984 82 DUP3 0985 01 ADD 0986 52 MSTORE 0987 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 09A8 60 PUSH1 0x44 09AA 82 DUP3 09AB 01 ADD 09AC 52 MSTORE 09AD 60 PUSH1 0x39 09AF 60 PUSH1 0xf9 09B1 1B SHL 09B2 60 PUSH1 0x64 09B4 82 DUP3 09B5 01 ADD 09B6 52 MSTORE 09B7 60 PUSH1 0x84 09B9 01 ADD 09BA 61 PUSH2 0x0807 09BD 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0978 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @097F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0986 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @09AC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @09B6 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39 << 0xf9 // @09B9 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_09BE: // Incoming jump from 0x096C, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @09BF msg.sender // @09C8 stack[-1] // } 09BE 5B JUMPDEST 09BF 33 CALLER 09C0 60 PUSH1 0x01 09C2 60 PUSH1 0x01 09C4 60 PUSH1 0xa0 09C6 1B SHL 09C7 03 SUB 09C8 82 DUP3 09C9 16 AND 09CA 14 EQ 09CB 80 DUP1 09CC 61 PUSH2 0x09da 09CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09CA stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x09da, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_09D0: // Incoming jump from 0x09CF, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @09D4 stack[-2] // @09D5 msg.sender // } 09D0 50 POP 09D1 61 PUSH2 0x09da 09D4 81 DUP2 09D5 33 CALLER 09D6 61 PUSH2 0x1408 09D9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09D1 stack[-1] = 0x09da // @09D4 stack[0] = stack[-2] // @09D5 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1408 label_09DA: // Incoming jump from 0x09CF, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @09DE stack[-1] } 09DA 5B JUMPDEST 09DB 61 PUSH2 0x0a4c 09DE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a4c, if stack[-1] label_09DF: // Incoming jump from 0x09DE, if not stack[-1] // Inputs[1] { @09E1 memory[0x40:0x60] } 09DF 60 PUSH1 0x40 09E1 51 MLOAD 09E2 62 PUSH3 0x461bcd 09E6 60 PUSH1 0xe5 09E8 1B SHL 09E9 81 DUP2 09EA 52 MSTORE 09EB 60 PUSH1 0x20 09ED 60 PUSH1 0x04 09EF 82 DUP3 09F0 01 ADD 09F1 52 MSTORE 09F2 60 PUSH1 0x38 09F4 60 PUSH1 0x24 09F6 82 DUP3 09F7 01 ADD 09F8 52 MSTORE 09F9 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 0A1A 60 PUSH1 0x44 0A1C 82 DUP3 0A1D 01 ADD 0A1E 52 MSTORE 0A1F 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 0A40 60 PUSH1 0x64 0A42 82 DUP3 0A43 01 ADD 0A44 52 MSTORE 0A45 60 PUSH1 0x84 0A47 01 ADD 0A48 61 PUSH2 0x0807 0A4B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @09EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09F1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09F8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x38 // @0A1E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @0A44 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 // @0A47 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_0A4C: // Incoming jump from 0x09DE, if stack[-1] // Inputs[2] // { // @0A50 stack[-3] // @0A51 stack[-2] // } 0A4C 5B JUMPDEST 0A4D 61 PUSH2 0x0a56 0A50 83 DUP4 0A51 83 DUP4 0A52 61 PUSH2 0x160a 0A55 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A4D stack[0] = 0x0a56 // @0A50 stack[1] = stack[-3] // @0A51 stack[2] = stack[-2] // } // Block ends with call to 0x160a, returns to 0x0A56 label_0A56: // Incoming return from call to 0x2A38 at 0x240A // Incoming return from call to 0x2A38 at 0x240A // Incoming return from call to 0x2A38 at 0x240A // Incoming jump from 0x2BDC, if !(0xff & storage[0x06] / (0x01 << 0xa0)) // Incoming return from call to 0x276C at 0x20FD // Incoming return from call to 0x160A at 0x0A55 // Inputs[1] { @0A5A stack[-4] } 0A56 5B JUMPDEST 0A57 50 POP 0A58 50 POP 0A59 50 POP 0A5A 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0A5B: // Incoming jump from 0x033B // Inputs[2] // { // @0A5E storage[0x06] // @0A68 msg.sender // } 0A5B 5B JUMPDEST 0A5C 60 PUSH1 0x06 0A5E 54 SLOAD 0A5F 60 PUSH1 0x01 0A61 60 PUSH1 0x01 0A63 60 PUSH1 0xa0 0A65 1B SHL 0A66 03 SUB 0A67 16 AND 0A68 33 CALLER 0A69 14 EQ 0A6A 61 PUSH2 0x0a85 0A6D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a85, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0A6E: // Incoming jump from 0x0A6D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0A70 memory[0x40:0x60] } 0A6E 60 PUSH1 0x40 0A70 51 MLOAD 0A71 62 PUSH3 0x461bcd 0A75 60 PUSH1 0xe5 0A77 1B SHL 0A78 81 DUP2 0A79 52 MSTORE 0A7A 60 PUSH1 0x04 0A7C 01 ADD 0A7D 61 PUSH2 0x0807 0A80 90 SWAP1 0A81 61 PUSH2 0x370a 0A84 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A80 stack[0] = 0x0807 // @0A80 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0A85: // Incoming jump from 0x0A6D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0A8B stack[-1] } 0A85 5B JUMPDEST 0A86 61 PUSH2 0x081a 0A89 60 PUSH1 0x14 0A8B 82 DUP3 0A8C 61 PUSH2 0x1678 0A8F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A86 stack[0] = 0x081a // @0A89 stack[1] = 0x14 // @0A8B stack[2] = stack[-1] // } // Block ends with call to 0x1678, returns to 0x081A label_0A90: // Incoming jump from 0x0380 // Inputs[2] // { // @0A93 storage[0x06] // @0A9D msg.sender // } 0A90 5B JUMPDEST 0A91 60 PUSH1 0x06 0A93 54 SLOAD 0A94 60 PUSH1 0x01 0A96 60 PUSH1 0x01 0A98 60 PUSH1 0xa0 0A9A 1B SHL 0A9B 03 SUB 0A9C 16 AND 0A9D 33 CALLER 0A9E 14 EQ 0A9F 61 PUSH2 0x0aba 0AA2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aba, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0AA3: // Incoming jump from 0x0AA2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0AA5 memory[0x40:0x60] } 0AA3 60 PUSH1 0x40 0AA5 51 MLOAD 0AA6 62 PUSH3 0x461bcd 0AAA 60 PUSH1 0xe5 0AAC 1B SHL 0AAD 81 DUP2 0AAE 52 MSTORE 0AAF 60 PUSH1 0x04 0AB1 01 ADD 0AB2 61 PUSH2 0x0807 0AB5 90 SWAP1 0AB6 61 PUSH2 0x370a 0AB9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AAE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AB5 stack[0] = 0x0807 // @0AB5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0ABA: // Incoming jump from 0x0AA2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[3] // { // @0ABE storage[0x10] // @0AD1 stack[-1] // @0ADB stack[-2] // } 0ABA 5B JUMPDEST 0ABB 60 PUSH1 0x10 0ABD 80 DUP1 0ABE 54 SLOAD 0ABF 60 PUSH1 0x01 0AC1 60 PUSH1 0x01 0AC3 60 PUSH1 0xa0 0AC5 1B SHL 0AC6 03 SUB 0AC7 19 NOT 0AC8 16 AND 0AC9 60 PUSH1 0x01 0ACB 60 PUSH1 0x01 0ACD 60 PUSH1 0xa0 0ACF 1B SHL 0AD0 03 SUB 0AD1 92 SWAP3 0AD2 90 SWAP1 0AD3 92 SWAP3 0AD4 16 AND 0AD5 91 SWAP2 0AD6 90 SWAP1 0AD7 91 SWAP2 0AD8 17 OR 0AD9 90 SWAP1 0ADA 55 SSTORE 0ADB 56 *JUMP // Stack delta = -2 // Outputs[1] { @0ADA storage[0x10] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x10]) } // Block ends with unconditional jump to stack[-2] label_0ADC: // Incoming jump from 0x03A0 // Inputs[2] // { // @0AE0 msg.sender // @0AE1 stack[-1] // } 0ADC 5B JUMPDEST 0ADD 61 PUSH2 0x0ae6 0AE0 33 CALLER 0AE1 82 DUP3 0AE2 61 PUSH2 0x168d 0AE5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0ADD stack[0] = 0x0ae6 // @0AE0 stack[1] = msg.sender // @0AE1 stack[2] = stack[-1] // } // Block ends with call to 0x168d, returns to 0x0AE6 label_0AE6: // Incoming return from call to 0x168D at 0x0AE5 // Inputs[1] { @0AEA stack[-1] } 0AE6 5B JUMPDEST 0AE7 61 PUSH2 0x0b02 0AEA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b02, if stack[-1] label_0AEB: // Incoming jump from 0x0AEA, if not stack[-1] // Inputs[1] { @0AED memory[0x40:0x60] } 0AEB 60 PUSH1 0x40 0AED 51 MLOAD 0AEE 62 PUSH3 0x461bcd 0AF2 60 PUSH1 0xe5 0AF4 1B SHL 0AF5 81 DUP2 0AF6 52 MSTORE 0AF7 60 PUSH1 0x04 0AF9 01 ADD 0AFA 61 PUSH2 0x0807 0AFD 90 SWAP1 0AFE 61 PUSH2 0x377a 0B01 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0AF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AFD stack[0] = 0x0807 // @0AFD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x377a, returns to 0x0807 label_0B02: // Incoming jump from 0x0AEA, if stack[-1] // Inputs[3] // { // @0B06 stack[-3] // @0B07 stack[-2] // @0B08 stack[-1] // } 0B02 5B JUMPDEST 0B03 61 PUSH2 0x0a56 0B06 83 DUP4 0B07 83 DUP4 0B08 83 DUP4 0B09 61 PUSH2 0x1764 0B0C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B03 stack[0] = 0x0a56 // @0B06 stack[1] = stack[-3] // @0B07 stack[2] = stack[-2] // @0B08 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1764 label_0B0D: // Incoming jump from 0x03C0 // Inputs[2] // { // @0B10 storage[0x06] // @0B1A msg.sender // } 0B0D 5B JUMPDEST 0B0E 60 PUSH1 0x06 0B10 54 SLOAD 0B11 60 PUSH1 0x01 0B13 60 PUSH1 0x01 0B15 60 PUSH1 0xa0 0B17 1B SHL 0B18 03 SUB 0B19 16 AND 0B1A 33 CALLER 0B1B 14 EQ 0B1C 61 PUSH2 0x0b37 0B1F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b37, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0B20: // Incoming jump from 0x0B1F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0B22 memory[0x40:0x60] } 0B20 60 PUSH1 0x40 0B22 51 MLOAD 0B23 62 PUSH3 0x461bcd 0B27 60 PUSH1 0xe5 0B29 1B SHL 0B2A 81 DUP2 0B2B 52 MSTORE 0B2C 60 PUSH1 0x04 0B2E 01 ADD 0B2F 61 PUSH2 0x0807 0B32 90 SWAP1 0B33 61 PUSH2 0x370a 0B36 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B2B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B32 stack[0] = 0x0807 // @0B32 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0B37: // Incoming jump from 0x0B1F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[3] // { // @0B3B storage[0x19] // @0B40 stack[-1] // @0B49 stack[-2] // } 0B37 5B JUMPDEST 0B38 60 PUSH1 0x19 0B3A 80 DUP1 0B3B 54 SLOAD 0B3C 60 PUSH1 0xff 0B3E 19 NOT 0B3F 16 AND 0B40 91 SWAP2 0B41 15 ISZERO 0B42 15 ISZERO 0B43 91 SWAP2 0B44 90 SWAP1 0B45 91 SWAP2 0B46 17 OR 0B47 90 SWAP1 0B48 55 SSTORE 0B49 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B48 storage[0x19] = !!stack[-1] | (~0xff & storage[0x19]) } // Block ends with unconditional jump to stack[-2] label_0B4A: // Incoming jump from 0x03E0 // Inputs[4] // { // @0B4D stack[-2] // @0B5B memory[0x00:0x40] // @0B5D memory[0x40:0x60] // @0B64 storage[keccak256(memory[0x00:0x40])] // } 0B4A 5B JUMPDEST 0B4B 60 PUSH1 0x00 0B4D 82 DUP3 0B4E 81 DUP2 0B4F 52 MSTORE 0B50 60 PUSH1 0x17 0B52 60 PUSH1 0x20 0B54 90 SWAP1 0B55 81 DUP2 0B56 52 MSTORE 0B57 60 PUSH1 0x40 0B59 80 DUP1 0B5A 83 DUP4 0B5B 20 SHA3 0B5C 81 DUP2 0B5D 51 MLOAD 0B5E 80 DUP1 0B5F 83 DUP4 0B60 01 ADD 0B61 90 SWAP1 0B62 92 SWAP3 0B63 52 MSTORE 0B64 54 SLOAD 0B65 60 PUSH1 0x01 0B67 60 PUSH1 0x01 0B69 60 PUSH1 0xa0 0B6B 1B SHL 0B6C 03 SUB 0B6D 81 DUP2 0B6E 16 AND 0B6F 80 DUP1 0B70 83 DUP4 0B71 52 MSTORE 0B72 60 PUSH1 0x01 0B74 60 PUSH1 0xa0 0B76 1B SHL 0B77 90 SWAP1 0B78 91 SWAP2 0B79 04 DIV 0B7A 60 PUSH1 0x01 0B7C 60 PUSH1 0x01 0B7E 60 PUSH1 0x60 0B80 1B SHL 0B81 03 SUB 0B82 16 AND 0B83 92 SWAP3 0B84 82 DUP3 0B85 01 ADD 0B86 92 SWAP3 0B87 90 SWAP1 0B88 92 SWAP3 0B89 52 MSTORE 0B8A 82 DUP3 0B8B 91 SWAP2 0B8C 61 PUSH2 0x0bbf 0B8F 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @0B4B stack[0] = 0x00 // @0B4F memory[0x00:0x20] = stack[-2] // @0B56 memory[0x20:0x40] = 0x17 // @0B62 stack[2] = memory[0x40:0x60] // @0B63 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0B71 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0B89 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0B8B stack[1] = 0x00 // } // Block ends with conditional jump to 0x0bbf, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_0B90: // Incoming jump from 0x0B8F, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0B94 memory[0x40:0x60] // @0B9D storage[0x16] // @0BC4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0BD9 stack[-4] // } 0B90 50 POP 0B91 60 PUSH1 0x40 0B93 80 DUP1 0B94 51 MLOAD 0B95 80 DUP1 0B96 82 DUP3 0B97 01 ADD 0B98 90 SWAP1 0B99 91 SWAP2 0B9A 52 MSTORE 0B9B 60 PUSH1 0x16 0B9D 54 SLOAD 0B9E 60 PUSH1 0x01 0BA0 60 PUSH1 0x01 0BA2 60 PUSH1 0xa0 0BA4 1B SHL 0BA5 03 SUB 0BA6 81 DUP2 0BA7 16 AND 0BA8 82 DUP3 0BA9 52 MSTORE 0BAA 60 PUSH1 0x01 0BAC 60 PUSH1 0xa0 0BAE 1B SHL 0BAF 90 SWAP1 0BB0 04 DIV 0BB1 60 PUSH1 0x01 0BB3 60 PUSH1 0x01 0BB5 60 PUSH1 0x60 0BB7 1B SHL 0BB8 03 SUB 0BB9 16 AND 0BBA 60 PUSH1 0x20 0BBC 82 DUP3 0BBD 01 ADD 0BBE 52 MSTORE 0BBF 5B JUMPDEST 0BC0 60 PUSH1 0x20 0BC2 81 DUP2 0BC3 01 ADD 0BC4 51 MLOAD 0BC5 60 PUSH1 0x00 0BC7 90 SWAP1 0BC8 61 PUSH2 0x2710 0BCB 90 SWAP1 0BCC 61 PUSH2 0x0bde 0BCF 90 SWAP1 0BD0 60 PUSH1 0x01 0BD2 60 PUSH1 0x01 0BD4 60 PUSH1 0x60 0BD6 1B SHL 0BD7 03 SUB 0BD8 16 AND 0BD9 87 DUP8 0BDA 61 PUSH2 0x37e1 0BDD 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0B99 stack[-1] = memory[0x40:0x60] // @0B9A memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0BA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x16] & (0x01 << 0xa0) - 0x01 // @0BBE memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x60) - 0x01 & storage[0x16] / (0x01 << 0xa0) // @0BC7 stack[0] = 0x00 // @0BCB stack[1] = 0x2710 // @0BCF stack[2] = 0x0bde // @0BD8 stack[3] = (0x01 << 0x60) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0BD9 stack[4] = stack[-4] // } // Block ends with call to 0x37e1, returns to 0x0BDE label_0BDE: // Incoming return from call to 0x37E1 at 0x0BDD // Incoming return from call to 0x37E1 at 0x0BDD // Inputs[2] // { // @0BE2 stack[-2] // @0BE3 stack[-1] // } 0BDE 5B JUMPDEST 0BDF 61 PUSH2 0x0be8 0BE2 91 SWAP2 0BE3 90 SWAP1 0BE4 61 PUSH2 0x3816 0BE7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0BE2 stack[-2] = 0x0be8 // @0BE3 stack[-1] = stack[-2] // @0BE3 stack[0] = stack[-1] // } // Block ends with call to 0x3816, returns to 0x0BE8 label_0BE8: // Incoming return from call to 0x3816 at 0x0BE7 // Inputs[9] // { // @0BE9 stack[-1] // @0BE9 stack[-3] // @0BEA memory[stack[-3]:stack[-3] + 0x20] // @0BEB stack[-5] // @0BED stack[-2] // @0BEE stack[-4] // @0BF2 stack[-7] // @0BF4 stack[-8] // @0BF5 stack[-6] // } 0BE8 5B JUMPDEST 0BE9 91 SWAP2 0BEA 51 MLOAD 0BEB 93 SWAP4 0BEC 50 POP 0BED 90 SWAP1 0BEE 91 SWAP2 0BEF 50 POP 0BF0 50 POP 0BF1 5B JUMPDEST 0BF2 92 SWAP3 0BF3 50 POP 0BF4 92 SWAP3 0BF5 90 SWAP1 0BF6 50 POP 0BF7 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0BF2 stack[-7] = stack[-1] // @0BF4 stack[-8] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with unconditional jump to stack[-8] label_0BF8: // Incoming jump from 0x041F // Inputs[2] // { // @0BFB storage[0x06] // @0C05 msg.sender // } 0BF8 5B JUMPDEST 0BF9 60 PUSH1 0x06 0BFB 54 SLOAD 0BFC 60 PUSH1 0x01 0BFE 60 PUSH1 0x01 0C00 60 PUSH1 0xa0 0C02 1B SHL 0C03 03 SUB 0C04 16 AND 0C05 33 CALLER 0C06 14 EQ 0C07 61 PUSH2 0x0c22 0C0A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c22, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0C0B: // Incoming jump from 0x0C0A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0C0D memory[0x40:0x60] } 0C0B 60 PUSH1 0x40 0C0D 51 MLOAD 0C0E 62 PUSH3 0x461bcd 0C12 60 PUSH1 0xe5 0C14 1B SHL 0C15 81 DUP2 0C16 52 MSTORE 0C17 60 PUSH1 0x04 0C19 01 ADD 0C1A 61 PUSH2 0x0807 0C1D 90 SWAP1 0C1E 61 PUSH2 0x370a 0C21 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C16 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C1D stack[0] = 0x0807 // @0C1D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0C22: // Incoming jump from 0x0C0A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[3] // { // @0C23 stack[-1] // @0C27 memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // @0C35 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 0C22 5B JUMPDEST 0C23 80 DUP1 0C24 60 PUSH1 0x60 0C26 01 ADD 0C27 51 MLOAD 0C28 60 PUSH1 0x01 0C2A 60 PUSH1 0x01 0C2C 60 PUSH1 0xf8 0C2E 1B SHL 0C2F 03 SUB 0C30 16 AND 0C31 81 DUP2 0C32 60 PUSH1 0x00 0C34 01 ADD 0C35 51 MLOAD 0C36 10 LT 0C37 15 ISZERO 0C38 61 PUSH2 0x0c83 0C3B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c83, if !(memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] < (0x01 << 0xf8) - 0x01 & memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20]) label_0C3C: // Incoming jump from 0x0C3B, if not !(memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] < (0x01 << 0xf8) - 0x01 & memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20]) // Inputs[1] { @0C3E memory[0x40:0x60] } 0C3C 60 PUSH1 0x40 0C3E 51 MLOAD 0C3F 62 PUSH3 0x461bcd 0C43 60 PUSH1 0xe5 0C45 1B SHL 0C46 81 DUP2 0C47 52 MSTORE 0C48 60 PUSH1 0x20 0C4A 60 PUSH1 0x04 0C4C 82 DUP3 0C4D 01 ADD 0C4E 52 MSTORE 0C4F 60 PUSH1 0x1c 0C51 60 PUSH1 0x24 0C53 82 DUP3 0C54 01 ADD 0C55 52 MSTORE 0C56 7F PUSH32 0x53656c6c65723a2065786365737369766520667265652071756f746100000000 0C77 60 PUSH1 0x44 0C79 82 DUP3 0C7A 01 ADD 0C7B 52 MSTORE 0C7C 60 PUSH1 0x64 0C7E 01 ADD 0C7F 61 PUSH2 0x0807 0C82 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C4E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C55 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @0C7B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53656c6c65723a2065786365737369766520667265652071756f746100000000 // @0C7E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_0C83: // Incoming jump from 0x0C3B, if !(memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] < (0x01 << 0xf8) - 0x01 & memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20]) // Inputs[3] // { // @0C86 storage[0x11] // @0C87 stack[-1] // @0C88 memory[stack[-1]:stack[-1] + 0x20] // } 0C83 5B JUMPDEST 0C84 60 PUSH1 0x11 0C86 54 SLOAD 0C87 81 DUP2 0C88 51 MLOAD 0C89 10 LT 0C8A 15 ISZERO 0C8B 61 PUSH2 0x0cd6 0C8E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cd6, if !(memory[stack[-1]:stack[-1] + 0x20] < storage[0x11]) label_0C8F: // Incoming jump from 0x0C8E, if not !(memory[stack[-1]:stack[-1] + 0x20] < storage[0x11]) // Inputs[1] { @0C91 memory[0x40:0x60] } 0C8F 60 PUSH1 0x40 0C91 51 MLOAD 0C92 62 PUSH3 0x461bcd 0C96 60 PUSH1 0xe5 0C98 1B SHL 0C99 81 DUP2 0C9A 52 MSTORE 0C9B 60 PUSH1 0x20 0C9D 60 PUSH1 0x04 0C9F 82 DUP3 0CA0 01 ADD 0CA1 81 DUP2 0CA2 90 SWAP1 0CA3 52 MSTORE 0CA4 60 PUSH1 0x24 0CA6 82 DUP3 0CA7 01 ADD 0CA8 52 MSTORE 0CA9 7F PUSH32 0x53656c6c65723a20696e76656e746f7279203c20616c726561647920736f6c64 0CCA 60 PUSH1 0x44 0CCC 82 DUP3 0CCD 01 ADD 0CCE 52 MSTORE 0CCF 60 PUSH1 0x64 0CD1 01 ADD 0CD2 61 PUSH2 0x0807 0CD5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C9A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CA3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CA8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0CCE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53656c6c65723a20696e76656e746f7279203c20616c726561647920736f6c64 // @0CD1 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_0CD6: // Incoming jump from 0x0C8E, if !(memory[stack[-1]:stack[-1] + 0x20] < storage[0x11]) // Inputs[3] // { // @0CD9 storage[0x13] // @0CDA stack[-1] // @0CDE memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // } 0CD6 5B JUMPDEST 0CD7 60 PUSH1 0x13 0CD9 54 SLOAD 0CDA 81 DUP2 0CDB 60 PUSH1 0x60 0CDD 01 ADD 0CDE 51 MLOAD 0CDF 60 PUSH1 0x01 0CE1 60 PUSH1 0x01 0CE3 60 PUSH1 0xf8 0CE5 1B SHL 0CE6 03 SUB 0CE7 16 AND 0CE8 10 LT 0CE9 15 ISZERO 0CEA 61 PUSH2 0x0d3f 0CED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d3f, if !((0x01 << 0xf8) - 0x01 & memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] < storage[0x13]) label_0CEE: // Incoming jump from 0x0CED, if not !((0x01 << 0xf8) - 0x01 & memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] < storage[0x13]) // Inputs[1] { @0CF0 memory[0x40:0x60] } 0CEE 60 PUSH1 0x40 0CF0 51 MLOAD 0CF1 62 PUSH3 0x461bcd 0CF5 60 PUSH1 0xe5 0CF7 1B SHL 0CF8 81 DUP2 0CF9 52 MSTORE 0CFA 60 PUSH1 0x20 0CFC 60 PUSH1 0x04 0CFE 82 DUP3 0CFF 01 ADD 0D00 52 MSTORE 0D01 60 PUSH1 0x21 0D03 60 PUSH1 0x24 0D05 82 DUP3 0D06 01 ADD 0D07 52 MSTORE 0D08 7F PUSH32 0x53656c6c65723a20667265652071756f7461203c20616c726561647920757365 0D29 60 PUSH1 0x44 0D2B 82 DUP3 0D2C 01 ADD 0D2D 52 MSTORE 0D2E 60 PUSH1 0x19 0D30 60 PUSH1 0xfa 0D32 1B SHL 0D33 60 PUSH1 0x64 0D35 82 DUP3 0D36 01 ADD 0D37 52 MSTORE 0D38 60 PUSH1 0x84 0D3A 01 ADD 0D3B 61 PUSH2 0x0807 0D3E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0CF9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D00 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D07 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @0D2D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53656c6c65723a20667265652071756f7461203c20616c726561647920757365 // @0D37 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x19 << 0xfa // @0D3A stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_0D3F: // Incoming jump from 0x0CED, if !((0x01 << 0xf8) - 0x01 & memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] < storage[0x13]) // Inputs[1] { @0D42 storage[0x0f] } 0D3F 5B JUMPDEST 0D40 60 PUSH1 0x0f 0D42 54 SLOAD 0D43 61 PUSH2 0x0100 0D46 90 SWAP1 0D47 04 DIV 0D48 60 PUSH1 0xff 0D4A 16 AND 0D4B 15 ISZERO 0D4C 61 PUSH2 0x0d5c 0D4F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d5c, if !(0xff & storage[0x0f] / 0x0100) label_0D50: // Incoming jump from 0x0D4F, if not !(0xff & storage[0x0f] / 0x0100) // Inputs[3] // { // @0D54 stack[-1] // @0D59 storage[0x0b] // @0D5F storage[0x0f] // } 0D50 60 PUSH1 0x01 0D52 60 PUSH1 0xc0 0D54 82 DUP3 0D55 01 ADD 0D56 52 MSTORE 0D57 60 PUSH1 0x0b 0D59 54 SLOAD 0D5A 81 DUP2 0D5B 52 MSTORE 0D5C 5B JUMPDEST 0D5D 60 PUSH1 0x0f 0D5F 54 SLOAD 0D60 60 PUSH1 0xff 0D62 16 AND 0D63 15 ISZERO 0D64 61 PUSH2 0x0d80 0D67 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0D56 memory[stack[-1] + 0xc0:stack[-1] + 0xc0 + 0x20] = 0x01 // @0D5B memory[stack[-1]:stack[-1] + 0x20] = storage[0x0b] // } // Block ends with conditional jump to 0x0d80, if !(0xff & storage[0x0f]) label_0D68: // Incoming jump from 0x0D67, if not !(0xff & storage[0x0f]) // Incoming jump from 0x0D67, if not !(0xff & storage[0x0f]) // Inputs[11] // { // @0D6C stack[-1] // @0D71 storage[0x0e] // @0D82 memory[stack[-1]:stack[-1] + 0x20] // @0D8A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @0D92 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @0D9A memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] // @0D9F memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] // @0DBB memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @0DBF storage[0x0f] // @0DC5 memory[stack[-1] + 0xc0:stack[-1] + 0xc0 + 0x20] // @0DE5 stack[-2] // } 0D68 60 PUSH1 0x01 0D6A 60 PUSH1 0xa0 0D6C 82 DUP3 0D6D 01 ADD 0D6E 52 MSTORE 0D6F 60 PUSH1 0x0e 0D71 54 SLOAD 0D72 60 PUSH1 0x01 0D74 60 PUSH1 0x01 0D76 60 PUSH1 0xf8 0D78 1B SHL 0D79 03 SUB 0D7A 16 AND 0D7B 60 PUSH1 0x60 0D7D 82 DUP3 0D7E 01 ADD 0D7F 52 MSTORE 0D80 5B JUMPDEST 0D81 80 DUP1 0D82 51 MLOAD 0D83 60 PUSH1 0x0b 0D85 55 SSTORE 0D86 60 PUSH1 0x20 0D88 81 DUP2 0D89 01 ADD 0D8A 51 MLOAD 0D8B 60 PUSH1 0x0c 0D8D 55 SSTORE 0D8E 60 PUSH1 0x40 0D90 81 DUP2 0D91 01 ADD 0D92 51 MLOAD 0D93 60 PUSH1 0x0d 0D95 55 SSTORE 0D96 60 PUSH1 0x60 0D98 81 DUP2 0D99 01 ADD 0D9A 51 MLOAD 0D9B 60 PUSH1 0x80 0D9D 82 DUP3 0D9E 01 ADD 0D9F 51 MLOAD 0DA0 15 ISZERO 0DA1 15 ISZERO 0DA2 60 PUSH1 0x01 0DA4 60 PUSH1 0xf8 0DA6 1B SHL 0DA7 02 MUL 0DA8 60 PUSH1 0x01 0DAA 60 PUSH1 0x01 0DAC 60 PUSH1 0xf8 0DAE 1B SHL 0DAF 03 SUB 0DB0 90 SWAP1 0DB1 91 SWAP2 0DB2 16 AND 0DB3 17 OR 0DB4 60 PUSH1 0x0e 0DB6 55 SSTORE 0DB7 60 PUSH1 0xa0 0DB9 81 DUP2 0DBA 01 ADD 0DBB 51 MLOAD 0DBC 60 PUSH1 0x0f 0DBE 80 DUP1 0DBF 54 SLOAD 0DC0 60 PUSH1 0xc0 0DC2 90 SWAP1 0DC3 93 SWAP4 0DC4 01 ADD 0DC5 51 MLOAD 0DC6 15 ISZERO 0DC7 15 ISZERO 0DC8 61 PUSH2 0x0100 0DCB 02 MUL 0DCC 61 PUSH2 0xff00 0DCF 19 NOT 0DD0 92 SWAP3 0DD1 15 ISZERO 0DD2 15 ISZERO 0DD3 92 SWAP3 0DD4 90 SWAP1 0DD5 92 SWAP3 0DD6 16 AND 0DD7 61 PUSH2 0xffff 0DDA 19 NOT 0DDB 90 SWAP1 0DDC 93 SWAP4 0DDD 16 AND 0DDE 92 SWAP3 0DDF 90 SWAP1 0DE0 92 SWAP3 0DE1 17 OR 0DE2 17 OR 0DE3 90 SWAP1 0DE4 55 SSTORE 0DE5 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @0D6E memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] = 0x01 // @0D7F memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = (0x01 << 0xf8) - 0x01 & storage[0x0e] // @0D85 storage[0x0b] = memory[stack[-1]:stack[-1] + 0x20] // @0D8D storage[0x0c] = memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @0D95 storage[0x0d] = memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @0DB6 storage[0x0e] = (memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] & (0x01 << 0xf8) - 0x01) | (0x01 << 0xf8) * !!memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] // @0DE4 storage[0x0f] = (storage[0x0f] & ~0xffff) | (!!memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] & ~0xff00) | 0x0100 * !!memory[stack[-1] + 0xc0:stack[-1] + 0xc0 + 0x20] // } // Block ends with unconditional jump to stack[-2] label_0DE6: // Incoming jump from 0x043F // Inputs[2] // { // @0DE9 storage[0x06] // @0DF3 msg.sender // } 0DE6 5B JUMPDEST 0DE7 60 PUSH1 0x06 0DE9 54 SLOAD 0DEA 60 PUSH1 0x01 0DEC 60 PUSH1 0x01 0DEE 60 PUSH1 0xa0 0DF0 1B SHL 0DF1 03 SUB 0DF2 16 AND 0DF3 33 CALLER 0DF4 14 EQ 0DF5 61 PUSH2 0x0e10 0DF8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e10, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0DF9: // Incoming jump from 0x0DF8, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0DFB memory[0x40:0x60] } 0DF9 60 PUSH1 0x40 0DFB 51 MLOAD 0DFC 62 PUSH3 0x461bcd 0E00 60 PUSH1 0xe5 0E02 1B SHL 0E03 81 DUP2 0E04 52 MSTORE 0E05 60 PUSH1 0x04 0E07 01 ADD 0E08 61 PUSH2 0x0807 0E0B 90 SWAP1 0E0C 61 PUSH2 0x370a 0E0F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E0B stack[0] = 0x0807 // @0E0B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0E10: // Incoming jump from 0x0DF8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @0E11 stack[-1] // @0E12 memory[stack[-1]:stack[-1] + 0x20] // } 0E10 5B JUMPDEST 0E11 80 DUP1 0E12 51 MLOAD 0E13 61 PUSH2 0x081a 0E16 90 SWAP1 0E17 60 PUSH1 0x09 0E19 90 SWAP1 0E1A 60 PUSH1 0x20 0E1C 84 DUP5 0E1D 01 ADD 0E1E 90 SWAP1 0E1F 61 PUSH2 0x314d 0E22 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E16 stack[0] = 0x081a // @0E19 stack[1] = 0x09 // @0E1E stack[2] = stack[-1] + 0x20 // @0E1E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x314d label_0E23: // Incoming call from 0x1E6A, returns to 0x1E6B // Incoming jump from 0x047F // Inputs[2] // { // @0E29 stack[-1] // @0E2A stack[-2] // } 0E23 5B JUMPDEST 0E24 60 PUSH1 0x00 0E26 61 PUSH2 0x0e2f 0E29 82 DUP3 0E2A 84 DUP5 0E2B 61 PUSH2 0x37e1 0E2E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E24 stack[0] = 0x00 // @0E26 stack[1] = 0x0e2f // @0E29 stack[2] = stack[-1] // @0E2A stack[3] = stack[-2] // } // Block ends with call to 0x37e1, returns to 0x0E2F label_0E2F: // Incoming jump from 0x22E2, if !(stack[-1] == stack[-2]) // Incoming return from call to 0x3219 at 0x333F // Incoming jump from 0x213F // Incoming return from call to 0x2999 at 0x2301 // Incoming return from call to 0x2276 at 0x1413 // Incoming return from call to 0x31E6 at 0x3218 // Incoming return from call to 0x295A at 0x22EC // Incoming return from call to 0x3381 at 0x33B0 // Incoming return from call to 0x37E1 at 0x0E2E // Incoming return from call to 0x3219 at 0x3A77 // Incoming return from call to 0x230D at 0x168C // Incoming return from call to 0x329F at 0x32DD // Inputs[3] // { // @0E30 stack[-5] // @0E30 stack[-1] // @0E31 stack[-4] // } 0E2F 5B JUMPDEST 0E30 93 SWAP4 0E31 92 SWAP3 0E32 50 POP 0E33 50 POP 0E34 50 POP 0E35 56 *JUMP // Stack delta = -4 // Outputs[1] { @0E30 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0E36: // Incoming call from 0x0494, returns to 0x02A0 // Inputs[2] // { // @0E39 storage[0x06] // @0E43 msg.sender // } 0E36 5B JUMPDEST 0E37 60 PUSH1 0x06 0E39 54 SLOAD 0E3A 60 PUSH1 0x01 0E3C 60 PUSH1 0x01 0E3E 60 PUSH1 0xa0 0E40 1B SHL 0E41 03 SUB 0E42 16 AND 0E43 33 CALLER 0E44 14 EQ 0E45 61 PUSH2 0x0e60 0E48 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e60, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0E49: // Incoming jump from 0x0E48, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0E4B memory[0x40:0x60] } 0E49 60 PUSH1 0x40 0E4B 51 MLOAD 0E4C 62 PUSH3 0x461bcd 0E50 60 PUSH1 0xe5 0E52 1B SHL 0E53 81 DUP2 0E54 52 MSTORE 0E55 60 PUSH1 0x04 0E57 01 ADD 0E58 61 PUSH2 0x0807 0E5B 90 SWAP1 0E5C 61 PUSH2 0x370a 0E5F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E54 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E5B stack[0] = 0x0807 // @0E5B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0E60: // Incoming jump from 0x0E48, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] 0E60 5B JUMPDEST 0E61 61 PUSH2 0x0e68 0E64 61 PUSH2 0x190b 0E67 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E61 stack[0] = 0x0e68 } // Block ends with call to 0x190b, returns to 0x0E68 label_0E68: // Incoming return from call to 0x19FA at 0x0FE8 // Incoming return from call to 0x19A8 at 0x0FB6 // Incoming return from call to 0x190B at 0x0E67 // Inputs[1] { @0E69 stack[-1] } 0E68 5B JUMPDEST 0E69 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0E6A: // Incoming jump from 0x04B4 // Inputs[4] // { // @0E6E stack[-3] // @0E6F stack[-2] // @0E70 stack[-1] // @0E73 memory[0x40:0x60] // } 0E6A 5B JUMPDEST 0E6B 61 PUSH2 0x0a56 0E6E 83 DUP4 0E6F 83 DUP4 0E70 83 DUP4 0E71 60 PUSH1 0x40 0E73 51 MLOAD 0E74 80 DUP1 0E75 60 PUSH1 0x20 0E77 01 ADD 0E78 60 PUSH1 0x40 0E7A 52 MSTORE 0E7B 80 DUP1 0E7C 60 PUSH1 0x00 0E7E 81 DUP2 0E7F 52 MSTORE 0E80 50 POP 0E81 61 PUSH2 0x10c4 0E84 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0E6B stack[0] = 0x0a56 // @0E6E stack[1] = stack[-3] // @0E6F stack[2] = stack[-2] // @0E70 stack[3] = stack[-1] // @0E73 stack[4] = memory[0x40:0x60] // @0E7A memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0E7F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x10c4 label_0E85: // Incoming jump from 0x053D // Incoming call from 0x1710, returns to 0x1711 // Incoming call from 0x163E, returns to 0x163F // Incoming call from 0x1776, returns to 0x1777 // Incoming call from 0x094F, returns to 0x0950 // Inputs[3] // { // @0E88 stack[-1] // @0E93 memory[0x00:0x40] // @0E94 storage[keccak256(memory[0x00:0x40])] // } 0E85 5B JUMPDEST 0E86 60 PUSH1 0x00 0E88 81 DUP2 0E89 81 DUP2 0E8A 52 MSTORE 0E8B 60 PUSH1 0x02 0E8D 60 PUSH1 0x20 0E8F 52 MSTORE 0E90 60 PUSH1 0x40 0E92 81 DUP2 0E93 20 SHA3 0E94 54 SLOAD 0E95 60 PUSH1 0x01 0E97 60 PUSH1 0x01 0E99 60 PUSH1 0xa0 0E9B 1B SHL 0E9C 03 SUB 0E9D 16 AND 0E9E 80 DUP1 0E9F 61 PUSH2 0x07d7 0EA2 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0E86 stack[0] = 0x00 // @0E8A memory[0x00:0x20] = stack[-1] // @0E8F memory[0x20:0x40] = 0x02 // @0E9D stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x07d7, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0EA3: // Incoming jump from 0x0EA2, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0EA5 memory[0x40:0x60] } 0EA3 60 PUSH1 0x40 0EA5 51 MLOAD 0EA6 62 PUSH3 0x461bcd 0EAA 60 PUSH1 0xe5 0EAC 1B SHL 0EAD 81 DUP2 0EAE 52 MSTORE 0EAF 60 PUSH1 0x20 0EB1 60 PUSH1 0x04 0EB3 82 DUP3 0EB4 01 ADD 0EB5 52 MSTORE 0EB6 60 PUSH1 0x29 0EB8 60 PUSH1 0x24 0EBA 82 DUP3 0EBB 01 ADD 0EBC 52 MSTORE 0EBD 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 0EDE 60 PUSH1 0x44 0EE0 82 DUP3 0EE1 01 ADD 0EE2 52 MSTORE 0EE3 68 PUSH9 0x32b73a103a37b5b2b7 0EED 60 PUSH1 0xb9 0EEF 1B SHL 0EF0 60 PUSH1 0x64 0EF2 82 DUP3 0EF3 01 ADD 0EF4 52 MSTORE 0EF5 60 PUSH1 0x84 0EF7 01 ADD 0EF8 61 PUSH2 0x0807 0EFB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0EAE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EB5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EBC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0EE2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @0EF4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x32b73a103a37b5b2b7 << 0xb9 // @0EF7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_0EFC: // Incoming jump from 0x055D // Incoming call from 0x2AD9, returns to 0x2ADA // Inputs[1] { @0F07 stack[-1] } 0EFC 5B JUMPDEST 0EFD 60 PUSH1 0x00 0EFF 60 PUSH1 0x01 0F01 60 PUSH1 0x01 0F03 60 PUSH1 0xa0 0F05 1B SHL 0F06 03 SUB 0F07 82 DUP3 0F08 16 AND 0F09 61 PUSH2 0x0f67 0F0C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EFD stack[0] = 0x00 } // Block ends with conditional jump to 0x0f67, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0F0D: // Incoming jump from 0x0F0C, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0F0F memory[0x40:0x60] } 0F0D 60 PUSH1 0x40 0F0F 51 MLOAD 0F10 62 PUSH3 0x461bcd 0F14 60 PUSH1 0xe5 0F16 1B SHL 0F17 81 DUP2 0F18 52 MSTORE 0F19 60 PUSH1 0x20 0F1B 60 PUSH1 0x04 0F1D 82 DUP3 0F1E 01 ADD 0F1F 52 MSTORE 0F20 60 PUSH1 0x2a 0F22 60 PUSH1 0x24 0F24 82 DUP3 0F25 01 ADD 0F26 52 MSTORE 0F27 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 0F48 60 PUSH1 0x44 0F4A 82 DUP3 0F4B 01 ADD 0F4C 52 MSTORE 0F4D 69 PUSH10 0x726f2061646472657373 0F58 60 PUSH1 0xb0 0F5A 1B SHL 0F5B 60 PUSH1 0x64 0F5D 82 DUP3 0F5E 01 ADD 0F5F 52 MSTORE 0F60 60 PUSH1 0x84 0F62 01 ADD 0F63 61 PUSH2 0x0807 0F66 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0F18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F1F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F26 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @0F4C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @0F5F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x726f2061646472657373 << 0xb0 // @0F62 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_0F67: // Incoming jump from 0x0F0C, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0F71 stack[-2] // @0F7F memory[0x00:0x40] // @0F80 storage[keccak256(memory[0x00:0x40])] // @0F81 stack[-3] // } 0F67 5B JUMPDEST 0F68 50 POP 0F69 60 PUSH1 0x01 0F6B 60 PUSH1 0x01 0F6D 60 PUSH1 0xa0 0F6F 1B SHL 0F70 03 SUB 0F71 16 AND 0F72 60 PUSH1 0x00 0F74 90 SWAP1 0F75 81 DUP2 0F76 52 MSTORE 0F77 60 PUSH1 0x03 0F79 60 PUSH1 0x20 0F7B 52 MSTORE 0F7C 60 PUSH1 0x40 0F7E 90 SWAP1 0F7F 20 SHA3 0F80 54 SLOAD 0F81 90 SWAP1 0F82 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0F76 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0F7B memory[0x20:0x40] = 0x03 // @0F81 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0F83: // Incoming call from 0x0572, returns to 0x02A0 // Inputs[2] // { // @0F86 storage[0x06] // @0F90 msg.sender // } 0F83 5B JUMPDEST 0F84 60 PUSH1 0x06 0F86 54 SLOAD 0F87 60 PUSH1 0x01 0F89 60 PUSH1 0x01 0F8B 60 PUSH1 0xa0 0F8D 1B SHL 0F8E 03 SUB 0F8F 16 AND 0F90 33 CALLER 0F91 14 EQ 0F92 61 PUSH2 0x0fad 0F95 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fad, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0F96: // Incoming jump from 0x0F95, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0F98 memory[0x40:0x60] } 0F96 60 PUSH1 0x40 0F98 51 MLOAD 0F99 62 PUSH3 0x461bcd 0F9D 60 PUSH1 0xe5 0F9F 1B SHL 0FA0 81 DUP2 0FA1 52 MSTORE 0FA2 60 PUSH1 0x04 0FA4 01 ADD 0FA5 61 PUSH2 0x0807 0FA8 90 SWAP1 0FA9 61 PUSH2 0x370a 0FAC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FA8 stack[0] = 0x0807 // @0FA8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0FAD: // Incoming jump from 0x0F95, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] 0FAD 5B JUMPDEST 0FAE 61 PUSH2 0x0e68 0FB1 60 PUSH1 0x00 0FB3 61 PUSH2 0x19a8 0FB6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FAE stack[0] = 0x0e68 // @0FB1 stack[1] = 0x00 // } // Block ends with call to 0x19a8, returns to 0x0E68 label_0FB7: // Incoming call from 0x0587, returns to 0x02A0 // Inputs[2] // { // @0FBA storage[0x06] // @0FC4 msg.sender // } 0FB7 5B JUMPDEST 0FB8 60 PUSH1 0x06 0FBA 54 SLOAD 0FBB 60 PUSH1 0x01 0FBD 60 PUSH1 0x01 0FBF 60 PUSH1 0xa0 0FC1 1B SHL 0FC2 03 SUB 0FC3 16 AND 0FC4 33 CALLER 0FC5 14 EQ 0FC6 61 PUSH2 0x0fe1 0FC9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fe1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0FCA: // Incoming jump from 0x0FC9, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0FCC memory[0x40:0x60] } 0FCA 60 PUSH1 0x40 0FCC 51 MLOAD 0FCD 62 PUSH3 0x461bcd 0FD1 60 PUSH1 0xe5 0FD3 1B SHL 0FD4 81 DUP2 0FD5 52 MSTORE 0FD6 60 PUSH1 0x04 0FD8 01 ADD 0FD9 61 PUSH2 0x0807 0FDC 90 SWAP1 0FDD 61 PUSH2 0x370a 0FE0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FD5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FDC stack[0] = 0x0807 // @0FDC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_0FE1: // Incoming jump from 0x0FC9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] 0FE1 5B JUMPDEST 0FE2 61 PUSH2 0x0e68 0FE5 61 PUSH2 0x19fa 0FE8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FE2 stack[0] = 0x0e68 } // Block ends with call to 0x19fa, returns to 0x0E68 label_0FE9: // Incoming call from 0x05BA, returns to 0x0353 // Inputs[1] { @0FF1 storage[0x11] } 0FE9 5B JUMPDEST 0FEA 60 PUSH1 0x00 0FEC 61 PUSH2 0x0ff4 0FEF 60 PUSH1 0x11 0FF1 54 SLOAD 0FF2 90 SWAP1 0FF3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FEA stack[0] = 0x00 // @0FF2 stack[1] = storage[0x11] // } // Block ends with unconditional jump to 0x0ff4 label_0FF4: // Incoming jump from 0x0FF3 // Incoming return from call to 0x294B at 0x2177 // Inputs[3] // { // @0FF5 stack[-1] // @0FF5 stack[-2] // @0FF7 stack[-3] // } 0FF4 5B JUMPDEST 0FF5 90 SWAP1 0FF6 50 POP 0FF7 90 SWAP1 0FF8 56 *JUMP // Stack delta = -2 // Outputs[1] { @0FF7 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0FF9: // Incoming jump from 0x05DA // Inputs[3] // { // @1006 stack[-3] // @1007 stack[-2] // @1008 stack[-1] // } 0FF9 5B JUMPDEST 0FFA 60 PUSH1 0x00 0FFC 60 PUSH1 0x18 0FFE 60 PUSH1 0x00 1000 61 PUSH2 0x1012 1003 61 PUSH2 0x100d 1006 87 DUP8 1007 87 DUP8 1008 87 DUP8 1009 61 PUSH2 0x1a5f 100C 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @0FFA stack[0] = 0x00 // @0FFC stack[1] = 0x18 // @0FFE stack[2] = 0x00 // @1000 stack[3] = 0x1012 // @1003 stack[4] = 0x100d // @1006 stack[5] = stack[-3] // @1007 stack[6] = stack[-2] // @1008 stack[7] = stack[-1] // } // Block ends with call to 0x1a5f, returns to 0x100D label_100D: // Incoming return from call to 0x1A5F at 0x100C 100D 5B JUMPDEST 100E 61 PUSH2 0x1aa5 1011 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1aa5 1012 5B JUMPDEST 1013 81 DUP2 1014 52 MSTORE 1015 60 PUSH1 0x20 1017 81 DUP2 1018 01 ADD 1019 91 SWAP2 101A 90 SWAP1 101B 91 SWAP2 101C 52 MSTORE 101D 60 PUSH1 0x40 101F 01 ADD 1020 60 PUSH1 0x00 1022 20 SHA3 1023 54 SLOAD 1024 60 PUSH1 0xff 1026 16 AND 1027 94 SWAP5 1028 93 SWAP4 1029 50 POP 102A 50 POP 102B 50 POP 102C 50 POP 102D 56 *JUMP label_102E: // Incoming call from 0x05EF, returns to 0x02B7 // Inputs[1] { @1034 storage[0x01] } 102E 5B JUMPDEST 102F 60 PUSH1 0x60 1031 60 PUSH1 0x01 1033 80 DUP1 1034 54 SLOAD 1035 61 PUSH2 0x082d 1038 90 SWAP1 1039 61 PUSH2 0x373f 103C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @102F stack[0] = 0x60 // @1031 stack[1] = 0x01 // @1038 stack[2] = 0x082d // @1038 stack[3] = storage[0x01] // } // Block ends with call to 0x373f, returns to 0x082D label_103D: // Incoming jump from 0x0602 // Inputs[3] // { // @1044 stack[-5] // @1045 stack[-4] // @1046 stack[-3] // } 103D 5B JUMPDEST 103E 61 PUSH2 0x1057 1041 61 PUSH2 0x104b 1044 86 DUP7 1045 86 DUP7 1046 86 DUP7 1047 61 PUSH2 0x1a5f 104A 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @103E stack[0] = 0x1057 // @1041 stack[1] = 0x104b // @1044 stack[2] = stack[-5] // @1045 stack[3] = stack[-4] // @1046 stack[4] = stack[-3] // } // Block ends with call to 0x1a5f, returns to 0x104B label_104B: // Incoming return from call to 0x1A5F at 0x104A // Inputs[3] // { // @104E stack[-1] // @104F stack[-4] // @1050 stack[-3] // } 104B 5B JUMPDEST 104C 60 PUSH1 0x14 104E 90 SWAP1 104F 84 DUP5 1050 84 DUP5 1051 60 PUSH1 0x18 1053 61 PUSH2 0x1ab0 1056 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @104E stack[0] = stack[-1] // @104E stack[-1] = 0x14 // @104F stack[1] = stack[-4] // @1050 stack[2] = stack[-3] // @1051 stack[3] = 0x18 // } // Block ends with unconditional jump to 0x1ab0 1057 5B JUMPDEST 1058 61 PUSH2 0x1063 105B 85 DUP6 105C 60 PUSH1 0x01 105E 86 DUP7 105F 61 PUSH2 0x1b59 1062 56 *JUMP label_1063: // Incoming return from call to 0x2151 at 0x2BC9 // Inputs[1] { @1069 stack[-6] } 1063 5B JUMPDEST 1064 50 POP 1065 50 POP 1066 50 POP 1067 50 POP 1068 50 POP 1069 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_106A: // Incoming jump from 0x0615 // Inputs[1] { @106D storage[0x19] } 106A 5B JUMPDEST 106B 60 PUSH1 0x19 106D 54 SLOAD 106E 60 PUSH1 0xff 1070 16 AND 1071 61 PUSH2 0x10ad 1074 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10ad, if 0xff & storage[0x19] label_1075: // Incoming jump from 0x1074, if not 0xff & storage[0x19] // Inputs[1] { @1077 memory[0x40:0x60] } 1075 60 PUSH1 0x40 1077 51 MLOAD 1078 62 PUSH3 0x461bcd 107C 60 PUSH1 0xe5 107E 1B SHL 107F 81 DUP2 1080 52 MSTORE 1081 60 PUSH1 0x20 1083 60 PUSH1 0x04 1085 82 DUP3 1086 01 ADD 1087 52 MSTORE 1088 60 PUSH1 0x0e 108A 60 PUSH1 0x24 108C 82 DUP3 108D 01 ADD 108E 52 MSTORE 108F 6D PUSH14 0x135a5b9d1a5b99c818db1bdcd959 109E 60 PUSH1 0x92 10A0 1B SHL 10A1 60 PUSH1 0x44 10A3 82 DUP3 10A4 01 ADD 10A5 52 MSTORE 10A6 60 PUSH1 0x64 10A8 01 ADD 10A9 61 PUSH2 0x0807 10AC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1080 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1087 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @108E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @10A5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x135a5b9d1a5b99c818db1bdcd959 << 0x92 // @10A8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_10AD: // Incoming jump from 0x1074, if 0xff & storage[0x19] // Inputs[3] // { // @10B1 stack[-2] // @10B2 stack[-1] // @10B5 storage[0x1a] // } 10AD 5B JUMPDEST 10AE 61 PUSH2 0x081a 10B1 82 DUP3 10B2 82 DUP3 10B3 60 PUSH1 0x1a 10B5 54 SLOAD 10B6 61 PUSH2 0x1b59 10B9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10AE stack[0] = 0x081a // @10B1 stack[1] = stack[-2] // @10B2 stack[2] = stack[-1] // @10B5 stack[3] = storage[0x1a] // } // Block ends with unconditional jump to 0x1b59 label_10BA: // Incoming jump from 0x0635 // Inputs[2] // { // @10BE stack[-2] // @10BF stack[-1] // } 10BA 5B JUMPDEST 10BB 61 PUSH2 0x081a 10BE 82 DUP3 10BF 82 DUP3 10C0 61 PUSH2 0x2037 10C3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10BB stack[0] = 0x081a // @10BE stack[1] = stack[-2] // @10BF stack[2] = stack[-1] // } // Block ends with call to 0x2037, returns to 0x081A label_10C4: // Incoming jump from 0x0E84 // Incoming jump from 0x066B // Inputs[2] // { // @10C8 msg.sender // @10C9 stack[-2] // } 10C4 5B JUMPDEST 10C5 61 PUSH2 0x10ce 10C8 33 CALLER 10C9 83 DUP4 10CA 61 PUSH2 0x168d 10CD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10C5 stack[0] = 0x10ce // @10C8 stack[1] = msg.sender // @10C9 stack[2] = stack[-2] // } // Block ends with call to 0x168d, returns to 0x10CE label_10CE: // Incoming return from call to 0x168D at 0x10CD // Inputs[1] { @10D2 stack[-1] } 10CE 5B JUMPDEST 10CF 61 PUSH2 0x10ea 10D2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10ea, if stack[-1] label_10D3: // Incoming jump from 0x10D2, if not stack[-1] // Inputs[1] { @10D5 memory[0x40:0x60] } 10D3 60 PUSH1 0x40 10D5 51 MLOAD 10D6 62 PUSH3 0x461bcd 10DA 60 PUSH1 0xe5 10DC 1B SHL 10DD 81 DUP2 10DE 52 MSTORE 10DF 60 PUSH1 0x04 10E1 01 ADD 10E2 61 PUSH2 0x0807 10E5 90 SWAP1 10E6 61 PUSH2 0x377a 10E9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10E5 stack[0] = 0x0807 // @10E5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x377a, returns to 0x0807 label_10EA: // Incoming jump from 0x10D2, if stack[-1] // Inputs[4] // { // @10EE stack[-4] // @10EF stack[-3] // @10F0 stack[-2] // @10F1 stack[-1] // } 10EA 5B JUMPDEST 10EB 61 PUSH2 0x10f6 10EE 84 DUP5 10EF 84 DUP5 10F0 84 DUP5 10F1 84 DUP5 10F2 61 PUSH2 0x20fe 10F5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @10EB stack[0] = 0x10f6 // @10EE stack[1] = stack[-4] // @10EF stack[2] = stack[-3] // @10F0 stack[3] = stack[-2] // @10F1 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x20fe label_10F6: // Incoming jump from 0x3296, if !(stack[-1] > stack[-4]) // Incoming jump from 0x2ADE, if stack[-1] // Inputs[1] { @10FB stack[-5] } 10F6 5B JUMPDEST 10F7 50 POP 10F8 50 POP 10F9 50 POP 10FA 50 POP 10FB 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_10FC: // Incoming jump from 0x0716 // Inputs[2] // { // @10FF storage[0x06] // @1109 msg.sender // } 10FC 5B JUMPDEST 10FD 60 PUSH1 0x06 10FF 54 SLOAD 1100 60 PUSH1 0x01 1102 60 PUSH1 0x01 1104 60 PUSH1 0xa0 1106 1B SHL 1107 03 SUB 1108 16 AND 1109 33 CALLER 110A 14 EQ 110B 61 PUSH2 0x1126 110E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1126, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_110F: // Incoming jump from 0x110E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @1111 memory[0x40:0x60] } 110F 60 PUSH1 0x40 1111 51 MLOAD 1112 62 PUSH3 0x461bcd 1116 60 PUSH1 0xe5 1118 1B SHL 1119 81 DUP2 111A 52 MSTORE 111B 60 PUSH1 0x04 111D 01 ADD 111E 61 PUSH2 0x0807 1121 90 SWAP1 1122 61 PUSH2 0x370a 1125 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @111A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1121 stack[0] = 0x0807 // @1121 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_1126: // Incoming jump from 0x110E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @1129 storage[0x06] } 1126 5B JUMPDEST 1127 60 PUSH1 0x06 1129 54 SLOAD 112A 60 PUSH1 0x01 112C 60 PUSH1 0xa0 112E 1B SHL 112F 90 SWAP1 1130 04 DIV 1131 60 PUSH1 0xff 1133 16 AND 1134 15 ISZERO 1135 61 PUSH2 0x1150 1138 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1150, if !(0xff & storage[0x06] / (0x01 << 0xa0)) label_1139: // Incoming jump from 0x1138, if not !(0xff & storage[0x06] / (0x01 << 0xa0)) // Inputs[1] { @113B memory[0x40:0x60] } 1139 60 PUSH1 0x40 113B 51 MLOAD 113C 62 PUSH3 0x461bcd 1140 60 PUSH1 0xe5 1142 1B SHL 1143 81 DUP2 1144 52 MSTORE 1145 60 PUSH1 0x04 1147 01 ADD 1148 61 PUSH2 0x0807 114B 90 SWAP1 114C 61 PUSH2 0x382a 114F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1144 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @114B stack[0] = 0x0807 // @114B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x382a, returns to 0x0807 label_1150: // Incoming jump from 0x1138, if !(0xff & storage[0x06] / (0x01 << 0xa0)) // Inputs[3] // { // @1153 storage[0x0e] // @1160 stack[-1] // @1166 storage[0x13] // } 1150 5B JUMPDEST 1151 60 PUSH1 0x0e 1153 54 SLOAD 1154 60 PUSH1 0x01 1156 60 PUSH1 0x01 1158 60 PUSH1 0xf8 115A 1B SHL 115B 03 SUB 115C 16 AND 115D 61 PUSH2 0x1178 1160 82 DUP3 1161 61 PUSH2 0x1169 1164 60 PUSH1 0x13 1166 54 SLOAD 1167 90 SWAP1 1168 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @115C stack[0] = (0x01 << 0xf8) - 0x01 & storage[0x0e] // @115D stack[1] = 0x1178 // @1160 stack[2] = stack[-1] // @1167 stack[3] = storage[0x13] // } // Block ends with call to 0x1169, returns to 0x1178 label_1169: // Incoming call from 0x11D9, returns to 0x11DA // Incoming call from 0x1168, returns to 0x1178 // Inputs[2] // { // @116D stack[-1] // @116E stack[-4] // } 1169 5B JUMPDEST 116A 61 PUSH2 0x1173 116D 90 SWAP1 116E 84 DUP5 116F 61 PUSH2 0x3854 1172 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @116D stack[0] = stack[-1] // @116D stack[-1] = 0x1173 // @116E stack[1] = stack[-4] // } // Block ends with call to 0x3854, returns to 0x1173 label_1173: // Incoming return from call to 0x3854 at 0x1CBD // Incoming return from call to 0x3854 at 0x1172 // Incoming return from call to 0x3854 at 0x1CBD 1173 5B JUMPDEST 1174 61 PUSH2 0x2131 1177 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2131 label_1178: // Incoming return from call to 0x1169 at 0x1168 // Inputs[2] // { // @1179 stack[-3] // @1179 stack[-1] // } 1178 5B JUMPDEST 1179 91 SWAP2 117A 50 POP 117B 60 PUSH1 0x00 117D 82 DUP3 117E 11 GT 117F 61 PUSH2 0x11ca 1182 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1179 stack[-3] = stack[-1] } // Block ends with conditional jump to 0x11ca, if stack[-1] > 0x00 label_1183: // Incoming jump from 0x1182, if not stack[-1] > 0x00 // Inputs[1] { @1185 memory[0x40:0x60] } 1183 60 PUSH1 0x40 1185 51 MLOAD 1186 62 PUSH3 0x461bcd 118A 60 PUSH1 0xe5 118C 1B SHL 118D 81 DUP2 118E 52 MSTORE 118F 60 PUSH1 0x20 1191 60 PUSH1 0x04 1193 82 DUP3 1194 01 ADD 1195 52 MSTORE 1196 60 PUSH1 0x1b 1198 60 PUSH1 0x24 119A 82 DUP3 119B 01 ADD 119C 52 MSTORE 119D 7F PUSH32 0x53656c6c65723a20467265652071756f74612065786365656465640000000000 11BE 60 PUSH1 0x44 11C0 82 DUP3 11C1 01 ADD 11C2 52 MSTORE 11C3 60 PUSH1 0x64 11C5 01 ADD 11C6 61 PUSH2 0x0807 11C9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @118E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1195 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @119C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1b // @11C2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x53656c6c65723a20467265652071756f74612065786365656465640000000000 // @11C5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_11CA: // Incoming jump from 0x1182, if stack[-1] > 0x00 // Inputs[3] // { // @11CD storage[0x0b] // @11D1 stack[-2] // @11D7 storage[0x11] // } 11CA 5B JUMPDEST 11CB 60 PUSH1 0x0b 11CD 54 SLOAD 11CE 61 PUSH2 0x11da 11D1 83 DUP4 11D2 61 PUSH2 0x1169 11D5 60 PUSH1 0x11 11D7 54 SLOAD 11D8 90 SWAP1 11D9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @11CD stack[0] = storage[0x0b] // @11CE stack[1] = 0x11da // @11D1 stack[2] = stack[-2] // @11D8 stack[3] = storage[0x11] // } // Block ends with call to 0x1169, returns to 0x11DA label_11DA: // Incoming return from call to 0x1169 at 0x11D9 // Inputs[2] // { // @11DB stack[-1] // @11DB stack[-4] // } 11DA 5B JUMPDEST 11DB 92 SWAP3 11DC 50 POP 11DD 60 PUSH1 0x00 11DF 83 DUP4 11E0 11 GT 11E1 61 PUSH2 0x121f 11E4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @11DB stack[-4] = stack[-1] } // Block ends with conditional jump to 0x121f, if stack[-1] > 0x00 label_11E5: // Incoming jump from 0x11E4, if not stack[-1] > 0x00 // Inputs[1] { @11E7 memory[0x40:0x60] } 11E5 60 PUSH1 0x40 11E7 51 MLOAD 11E8 62 PUSH3 0x461bcd 11EC 60 PUSH1 0xe5 11EE 1B SHL 11EF 81 DUP2 11F0 52 MSTORE 11F1 60 PUSH1 0x20 11F3 60 PUSH1 0x04 11F5 82 DUP3 11F6 01 ADD 11F7 52 MSTORE 11F8 60 PUSH1 0x10 11FA 60 PUSH1 0x24 11FC 82 DUP3 11FD 01 ADD 11FE 52 MSTORE 11FF 6F PUSH16 0x14d95b1b195c8e8814dbdb19081bdd5d 1210 60 PUSH1 0x82 1212 1B SHL 1213 60 PUSH1 0x44 1215 82 DUP3 1216 01 ADD 1217 52 MSTORE 1218 60 PUSH1 0x64 121A 01 ADD 121B 61 PUSH2 0x0807 121E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11F7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11FE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1217 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14d95b1b195c8e8814dbdb19081bdd5d << 0x82 // @121A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_121F: // Incoming jump from 0x11E4, if stack[-1] > 0x00 // Inputs[2] // { // @1223 stack[-4] // @1224 stack[-3] // } 121F 5B JUMPDEST 1220 61 PUSH2 0x122b 1223 84 DUP5 1224 84 DUP5 1225 60 PUSH1 0x01 1227 61 PUSH2 0x2147 122A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1220 stack[0] = 0x122b // @1223 stack[1] = stack[-4] // @1224 stack[2] = stack[-3] // @1225 stack[3] = 0x01 // } // Block ends with unconditional jump to 0x2147 122B 5B JUMPDEST 122C 61 PUSH2 0x1236 122F 60 PUSH1 0x11 1231 84 DUP5 1232 61 PUSH2 0x2151 1235 56 *JUMP 1236 5B JUMPDEST 1237 61 PUSH2 0x1241 123A 60 PUSH1 0x13 123C 84 DUP5 123D 61 PUSH2 0x2151 1240 56 *JUMP 1241 5B JUMPDEST 1242 80 DUP1 1243 61 PUSH2 0x124b 1246 60 PUSH1 0x11 1248 54 SLOAD 1249 90 SWAP1 124A 56 *JUMP 124B 5B JUMPDEST 124C 11 GT 124D 15 ISZERO 124E 61 PUSH2 0x1259 1251 57 *JUMPI 1252 61 PUSH2 0x1259 1255 61 PUSH2 0x386b 1258 56 *JUMP 1259 5B JUMPDEST 125A 81 DUP2 125B 61 PUSH2 0x1263 125E 60 PUSH1 0x13 1260 54 SLOAD 1261 90 SWAP1 1262 56 *JUMP 1263 5B JUMPDEST 1264 11 GT 1265 15 ISZERO 1266 61 PUSH2 0x10f6 1269 57 *JUMPI 126A 61 PUSH2 0x10f6 126D 61 PUSH2 0x386b 1270 56 *JUMP label_1271: // Incoming jump from 0x0736 // Inputs[2] // { // @1274 storage[0x06] // @127E msg.sender // } 1271 5B JUMPDEST 1272 60 PUSH1 0x06 1274 54 SLOAD 1275 60 PUSH1 0x01 1277 60 PUSH1 0x01 1279 60 PUSH1 0xa0 127B 1B SHL 127C 03 SUB 127D 16 AND 127E 33 CALLER 127F 14 EQ 1280 61 PUSH2 0x129b 1283 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x129b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_1284: // Incoming jump from 0x1283, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @1286 memory[0x40:0x60] } 1284 60 PUSH1 0x40 1286 51 MLOAD 1287 62 PUSH3 0x461bcd 128B 60 PUSH1 0xe5 128D 1B SHL 128E 81 DUP2 128F 52 MSTORE 1290 60 PUSH1 0x04 1292 01 ADD 1293 61 PUSH2 0x0807 1296 90 SWAP1 1297 61 PUSH2 0x370a 129A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @128F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1296 stack[0] = 0x0807 // @1296 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_129B: // Incoming jump from 0x1283, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @129E stack[-1] // @129F stack[-2] // } 129B 5B JUMPDEST 129C 60 PUSH1 0x1a 129E 55 SSTORE 129F 56 *JUMP // Stack delta = -2 // Outputs[1] { @129E storage[0x1a] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_12A0: // Incoming jump from 0x0756 // Inputs[3] // { // @12A3 stack[-1] // @12AE memory[0x00:0x40] // @12AF storage[keccak256(memory[0x00:0x40])] // } 12A0 5B JUMPDEST 12A1 60 PUSH1 0x00 12A3 81 DUP2 12A4 81 DUP2 12A5 52 MSTORE 12A6 60 PUSH1 0x02 12A8 60 PUSH1 0x20 12AA 52 MSTORE 12AB 60 PUSH1 0x40 12AD 90 SWAP1 12AE 20 SHA3 12AF 54 SLOAD 12B0 60 PUSH1 0x60 12B2 90 SWAP1 12B3 60 PUSH1 0x01 12B5 60 PUSH1 0x01 12B7 60 PUSH1 0xa0 12B9 1B SHL 12BA 03 SUB 12BB 16 AND 12BC 61 PUSH2 0x131f 12BF 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @12A5 memory[0x00:0x20] = stack[-1] // @12AA memory[0x20:0x40] = 0x02 // @12B2 stack[0] = 0x60 // } // Block ends with conditional jump to 0x131f, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_12C0: // Incoming jump from 0x12BF, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @12C2 memory[0x40:0x60] } 12C0 60 PUSH1 0x40 12C2 51 MLOAD 12C3 62 PUSH3 0x461bcd 12C7 60 PUSH1 0xe5 12C9 1B SHL 12CA 81 DUP2 12CB 52 MSTORE 12CC 60 PUSH1 0x20 12CE 60 PUSH1 0x04 12D0 82 DUP3 12D1 01 ADD 12D2 52 MSTORE 12D3 60 PUSH1 0x2f 12D5 60 PUSH1 0x24 12D7 82 DUP3 12D8 01 ADD 12D9 52 MSTORE 12DA 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 12FB 60 PUSH1 0x44 12FD 82 DUP3 12FE 01 ADD 12FF 52 MSTORE 1300 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 1310 60 PUSH1 0x89 1312 1B SHL 1313 60 PUSH1 0x64 1315 82 DUP3 1316 01 ADD 1317 52 MSTORE 1318 60 PUSH1 0x84 131A 01 ADD 131B 61 PUSH2 0x0807 131E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @12CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12D2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12D9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @12FF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @1317 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @131A stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_131F: // Incoming jump from 0x12BF, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] 131F 5B JUMPDEST 1320 60 PUSH1 0x00 1322 61 PUSH2 0x1329 1325 61 PUSH2 0x216e 1328 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1320 stack[0] = 0x00 // @1322 stack[1] = 0x1329 // } // Block ends with unconditional jump to 0x216e 1329 5B JUMPDEST 132A 90 SWAP1 132B 50 POP 132C 60 PUSH1 0x00 132E 81 DUP2 132F 51 MLOAD 1330 11 GT 1331 61 PUSH2 0x1349 1334 57 *JUMPI 1335 60 PUSH1 0x40 1337 51 MLOAD 1338 80 DUP1 1339 60 PUSH1 0x20 133B 01 ADD 133C 60 PUSH1 0x40 133E 52 MSTORE 133F 80 DUP1 1340 60 PUSH1 0x00 1342 81 DUP2 1343 52 MSTORE 1344 50 POP 1345 61 PUSH2 0x0e2f 1348 56 *JUMP 1349 5B JUMPDEST 134A 80 DUP1 134B 61 PUSH2 0x1353 134E 84 DUP5 134F 61 PUSH2 0x2178 1352 56 *JUMP 1353 5B JUMPDEST 1354 60 PUSH1 0x40 1356 51 MLOAD 1357 60 PUSH1 0x20 1359 01 ADD 135A 61 PUSH2 0x1364 135D 92 SWAP3 135E 91 SWAP2 135F 90 SWAP1 1360 61 PUSH2 0x3881 1363 56 *JUMP 1364 5B JUMPDEST 1365 60 PUSH1 0x40 1367 51 MLOAD 1368 60 PUSH1 0x20 136A 81 DUP2 136B 83 DUP4 136C 03 SUB 136D 03 SUB 136E 81 DUP2 136F 52 MSTORE 1370 90 SWAP1 1371 60 PUSH1 0x40 1373 52 MSTORE 1374 93 SWAP4 1375 92 SWAP3 1376 50 POP 1377 50 POP 1378 50 POP 1379 56 *JUMP label_137A: // Incoming call from 0x076B, returns to 0x02B7 // Inputs[1] { @137E storage[0x09] } 137A 5B JUMPDEST 137B 60 PUSH1 0x09 137D 80 DUP1 137E 54 SLOAD 137F 61 PUSH2 0x1387 1382 90 SWAP1 1383 61 PUSH2 0x373f 1386 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @137B stack[0] = 0x09 // @1382 stack[1] = 0x1387 // @1382 stack[2] = storage[0x09] // } // Block ends with call to 0x373f, returns to 0x1387 label_1387: // Incoming return from call to 0x373F at 0x1386 // Inputs[4] // { // @1388 stack[-1] // @1397 memory[0x40:0x60] // @139F stack[-2] // @13AA storage[stack[-2]] // } 1387 5B JUMPDEST 1388 80 DUP1 1389 60 PUSH1 0x1f 138B 01 ADD 138C 60 PUSH1 0x20 138E 80 DUP1 138F 91 SWAP2 1390 04 DIV 1391 02 MUL 1392 60 PUSH1 0x20 1394 01 ADD 1395 60 PUSH1 0x40 1397 51 MLOAD 1398 90 SWAP1 1399 81 DUP2 139A 01 ADD 139B 60 PUSH1 0x40 139D 52 MSTORE 139E 80 DUP1 139F 92 SWAP3 13A0 91 SWAP2 13A1 90 SWAP1 13A2 81 DUP2 13A3 81 DUP2 13A4 52 MSTORE 13A5 60 PUSH1 0x20 13A7 01 ADD 13A8 82 DUP3 13A9 80 DUP1 13AA 54 SLOAD 13AB 61 PUSH2 0x13b3 13AE 90 SWAP1 13AF 61 PUSH2 0x373f 13B2 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @139D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @139F stack[-2] = memory[0x40:0x60] // @13A0 stack[-1] = stack[-2] // @13A1 stack[0] = stack[-1] // @13A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @13A7 stack[1] = 0x20 + memory[0x40:0x60] // @13A8 stack[2] = stack[-2] // @13AE stack[4] = storage[stack[-2]] // @13AE stack[3] = 0x13b3 // } // Block ends with call to 0x373f, returns to 0x13B3 label_13B3: // Incoming return from call to 0x373F at 0x13B2 // Inputs[1] { @13B4 stack[-1] } 13B3 5B JUMPDEST 13B4 80 DUP1 13B5 15 ISZERO 13B6 61 PUSH2 0x1400 13B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1400, if !stack[-1] label_13BA: // Incoming jump from 0x13B9, if not !stack[-1] // Inputs[1] { @13BA stack[-1] } 13BA 80 DUP1 13BB 60 PUSH1 0x1f 13BD 10 LT 13BE 61 PUSH2 0x13d5 13C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13d5, if 0x1f < stack[-1] label_13C2: // Incoming jump from 0x13C1, if not 0x1f < stack[-1] // Inputs[4] // { // @13C6 stack[-2] // @13C7 storage[stack[-2]] // @13CA stack[-3] // @13CC stack[-1] // } 13C2 61 PUSH2 0x0100 13C5 80 DUP1 13C6 83 DUP4 13C7 54 SLOAD 13C8 04 DIV 13C9 02 MUL 13CA 83 DUP4 13CB 52 MSTORE 13CC 91 SWAP2 13CD 60 PUSH1 0x20 13CF 01 ADD 13D0 91 SWAP2 13D1 61 PUSH2 0x1400 13D4 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @13CB memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @13D0 stack[-1] = stack[-1] // @13D0 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1400 label_13D5: // Incoming jump from 0x13C1, if 0x1f < stack[-1] // Inputs[5] // { // @13D6 stack[-3] // @13D7 stack[-1] // @13D9 stack[-2] // @13E1 memory[0x00:0x20] // @13E5 storage[keccak256(memory[0x00:0x20])] // } 13D5 5B JUMPDEST 13D6 82 DUP3 13D7 01 ADD 13D8 91 SWAP2 13D9 90 SWAP1 13DA 60 PUSH1 0x00 13DC 52 MSTORE 13DD 60 PUSH1 0x20 13DF 60 PUSH1 0x00 13E1 20 SHA3 13E2 90 SWAP1 13E3 5B JUMPDEST 13E4 81 DUP2 13E5 54 SLOAD 13E6 81 DUP2 13E7 52 MSTORE 13E8 90 SWAP1 13E9 60 PUSH1 0x01 13EB 01 ADD 13EC 90 SWAP1 13ED 60 PUSH1 0x20 13EF 01 ADD 13F0 80 DUP1 13F1 83 DUP4 13F2 11 GT 13F3 61 PUSH2 0x13e3 13F6 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @13D8 stack[-3] = stack[-3] + stack[-1] // @13DC memory[0x00:0x20] = stack[-2] // @13E7 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @13EC stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @13EF stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x13e3, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_13F7: // Incoming jump from 0x13F6, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x13F6, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @13F7 stack[-3] // @13F8 stack[-1] // } 13F7 82 DUP3 13F8 90 SWAP1 13F9 03 SUB 13FA 60 PUSH1 0x1f 13FC 16 AND 13FD 82 DUP3 13FE 01 ADD 13FF 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @13FF stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @13FF stack[-1] = stack[-3] // } // Block continues label_1400: // Incoming jump from 0x13FF // Incoming jump from 0x13B9, if !stack[-1] // Incoming jump from 0x13D4 // Inputs[1] { @1406 stack[-7] } 1400 5B JUMPDEST 1401 50 POP 1402 50 POP 1403 50 POP 1404 50 POP 1405 50 POP 1406 81 DUP2 1407 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_1408: // Incoming jump from 0x175B // Incoming jump from 0x09D9 // Inputs[2] // { // @140E stack[-2] // @140F stack[-1] // } 1408 5B JUMPDEST 1409 60 PUSH1 0x00 140B 61 PUSH2 0x0e2f 140E 83 DUP4 140F 83 DUP4 1410 61 PUSH2 0x2276 1413 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1409 stack[0] = 0x00 // @140B stack[1] = 0x0e2f // @140E stack[2] = stack[-2] // @140F stack[3] = stack[-1] // } // Block ends with call to 0x2276, returns to 0x0E2F label_1414: // Incoming jump from 0x07AB // Inputs[2] // { // @1417 storage[0x06] // @1421 msg.sender // } 1414 5B JUMPDEST 1415 60 PUSH1 0x06 1417 54 SLOAD 1418 60 PUSH1 0x01 141A 60 PUSH1 0x01 141C 60 PUSH1 0xa0 141E 1B SHL 141F 03 SUB 1420 16 AND 1421 33 CALLER 1422 14 EQ 1423 61 PUSH2 0x143e 1426 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x143e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_1427: // Incoming jump from 0x1426, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @1429 memory[0x40:0x60] } 1427 60 PUSH1 0x40 1429 51 MLOAD 142A 62 PUSH3 0x461bcd 142E 60 PUSH1 0xe5 1430 1B SHL 1431 81 DUP2 1432 52 MSTORE 1433 60 PUSH1 0x04 1435 01 ADD 1436 61 PUSH2 0x0807 1439 90 SWAP1 143A 61 PUSH2 0x370a 143D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1432 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1439 stack[0] = 0x0807 // @1439 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_143E: // Incoming jump from 0x1426, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @1444 stack[-1] } 143E 5B JUMPDEST 143F 61 PUSH2 0x081a 1442 60 PUSH1 0x14 1444 82 DUP3 1445 61 PUSH2 0x22ed 1448 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @143F stack[0] = 0x081a // @1442 stack[1] = 0x14 // @1444 stack[2] = stack[-1] // } // Block ends with call to 0x22ed, returns to 0x081A label_1449: // Incoming jump from 0x07CB // Inputs[2] // { // @144C storage[0x06] // @1456 msg.sender // } 1449 5B JUMPDEST 144A 60 PUSH1 0x06 144C 54 SLOAD 144D 60 PUSH1 0x01 144F 60 PUSH1 0x01 1451 60 PUSH1 0xa0 1453 1B SHL 1454 03 SUB 1455 16 AND 1456 33 CALLER 1457 14 EQ 1458 61 PUSH2 0x1473 145B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1473, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_145C: // Incoming jump from 0x145B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @145E memory[0x40:0x60] } 145C 60 PUSH1 0x40 145E 51 MLOAD 145F 62 PUSH3 0x461bcd 1463 60 PUSH1 0xe5 1465 1B SHL 1466 81 DUP2 1467 52 MSTORE 1468 60 PUSH1 0x04 146A 01 ADD 146B 61 PUSH2 0x0807 146E 90 SWAP1 146F 61 PUSH2 0x370a 1472 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1467 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @146E stack[0] = 0x0807 // @146E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x370a, returns to 0x0807 label_1473: // Incoming jump from 0x145B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @147C stack[-1] } 1473 5B JUMPDEST 1474 60 PUSH1 0x01 1476 60 PUSH1 0x01 1478 60 PUSH1 0xa0 147A 1B SHL 147B 03 SUB 147C 81 DUP2 147D 16 AND 147E 61 PUSH2 0x14d8 1481 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14d8, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1482: // Incoming jump from 0x1481, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1484 memory[0x40:0x60] } 1482 60 PUSH1 0x40 1484 51 MLOAD 1485 62 PUSH3 0x461bcd 1489 60 PUSH1 0xe5 148B 1B SHL 148C 81 DUP2 148D 52 MSTORE 148E 60 PUSH1 0x20 1490 60 PUSH1 0x04 1492 82 DUP3 1493 01 ADD 1494 52 MSTORE 1495 60 PUSH1 0x26 1497 60 PUSH1 0x24 1499 82 DUP3 149A 01 ADD 149B 52 MSTORE 149C 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 14BD 60 PUSH1 0x44 14BF 82 DUP3 14C0 01 ADD 14C1 52 MSTORE 14C2 65 PUSH6 0x646472657373 14C9 60 PUSH1 0xd0 14CB 1B SHL 14CC 60 PUSH1 0x64 14CE 82 DUP3 14CF 01 ADD 14D0 52 MSTORE 14D1 60 PUSH1 0x84 14D3 01 ADD 14D4 61 PUSH2 0x0807 14D7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @148D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1494 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @149B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @14C1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @14D0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @14D3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_14D8: // Incoming jump from 0x1481, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14DC stack[-1] } 14D8 5B JUMPDEST 14D9 61 PUSH2 0x14e1 14DC 81 DUP2 14DD 61 PUSH2 0x19a8 14E0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14D9 stack[0] = 0x14e1 // @14DC stack[1] = stack[-1] // } // Block ends with call to 0x19a8, returns to 0x14E1 label_14E1: // Incoming return from call to 0x19A8 at 0x14E0 // Incoming jump from 0x31F7, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x3229, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14E3 stack[-2] } 14E1 5B JUMPDEST 14E2 50 POP 14E3 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 14E4 5B JUMPDEST 14E5 54 SLOAD 14E6 90 SWAP1 14E7 56 *JUMP label_14E8: // Incoming call from 0x07D6, returns to 0x07D7 // Inputs[1] { @14F4 stack[-1] } 14E8 5B JUMPDEST 14E9 60 PUSH1 0x00 14EB 60 PUSH1 0x01 14ED 60 PUSH1 0x01 14EF 60 PUSH1 0xe0 14F1 1B SHL 14F2 03 SUB 14F3 19 NOT 14F4 82 DUP3 14F5 16 AND 14F6 63 PUSH4 0x152a902d 14FB 60 PUSH1 0xe1 14FD 1B SHL 14FE 14 EQ 14FF 80 DUP1 1500 61 PUSH2 0x07d7 1503 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14E9 stack[0] = 0x00 // @14FE stack[1] = 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x07d7, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1504: // Incoming jump from 0x1503, if not 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1508 stack[-3] } 1504 50 POP 1505 61 PUSH2 0x07d7 1508 82 DUP3 1509 61 PUSH2 0x2302 150C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1505 stack[-1] = 0x07d7 // @1508 stack[0] = stack[-3] // } // Block ends with call to 0x2302, returns to 0x07D7 label_150D: // Incoming call from 0x0819, returns to 0x081A // Inputs[1] { @1519 stack[-1] } 150D 5B JUMPDEST 150E 61 PUSH2 0x2710 1511 60 PUSH1 0x01 1513 60 PUSH1 0x01 1515 60 PUSH1 0x60 1517 1B SHL 1518 03 SUB 1519 82 DUP3 151A 16 AND 151B 11 GT 151C 15 ISZERO 151D 61 PUSH2 0x157b 1520 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x157b, if !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) label_1521: // Incoming jump from 0x1520, if not !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) // Inputs[1] { @1523 memory[0x40:0x60] } 1521 60 PUSH1 0x40 1523 51 MLOAD 1524 62 PUSH3 0x461bcd 1528 60 PUSH1 0xe5 152A 1B SHL 152B 81 DUP2 152C 52 MSTORE 152D 60 PUSH1 0x20 152F 60 PUSH1 0x04 1531 82 DUP3 1532 01 ADD 1533 52 MSTORE 1534 60 PUSH1 0x2a 1536 60 PUSH1 0x24 1538 82 DUP3 1539 01 ADD 153A 52 MSTORE 153B 7F PUSH32 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 155C 60 PUSH1 0x44 155E 82 DUP3 155F 01 ADD 1560 52 MSTORE 1561 69 PUSH10 0x2073616c655072696365 156C 60 PUSH1 0xb0 156E 1B SHL 156F 60 PUSH1 0x64 1571 82 DUP3 1572 01 ADD 1573 52 MSTORE 1574 60 PUSH1 0x84 1576 01 ADD 1577 61 PUSH2 0x0807 157A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @152C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1533 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @153A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @1560 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 // @1573 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2073616c655072696365 << 0xb0 // @1576 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_157B: // Incoming jump from 0x1520, if !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) // Inputs[1] { @1584 stack[-2] } 157B 5B JUMPDEST 157C 60 PUSH1 0x01 157E 60 PUSH1 0x01 1580 60 PUSH1 0xa0 1582 1B SHL 1583 03 SUB 1584 82 DUP3 1585 16 AND 1586 61 PUSH2 0x15d1 1589 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15d1, if stack[-2] & (0x01 << 0xa0) - 0x01 label_158A: // Incoming jump from 0x1589, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @158C memory[0x40:0x60] } 158A 60 PUSH1 0x40 158C 51 MLOAD 158D 62 PUSH3 0x461bcd 1591 60 PUSH1 0xe5 1593 1B SHL 1594 81 DUP2 1595 52 MSTORE 1596 60 PUSH1 0x20 1598 60 PUSH1 0x04 159A 82 DUP3 159B 01 ADD 159C 52 MSTORE 159D 60 PUSH1 0x19 159F 60 PUSH1 0x24 15A1 82 DUP3 15A2 01 ADD 15A3 52 MSTORE 15A4 7F PUSH32 0x455243323938313a20696e76616c696420726563656976657200000000000000 15C5 60 PUSH1 0x44 15C7 82 DUP3 15C8 01 ADD 15C9 52 MSTORE 15CA 60 PUSH1 0x64 15CC 01 ADD 15CD 61 PUSH2 0x0807 15D0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1595 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @159C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15A3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @15C9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20696e76616c696420726563656976657200000000000000 // @15CC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_15D1: // Incoming jump from 0x1589, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @15D5 memory[0x40:0x60] // @15E5 stack[-2] // @15F3 stack[-1] // @1609 stack[-3] // } 15D1 5B JUMPDEST 15D2 60 PUSH1 0x40 15D4 80 DUP1 15D5 51 MLOAD 15D6 80 DUP1 15D7 82 DUP3 15D8 01 ADD 15D9 90 SWAP1 15DA 91 SWAP2 15DB 52 MSTORE 15DC 60 PUSH1 0x01 15DE 60 PUSH1 0x01 15E0 60 PUSH1 0xa0 15E2 1B SHL 15E3 03 SUB 15E4 90 SWAP1 15E5 92 SWAP3 15E6 16 AND 15E7 80 DUP1 15E8 83 DUP4 15E9 52 MSTORE 15EA 60 PUSH1 0x01 15EC 60 PUSH1 0x01 15EE 60 PUSH1 0x60 15F0 1B SHL 15F1 03 SUB 15F2 90 SWAP1 15F3 91 SWAP2 15F4 16 AND 15F5 60 PUSH1 0x20 15F7 90 SWAP1 15F8 92 SWAP3 15F9 01 ADD 15FA 82 DUP3 15FB 90 SWAP1 15FC 52 MSTORE 15FD 60 PUSH1 0x01 15FF 60 PUSH1 0xa0 1601 1B SHL 1602 90 SWAP1 1603 91 SWAP2 1604 02 MUL 1605 17 OR 1606 60 PUSH1 0x16 1608 55 SSTORE 1609 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @15DB memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @15E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @15FC memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & (0x01 << 0x60) - 0x01 // @1608 storage[0x16] = (stack[-1] & (0x01 << 0x60) - 0x01) * (0x01 << 0xa0) | (stack[-2] & (0x01 << 0xa0) - 0x01) // } // Block ends with unconditional jump to stack[-3] label_160A: // Incoming call from 0x0A55, returns to 0x0A56 // Inputs[4] // { // @160D stack[-1] // @1618 memory[0x00:0x40] // @161A storage[keccak256(memory[0x00:0x40])] // @162D stack[-2] // } 160A 5B JUMPDEST 160B 60 PUSH1 0x00 160D 81 DUP2 160E 81 DUP2 160F 52 MSTORE 1610 60 PUSH1 0x04 1612 60 PUSH1 0x20 1614 52 MSTORE 1615 60 PUSH1 0x40 1617 90 SWAP1 1618 20 SHA3 1619 80 DUP1 161A 54 SLOAD 161B 60 PUSH1 0x01 161D 60 PUSH1 0x01 161F 60 PUSH1 0xa0 1621 1B SHL 1622 03 SUB 1623 19 NOT 1624 16 AND 1625 60 PUSH1 0x01 1627 60 PUSH1 0x01 1629 60 PUSH1 0xa0 162B 1B SHL 162C 03 SUB 162D 84 DUP5 162E 16 AND 162F 90 SWAP1 1630 81 DUP2 1631 17 OR 1632 90 SWAP1 1633 91 SWAP2 1634 55 SSTORE 1635 81 DUP2 1636 90 SWAP1 1637 61 PUSH2 0x163f 163A 82 DUP3 163B 61 PUSH2 0x0e85 163E 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @160F memory[0x00:0x20] = stack[-1] // @1614 memory[0x20:0x40] = 0x04 // @1634 storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1636 stack[0] = stack[-1] // @1636 stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1637 stack[2] = 0x163f // @163A stack[3] = stack[-1] // } // Block ends with call to 0x0e85, returns to 0x163F label_163F: // Incoming return from call to 0x0E85 at 0x163E // Inputs[7] // { // @1648 stack[-1] // @166C memory[0x40:0x60] // @166F memory[0x40:0x60] // @1674 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1674 stack[-3] // @1674 stack[-2] // @1677 stack[-6] // } 163F 5B JUMPDEST 1640 60 PUSH1 0x01 1642 60 PUSH1 0x01 1644 60 PUSH1 0xa0 1646 1B SHL 1647 03 SUB 1648 16 AND 1649 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 166A 60 PUSH1 0x40 166C 51 MLOAD 166D 60 PUSH1 0x40 166F 51 MLOAD 1670 80 DUP1 1671 91 SWAP2 1672 03 SUB 1673 90 SWAP1 1674 A4 LOG4 1675 50 POP 1676 50 POP 1677 56 *JUMP // Stack delta = -6 // Outputs[1] { @1674 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_1678: // Incoming call from 0x0A8F, returns to 0x081A // Inputs[2] // { // @167E stack[-2] // @1687 stack[-1] // } 1678 5B JUMPDEST 1679 60 PUSH1 0x00 167B 61 PUSH2 0x0e2f 167E 83 DUP4 167F 60 PUSH1 0x01 1681 60 PUSH1 0x01 1683 60 PUSH1 0xa0 1685 1B SHL 1686 03 SUB 1687 84 DUP5 1688 16 AND 1689 61 PUSH2 0x230d 168C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1679 stack[0] = 0x00 // @167B stack[1] = 0x0e2f // @167E stack[2] = stack[-2] // @1688 stack[3] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with call to 0x230d, returns to 0x0E2F label_168D: // Incoming call from 0x0AE5, returns to 0x0AE6 // Incoming call from 0x10CD, returns to 0x10CE // Inputs[3] // { // @1690 stack[-1] // @169B memory[0x00:0x40] // @169C storage[keccak256(memory[0x00:0x40])] // } 168D 5B JUMPDEST 168E 60 PUSH1 0x00 1690 81 DUP2 1691 81 DUP2 1692 52 MSTORE 1693 60 PUSH1 0x02 1695 60 PUSH1 0x20 1697 52 MSTORE 1698 60 PUSH1 0x40 169A 81 DUP2 169B 20 SHA3 169C 54 SLOAD 169D 60 PUSH1 0x01 169F 60 PUSH1 0x01 16A1 60 PUSH1 0xa0 16A3 1B SHL 16A4 03 SUB 16A5 16 AND 16A6 61 PUSH2 0x1706 16A9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @168E stack[0] = 0x00 // @1692 memory[0x00:0x20] = stack[-1] // @1697 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x1706, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_16AA: // Incoming jump from 0x16A9, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @16AC memory[0x40:0x60] } 16AA 60 PUSH1 0x40 16AC 51 MLOAD 16AD 62 PUSH3 0x461bcd 16B1 60 PUSH1 0xe5 16B3 1B SHL 16B4 81 DUP2 16B5 52 MSTORE 16B6 60 PUSH1 0x20 16B8 60 PUSH1 0x04 16BA 82 DUP3 16BB 01 ADD 16BC 52 MSTORE 16BD 60 PUSH1 0x2c 16BF 60 PUSH1 0x24 16C1 82 DUP3 16C2 01 ADD 16C3 52 MSTORE 16C4 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 16E5 60 PUSH1 0x44 16E7 82 DUP3 16E8 01 ADD 16E9 52 MSTORE 16EA 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 16F7 60 PUSH1 0xa1 16F9 1B SHL 16FA 60 PUSH1 0x64 16FC 82 DUP3 16FD 01 ADD 16FE 52 MSTORE 16FF 60 PUSH1 0x84 1701 01 ADD 1702 61 PUSH2 0x0807 1705 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @16B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16BC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @16C3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @16E9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @16FE memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @1701 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_1706: // Incoming jump from 0x16A9, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @170C stack[-2] } 1706 5B JUMPDEST 1707 60 PUSH1 0x00 1709 61 PUSH2 0x1711 170C 83 DUP4 170D 61 PUSH2 0x0e85 1710 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1707 stack[0] = 0x00 // @1709 stack[1] = 0x1711 // @170C stack[2] = stack[-2] // } // Block ends with call to 0x0e85, returns to 0x1711 label_1711: // Incoming return from call to 0x0E85 at 0x1710 // Inputs[3] // { // @1712 stack[-1] // @1712 stack[-2] // @171E stack[-5] // } 1711 5B JUMPDEST 1712 90 SWAP1 1713 50 POP 1714 80 DUP1 1715 60 PUSH1 0x01 1717 60 PUSH1 0x01 1719 60 PUSH1 0xa0 171B 1B SHL 171C 03 SUB 171D 16 AND 171E 84 DUP5 171F 60 PUSH1 0x01 1721 60 PUSH1 0x01 1723 60 PUSH1 0xa0 1725 1B SHL 1726 03 SUB 1727 16 AND 1728 14 EQ 1729 80 DUP1 172A 61 PUSH2 0x174c 172D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1712 stack[-2] = stack[-1] // @1728 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x174c, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_172E: // Incoming jump from 0x172D, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @172F stack[-5] // @173C stack[-4] // } 172E 50 POP 172F 83 DUP4 1730 60 PUSH1 0x01 1732 60 PUSH1 0x01 1734 60 PUSH1 0xa0 1736 1B SHL 1737 03 SUB 1738 16 AND 1739 61 PUSH2 0x1741 173C 84 DUP5 173D 61 PUSH2 0x08b0 1740 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1738 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1739 stack[0] = 0x1741 // @173C stack[1] = stack[-4] // } // Block ends with call to 0x08b0, returns to 0x1741 label_1741: // Incoming return from call to 0x08B0 at 0x1740 // Inputs[2] // { // @174A stack[-1] // @174B stack[-2] // } 1741 5B JUMPDEST 1742 60 PUSH1 0x01 1744 60 PUSH1 0x01 1746 60 PUSH1 0xa0 1748 1B SHL 1749 03 SUB 174A 16 AND 174B 14 EQ // Stack delta = -1 // Outputs[1] { @174B stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_174C: // Incoming jump from 0x172D, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x174B // Inputs[1] { @174D stack[-1] } 174C 5B JUMPDEST 174D 80 DUP1 174E 61 PUSH2 0x175c 1751 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x175c, if stack[-1] label_1752: // Incoming jump from 0x1751, if not stack[-1] // Inputs[2] // { // @1756 stack[-2] // @1757 stack[-5] // } 1752 50 POP 1753 61 PUSH2 0x175c 1756 81 DUP2 1757 85 DUP6 1758 61 PUSH2 0x1408 175B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1753 stack[-1] = 0x175c // @1756 stack[0] = stack[-2] // @1757 stack[1] = stack[-5] // } // Block ends with unconditional jump to 0x1408 label_175C: // Incoming jump from 0x1751, if stack[-1] // Incoming jump from 0x2215, if !stack[-5] // Incoming jump from 0x297A, if !(stack[-1] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x2215, if !stack[-7] // Incoming jump from 0x2215, if !stack[-7] // Incoming return from call to 0x349D at 0x355B // Inputs[3] // { // @175D stack[-1] // @175D stack[-6] // @175E stack[-5] // } 175C 5B JUMPDEST 175D 94 SWAP5 175E 93 SWAP4 175F 50 POP 1760 50 POP 1761 50 POP 1762 50 POP 1763 56 *JUMP // Stack delta = -5 // Outputs[1] { @175D stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1764: // Incoming jump from 0x0B0C // Incoming jump from 0x2108 // Inputs[2] // { // @1765 stack[-3] // @1772 stack[-1] // } 1764 5B JUMPDEST 1765 82 DUP3 1766 60 PUSH1 0x01 1768 60 PUSH1 0x01 176A 60 PUSH1 0xa0 176C 1B SHL 176D 03 SUB 176E 16 AND 176F 61 PUSH2 0x1777 1772 82 DUP3 1773 61 PUSH2 0x0e85 1776 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @176E stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @176F stack[1] = 0x1777 // @1772 stack[2] = stack[-1] // } // Block ends with call to 0x0e85, returns to 0x1777 label_1777: // Incoming return from call to 0x0E85 at 0x1776 // Inputs[2] // { // @1780 stack[-1] // @1781 stack[-2] // } 1777 5B JUMPDEST 1778 60 PUSH1 0x01 177A 60 PUSH1 0x01 177C 60 PUSH1 0xa0 177E 1B SHL 177F 03 SUB 1780 16 AND 1781 14 EQ 1782 61 PUSH2 0x17db 1785 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x17db, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1786: // Incoming jump from 0x1785, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1788 memory[0x40:0x60] } 1786 60 PUSH1 0x40 1788 51 MLOAD 1789 62 PUSH3 0x461bcd 178D 60 PUSH1 0xe5 178F 1B SHL 1790 81 DUP2 1791 52 MSTORE 1792 60 PUSH1 0x20 1794 60 PUSH1 0x04 1796 82 DUP3 1797 01 ADD 1798 52 MSTORE 1799 60 PUSH1 0x25 179B 60 PUSH1 0x24 179D 82 DUP3 179E 01 ADD 179F 52 MSTORE 17A0 7F PUSH32 0x4552433732313a207472616e736665722066726f6d20696e636f727265637420 17C1 60 PUSH1 0x44 17C3 82 DUP3 17C4 01 ADD 17C5 52 MSTORE 17C6 64 PUSH5 0x37bbb732b9 17CC 60 PUSH1 0xd9 17CE 1B SHL 17CF 60 PUSH1 0x64 17D1 82 DUP3 17D2 01 ADD 17D3 52 MSTORE 17D4 60 PUSH1 0x84 17D6 01 ADD 17D7 61 PUSH2 0x0807 17DA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1791 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1798 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @179F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @17C5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e736665722066726f6d20696e636f727265637420 // @17D3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x37bbb732b9 << 0xd9 // @17D6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_17DB: // Incoming jump from 0x1785, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @17E4 stack[-2] } 17DB 5B JUMPDEST 17DC 60 PUSH1 0x01 17DE 60 PUSH1 0x01 17E0 60 PUSH1 0xa0 17E2 1B SHL 17E3 03 SUB 17E4 82 DUP3 17E5 16 AND 17E6 61 PUSH2 0x183d 17E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x183d, if stack[-2] & (0x01 << 0xa0) - 0x01 label_17EA: // Incoming jump from 0x17E9, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @17EC memory[0x40:0x60] } 17EA 60 PUSH1 0x40 17EC 51 MLOAD 17ED 62 PUSH3 0x461bcd 17F1 60 PUSH1 0xe5 17F3 1B SHL 17F4 81 DUP2 17F5 52 MSTORE 17F6 60 PUSH1 0x20 17F8 60 PUSH1 0x04 17FA 82 DUP3 17FB 01 ADD 17FC 52 MSTORE 17FD 60 PUSH1 0x24 17FF 80 DUP1 1800 82 DUP3 1801 01 ADD 1802 52 MSTORE 1803 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 1824 60 PUSH1 0x44 1826 82 DUP3 1827 01 ADD 1828 52 MSTORE 1829 63 PUSH4 0x72657373 182E 60 PUSH1 0xe0 1830 1B SHL 1831 60 PUSH1 0x64 1833 82 DUP3 1834 01 ADD 1835 52 MSTORE 1836 60 PUSH1 0x84 1838 01 ADD 1839 61 PUSH2 0x0807 183C 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @17F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17FC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1802 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @1828 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @1835 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72657373 << 0xe0 // @1838 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_183D: // Incoming jump from 0x17E9, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1841 stack[-3] // @1842 stack[-2] // @1843 stack[-1] // } 183D 5B JUMPDEST 183E 61 PUSH2 0x1848 1841 83 DUP4 1842 83 DUP4 1843 83 DUP4 1844 61 PUSH2 0x2400 1847 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @183E stack[0] = 0x1848 // @1841 stack[1] = stack[-3] // @1842 stack[2] = stack[-2] // @1843 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x2400 1848 5B JUMPDEST 1849 61 PUSH2 0x1853 184C 60 PUSH1 0x00 184E 82 DUP3 184F 61 PUSH2 0x160a 1852 56 *JUMP 1853 5B JUMPDEST 1854 60 PUSH1 0x01 1856 60 PUSH1 0x01 1858 60 PUSH1 0xa0 185A 1B SHL 185B 03 SUB 185C 83 DUP4 185D 16 AND 185E 60 PUSH1 0x00 1860 90 SWAP1 1861 81 DUP2 1862 52 MSTORE 1863 60 PUSH1 0x03 1865 60 PUSH1 0x20 1867 52 MSTORE 1868 60 PUSH1 0x40 186A 81 DUP2 186B 20 SHA3 186C 80 DUP1 186D 54 SLOAD 186E 60 PUSH1 0x01 1870 92 SWAP3 1871 90 SWAP1 1872 61 PUSH2 0x187c 1875 90 SWAP1 1876 84 DUP5 1877 90 SWAP1 1878 61 PUSH2 0x3854 187B 56 *JUMP 187C 5B JUMPDEST 187D 90 SWAP1 187E 91 SWAP2 187F 55 SSTORE 1880 50 POP 1881 50 POP 1882 60 PUSH1 0x01 1884 60 PUSH1 0x01 1886 60 PUSH1 0xa0 1888 1B SHL 1889 03 SUB 188A 82 DUP3 188B 16 AND 188C 60 PUSH1 0x00 188E 90 SWAP1 188F 81 DUP2 1890 52 MSTORE 1891 60 PUSH1 0x03 1893 60 PUSH1 0x20 1895 52 MSTORE 1896 60 PUSH1 0x40 1898 81 DUP2 1899 20 SHA3 189A 80 DUP1 189B 54 SLOAD 189C 60 PUSH1 0x01 189E 92 SWAP3 189F 90 SWAP1 18A0 61 PUSH2 0x18aa 18A3 90 SWAP1 18A4 84 DUP5 18A5 90 SWAP1 18A6 61 PUSH2 0x38b0 18A9 56 *JUMP 18AA 5B JUMPDEST 18AB 90 SWAP1 18AC 91 SWAP2 18AD 55 SSTORE 18AE 50 POP 18AF 50 POP 18B0 60 PUSH1 0x00 18B2 81 DUP2 18B3 81 DUP2 18B4 52 MSTORE 18B5 60 PUSH1 0x02 18B7 60 PUSH1 0x20 18B9 52 MSTORE 18BA 60 PUSH1 0x40 18BC 80 DUP1 18BD 82 DUP3 18BE 20 SHA3 18BF 80 DUP1 18C0 54 SLOAD 18C1 60 PUSH1 0x01 18C3 60 PUSH1 0x01 18C5 60 PUSH1 0xa0 18C7 1B SHL 18C8 03 SUB 18C9 19 NOT 18CA 16 AND 18CB 60 PUSH1 0x01 18CD 60 PUSH1 0x01 18CF 60 PUSH1 0xa0 18D1 1B SHL 18D2 03 SUB 18D3 86 DUP7 18D4 81 DUP2 18D5 16 AND 18D6 91 SWAP2 18D7 82 DUP3 18D8 17 OR 18D9 90 SWAP1 18DA 92 SWAP3 18DB 55 SSTORE 18DC 91 SWAP2 18DD 51 MLOAD 18DE 84 DUP5 18DF 93 SWAP4 18E0 91 SWAP2 18E1 87 DUP8 18E2 16 AND 18E3 91 SWAP2 18E4 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1905 91 SWAP2 1906 A4 LOG4 1907 50 POP 1908 50 POP 1909 50 POP 190A 56 *JUMP label_190B: // Incoming call from 0x0E67, returns to 0x0E68 // Inputs[1] { @190E storage[0x06] } 190B 5B JUMPDEST 190C 60 PUSH1 0x06 190E 54 SLOAD 190F 60 PUSH1 0x01 1911 60 PUSH1 0xa0 1913 1B SHL 1914 90 SWAP1 1915 04 DIV 1916 60 PUSH1 0xff 1918 16 AND 1919 61 PUSH2 0x195b 191C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x195b, if 0xff & storage[0x06] / (0x01 << 0xa0) label_191D: // Incoming jump from 0x191C, if not 0xff & storage[0x06] / (0x01 << 0xa0) // Inputs[1] { @191F memory[0x40:0x60] } 191D 60 PUSH1 0x40 191F 51 MLOAD 1920 62 PUSH3 0x461bcd 1924 60 PUSH1 0xe5 1926 1B SHL 1927 81 DUP2 1928 52 MSTORE 1929 60 PUSH1 0x20 192B 60 PUSH1 0x04 192D 82 DUP3 192E 01 ADD 192F 52 MSTORE 1930 60 PUSH1 0x14 1932 60 PUSH1 0x24 1934 82 DUP3 1935 01 ADD 1936 52 MSTORE 1937 73 PUSH20 0x14185d5cd8589b194e881b9bdd081c185d5cd959 194C 60 PUSH1 0x62 194E 1B SHL 194F 60 PUSH1 0x44 1951 82 DUP3 1952 01 ADD 1953 52 MSTORE 1954 60 PUSH1 0x64 1956 01 ADD 1957 61 PUSH2 0x0807 195A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1928 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @192F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1936 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1953 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14185d5cd8589b194e881b9bdd081c185d5cd959 << 0x62 // @1956 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_195B: // Incoming jump from 0x191C, if 0xff & storage[0x06] / (0x01 << 0xa0) // Inputs[2] // { // @195F storage[0x06] // @198A msg.sender // } 195B 5B JUMPDEST 195C 60 PUSH1 0x06 195E 80 DUP1 195F 54 SLOAD 1960 60 PUSH1 0xff 1962 60 PUSH1 0xa0 1964 1B SHL 1965 19 NOT 1966 16 AND 1967 90 SWAP1 1968 55 SSTORE 1969 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 198A 33 CALLER // Stack delta = +2 // Outputs[3] // { // @1968 storage[0x06] = ~(0xff << 0xa0) & storage[0x06] // @1969 stack[0] = 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa // @198A stack[1] = msg.sender // } // Block continues label_198B: // Incoming jump from 0x198A // Incoming jump from 0x1A5E // Inputs[6] // { // @198E memory[0x40:0x60] // @1998 stack[-1] // @19A1 memory[0x40:0x60] // @19A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @19A6 stack[-2] // @19A7 stack[-3] // } 198B 5B JUMPDEST 198C 60 PUSH1 0x40 198E 51 MLOAD 198F 60 PUSH1 0x01 1991 60 PUSH1 0x01 1993 60 PUSH1 0xa0 1995 1B SHL 1996 03 SUB 1997 90 SWAP1 1998 91 SWAP2 1999 16 AND 199A 81 DUP2 199B 52 MSTORE 199C 60 PUSH1 0x20 199E 01 ADD 199F 60 PUSH1 0x40 19A1 51 MLOAD 19A2 80 DUP1 19A3 91 SWAP2 19A4 03 SUB 19A5 90 SWAP1 19A6 A1 LOG1 19A7 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @199B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @19A6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [stack[-2]]); // } // Block ends with unconditional jump to stack[-3] label_19A8: // Incoming call from 0x0FB6, returns to 0x0E68 // Incoming call from 0x14E0, returns to 0x14E1 // Inputs[5] // { // @19AC storage[0x06] // @19B5 stack[-1] // @19CA memory[0x40:0x60] // @19F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @19F9 stack[-2] // } 19A8 5B JUMPDEST 19A9 60 PUSH1 0x06 19AB 80 DUP1 19AC 54 SLOAD 19AD 60 PUSH1 0x01 19AF 60 PUSH1 0x01 19B1 60 PUSH1 0xa0 19B3 1B SHL 19B4 03 SUB 19B5 83 DUP4 19B6 81 DUP2 19B7 16 AND 19B8 60 PUSH1 0x01 19BA 60 PUSH1 0x01 19BC 60 PUSH1 0xa0 19BE 1B SHL 19BF 03 SUB 19C0 19 NOT 19C1 83 DUP4 19C2 16 AND 19C3 81 DUP2 19C4 17 OR 19C5 90 SWAP1 19C6 93 SWAP4 19C7 55 SSTORE 19C8 60 PUSH1 0x40 19CA 51 MLOAD 19CB 91 SWAP2 19CC 16 AND 19CD 91 SWAP2 19CE 90 SWAP1 19CF 82 DUP3 19D0 90 SWAP1 19D1 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 19F2 90 SWAP1 19F3 60 PUSH1 0x00 19F5 90 SWAP1 19F6 A3 LOG3 19F7 50 POP 19F8 50 POP 19F9 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @19C7 storage[0x06] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x06] & ~((0x01 << 0xa0) - 0x01)) // @19F6 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x06] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_19FA: // Incoming call from 0x0FE8, returns to 0x0E68 // Inputs[1] { @19FD storage[0x06] } 19FA 5B JUMPDEST 19FB 60 PUSH1 0x06 19FD 54 SLOAD 19FE 60 PUSH1 0x01 1A00 60 PUSH1 0xa0 1A02 1B SHL 1A03 90 SWAP1 1A04 04 DIV 1A05 60 PUSH1 0xff 1A07 16 AND 1A08 15 ISZERO 1A09 61 PUSH2 0x1a24 1A0C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a24, if !(0xff & storage[0x06] / (0x01 << 0xa0)) label_1A0D: // Incoming jump from 0x1A0C, if not !(0xff & storage[0x06] / (0x01 << 0xa0)) // Inputs[1] { @1A0F memory[0x40:0x60] } 1A0D 60 PUSH1 0x40 1A0F 51 MLOAD 1A10 62 PUSH3 0x461bcd 1A14 60 PUSH1 0xe5 1A16 1B SHL 1A17 81 DUP2 1A18 52 MSTORE 1A19 60 PUSH1 0x04 1A1B 01 ADD 1A1C 61 PUSH2 0x0807 1A1F 90 SWAP1 1A20 61 PUSH2 0x382a 1A23 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1A18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A1F stack[0] = 0x0807 // @1A1F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x382a, returns to 0x0807 label_1A24: // Incoming jump from 0x1A0C, if !(0xff & storage[0x06] / (0x01 << 0xa0)) // Inputs[2] // { // @1A28 storage[0x06] // @1A5C msg.sender // } 1A24 5B JUMPDEST 1A25 60 PUSH1 0x06 1A27 80 DUP1 1A28 54 SLOAD 1A29 60 PUSH1 0xff 1A2B 60 PUSH1 0xa0 1A2D 1B SHL 1A2E 19 NOT 1A2F 16 AND 1A30 60 PUSH1 0x01 1A32 60 PUSH1 0xa0 1A34 1B SHL 1A35 17 OR 1A36 90 SWAP1 1A37 55 SSTORE 1A38 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 1A59 61 PUSH2 0x198b 1A5C 33 CALLER 1A5D 90 SWAP1 1A5E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1A37 storage[0x06] = (0x01 << 0xa0) | (~(0xff << 0xa0) & storage[0x06]) // @1A38 stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @1A5D stack[1] = msg.sender // } // Block ends with unconditional jump to 0x198b label_1A5F: // Incoming call from 0x104A, returns to 0x104B // Incoming call from 0x100C, returns to 0x100D // Inputs[6] // { // @1A62 memory[0x40:0x60] // @1A65 stack[-3] // @1A80 stack[-2] // @1A87 stack[-1] // @1A90 memory[0x40:0x60] // @1A9F stack[-4] // } 1A5F 5B JUMPDEST 1A60 60 PUSH1 0x40 1A62 51 MLOAD 1A63 60 PUSH1 0x60 1A65 84 DUP5 1A66 81 DUP2 1A67 1B SHL 1A68 6B PUSH12 0xffffffffffffffffffffffff 1A75 19 NOT 1A76 16 AND 1A77 60 PUSH1 0x20 1A79 83 DUP4 1A7A 01 ADD 1A7B 52 MSTORE 1A7C 60 PUSH1 0x34 1A7E 82 DUP3 1A7F 01 ADD 1A80 84 DUP5 1A81 90 SWAP1 1A82 52 MSTORE 1A83 60 PUSH1 0x54 1A85 82 DUP3 1A86 01 ADD 1A87 83 DUP4 1A88 90 SWAP1 1A89 52 MSTORE 1A8A 90 SWAP1 1A8B 60 PUSH1 0x74 1A8D 01 ADD 1A8E 60 PUSH1 0x40 1A90 51 MLOAD 1A91 60 PUSH1 0x20 1A93 81 DUP2 1A94 83 DUP4 1A95 03 SUB 1A96 03 SUB 1A97 81 DUP2 1A98 52 MSTORE 1A99 90 SWAP1 1A9A 60 PUSH1 0x40 1A9C 52 MSTORE 1A9D 90 SWAP1 1A9E 50 POP 1A9F 93 SWAP4 1AA0 92 SWAP3 1AA1 50 POP 1AA2 50 POP 1AA3 50 POP 1AA4 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @1A7B memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = ~0xffffffffffffffffffffffff & (stack[-3] << 0x60) // @1A82 memory[memory[0x40:0x60] + 0x34:memory[0x40:0x60] + 0x34 + 0x20] = stack[-2] // @1A89 memory[memory[0x40:0x60] + 0x54:memory[0x40:0x60] + 0x54 + 0x20] = stack[-1] // @1A98 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x74 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @1A9C memory[0x40:0x60] = 0x74 + memory[0x40:0x60] // @1A9F stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_1AA5: // Incoming jump from 0x1ABA // Incoming jump from 0x1011 // Inputs[1] { @1AAB stack[-1] } 1AA5 5B JUMPDEST 1AA6 60 PUSH1 0x00 1AA8 61 PUSH2 0x07d7 1AAB 82 DUP3 1AAC 61 PUSH2 0x240b 1AAF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AA6 stack[0] = 0x00 // @1AA8 stack[1] = 0x07d7 // @1AAB stack[2] = stack[-1] // } // Block ends with call to 0x240b, returns to 0x07D7 label_1AB0: // Incoming jump from 0x1056 // Inputs[1] { @1AB6 stack[-4] } 1AB0 5B JUMPDEST 1AB1 60 PUSH1 0x00 1AB3 61 PUSH2 0x1abb 1AB6 85 DUP6 1AB7 61 PUSH2 0x1aa5 1ABA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AB1 stack[0] = 0x00 // @1AB3 stack[1] = 0x1abb // @1AB6 stack[2] = stack[-4] // } // Block ends with unconditional jump to 0x1aa5 1ABB 5B JUMPDEST 1ABC 60 PUSH1 0x00 1ABE 81 DUP2 1ABF 81 DUP2 1AC0 52 MSTORE 1AC1 60 PUSH1 0x20 1AC3 84 DUP5 1AC4 90 SWAP1 1AC5 52 MSTORE 1AC6 60 PUSH1 0x40 1AC8 90 SWAP1 1AC9 20 SHA3 1ACA 54 SLOAD 1ACB 90 SWAP1 1ACC 91 SWAP2 1ACD 50 POP 1ACE 60 PUSH1 0xff 1AD0 16 AND 1AD1 15 ISZERO 1AD2 61 PUSH2 0x1b2c 1AD5 57 *JUMPI 1AD6 60 PUSH1 0x40 1AD8 51 MLOAD 1AD9 62 PUSH3 0x461bcd 1ADD 60 PUSH1 0xe5 1ADF 1B SHL 1AE0 81 DUP2 1AE1 52 MSTORE 1AE2 60 PUSH1 0x20 1AE4 60 PUSH1 0x04 1AE6 82 DUP3 1AE7 01 ADD 1AE8 52 MSTORE 1AE9 60 PUSH1 0x26 1AEB 60 PUSH1 0x24 1AED 82 DUP3 1AEE 01 ADD 1AEF 52 MSTORE 1AF0 7F PUSH32 0x5369676e6174757265436865636b65723a204d65737361676520616c72656164 1B11 60 PUSH1 0x44 1B13 82 DUP3 1B14 01 ADD 1B15 52 MSTORE 1B16 65 PUSH6 0x1e481d5cd959 1B1D 60 PUSH1 0xd2 1B1F 1B SHL 1B20 60 PUSH1 0x64 1B22 82 DUP3 1B23 01 ADD 1B24 52 MSTORE 1B25 60 PUSH1 0x84 1B27 01 ADD 1B28 61 PUSH2 0x0807 1B2B 56 *JUMP 1B2C 5B JUMPDEST 1B2D 60 PUSH1 0x00 1B2F 81 DUP2 1B30 81 DUP2 1B31 52 MSTORE 1B32 60 PUSH1 0x20 1B34 83 DUP4 1B35 90 SWAP1 1B36 52 MSTORE 1B37 60 PUSH1 0x40 1B39 90 SWAP1 1B3A 20 SHA3 1B3B 80 DUP1 1B3C 54 SLOAD 1B3D 60 PUSH1 0xff 1B3F 19 NOT 1B40 16 AND 1B41 60 PUSH1 0x01 1B43 17 OR 1B44 90 SWAP1 1B45 55 SSTORE 1B46 61 PUSH2 0x1b51 1B49 86 DUP7 1B4A 82 DUP3 1B4B 86 DUP7 1B4C 86 DUP7 1B4D 61 PUSH2 0x2446 1B50 56 *JUMP 1B51 5B JUMPDEST 1B52 50 POP 1B53 50 POP 1B54 50 POP 1B55 50 POP 1B56 50 POP 1B57 50 POP 1B58 56 *JUMP label_1B59: // Incoming jump from 0x10B9 // Inputs[1] { @1B5E storage[0x0a] } 1B59 5B JUMPDEST 1B5A 60 PUSH1 0x02 1B5C 60 PUSH1 0x0a 1B5E 54 SLOAD 1B5F 14 EQ 1B60 15 ISZERO 1B61 61 PUSH2 0x1bac 1B64 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1bac, if !(storage[0x0a] == 0x02) label_1B65: // Incoming jump from 0x1B64, if not !(storage[0x0a] == 0x02) // Inputs[1] { @1B67 memory[0x40:0x60] } 1B65 60 PUSH1 0x40 1B67 51 MLOAD 1B68 62 PUSH3 0x461bcd 1B6C 60 PUSH1 0xe5 1B6E 1B SHL 1B6F 81 DUP2 1B70 52 MSTORE 1B71 60 PUSH1 0x20 1B73 60 PUSH1 0x04 1B75 82 DUP3 1B76 01 ADD 1B77 52 MSTORE 1B78 60 PUSH1 0x1f 1B7A 60 PUSH1 0x24 1B7C 82 DUP3 1B7D 01 ADD 1B7E 52 MSTORE 1B7F 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 1BA0 60 PUSH1 0x44 1BA2 82 DUP3 1BA3 01 ADD 1BA4 52 MSTORE 1BA5 60 PUSH1 0x64 1BA7 01 ADD 1BA8 61 PUSH2 0x0807 1BAB 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1B70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B77 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B7E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @1BA4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @1BA7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_1BAC: // Incoming jump from 0x1B64, if !(storage[0x0a] == 0x02) // Inputs[1] { @1BB4 storage[0x06] } 1BAC 5B JUMPDEST 1BAD 60 PUSH1 0x02 1BAF 60 PUSH1 0x0a 1BB1 55 SSTORE 1BB2 60 PUSH1 0x06 1BB4 54 SLOAD 1BB5 60 PUSH1 0x01 1BB7 60 PUSH1 0xa0 1BB9 1B SHL 1BBA 90 SWAP1 1BBB 04 DIV 1BBC 60 PUSH1 0xff 1BBE 16 AND 1BBF 15 ISZERO 1BC0 61 PUSH2 0x1bdb 1BC3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BB1 storage[0x0a] = 0x02 } // Block ends with conditional jump to 0x1bdb, if !(0xff & storage[0x06] / (0x01 << 0xa0)) label_1BC4: // Incoming jump from 0x1BC3, if not !(0xff & storage[0x06] / (0x01 << 0xa0)) // Inputs[1] { @1BC6 memory[0x40:0x60] } 1BC4 60 PUSH1 0x40 1BC6 51 MLOAD 1BC7 62 PUSH3 0x461bcd 1BCB 60 PUSH1 0xe5 1BCD 1B SHL 1BCE 81 DUP2 1BCF 52 MSTORE 1BD0 60 PUSH1 0x04 1BD2 01 ADD 1BD3 61 PUSH2 0x0807 1BD6 90 SWAP1 1BD7 61 PUSH2 0x382a 1BDA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1BCF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1BD6 stack[0] = 0x0807 // @1BD6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x382a, returns to 0x0807 label_1BDB: // Incoming jump from 0x1BC3, if !(0xff & storage[0x06] / (0x01 << 0xa0)) // Inputs[6] // { // @1BDF memory[0x40:0x60] // @1BE8 storage[0x0b] // @1BED storage[0x0c] // @1BF5 storage[0x0d] // @1BFE storage[0x0e] // @1C23 storage[0x0f] // } 1BDB 5B JUMPDEST 1BDC 60 PUSH1 0x40 1BDE 80 DUP1 1BDF 51 MLOAD 1BE0 60 PUSH1 0xe0 1BE2 81 DUP2 1BE3 01 ADD 1BE4 82 DUP3 1BE5 52 MSTORE 1BE6 60 PUSH1 0x0b 1BE8 54 SLOAD 1BE9 81 DUP2 1BEA 52 MSTORE 1BEB 60 PUSH1 0x0c 1BED 54 SLOAD 1BEE 60 PUSH1 0x20 1BF0 82 DUP3 1BF1 01 ADD 1BF2 52 MSTORE 1BF3 60 PUSH1 0x0d 1BF5 54 SLOAD 1BF6 91 SWAP2 1BF7 81 DUP2 1BF8 01 ADD 1BF9 82 DUP3 1BFA 90 SWAP1 1BFB 52 MSTORE 1BFC 60 PUSH1 0x0e 1BFE 54 SLOAD 1BFF 60 PUSH1 0x01 1C01 60 PUSH1 0x01 1C03 60 PUSH1 0xf8 1C05 1B SHL 1C06 03 SUB 1C07 81 DUP2 1C08 16 AND 1C09 60 PUSH1 0x60 1C0B 83 DUP4 1C0C 01 ADD 1C0D 52 MSTORE 1C0E 60 PUSH1 0xff 1C10 60 PUSH1 0x01 1C12 60 PUSH1 0xf8 1C14 1B SHL 1C15 90 SWAP1 1C16 91 SWAP2 1C17 04 DIV 1C18 81 DUP2 1C19 16 AND 1C1A 15 ISZERO 1C1B 15 ISZERO 1C1C 60 PUSH1 0x80 1C1E 83 DUP4 1C1F 01 ADD 1C20 52 MSTORE 1C21 60 PUSH1 0x0f 1C23 54 SLOAD 1C24 80 DUP1 1C25 82 DUP3 1C26 16 AND 1C27 15 ISZERO 1C28 15 ISZERO 1C29 60 PUSH1 0xa0 1C2B 84 DUP5 1C2C 01 ADD 1C2D 52 MSTORE 1C2E 61 PUSH2 0x0100 1C31 90 SWAP1 1C32 04 DIV 1C33 16 AND 1C34 15 ISZERO 1C35 15 ISZERO 1C36 60 PUSH1 0xc0 1C38 82 DUP3 1C39 01 ADD 1C3A 52 MSTORE 1C3B 90 SWAP1 1C3C 60 PUSH1 0x00 1C3E 90 SWAP1 1C3F 15 ISZERO 1C40 61 PUSH2 0x1c56 1C43 57 *JUMPI // Stack delta = +2 // Outputs[10] // { // @1BE5 memory[0x40:0x60] = memory[0x40:0x60] + 0xe0 // @1BEA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x0b] // @1BF2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = storage[0x0c] // @1BFB memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = storage[0x0d] // @1C0D memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = storage[0x0e] & (0x01 << 0xf8) - 0x01 // @1C20 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = !!(0xff & storage[0x0e] / (0x01 << 0xf8)) // @1C2D memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = !!(0xff & storage[0x0f]) // @1C3A memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = !!(storage[0x0f] / 0x0100 & 0xff) // @1C3B stack[0] = memory[0x40:0x60] // @1C3E stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c56, if !storage[0x0d] label_1C44: // Incoming jump from 0x1C43, if not !storage[0x0d] // Inputs[3] // { // @1C47 stack[-4] // @1C48 stack[-2] // @1C4C memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 1C44 61 PUSH2 0x1c51 1C47 84 DUP5 1C48 83 DUP4 1C49 60 PUSH1 0x40 1C4B 01 ADD 1C4C 51 MLOAD 1C4D 61 PUSH2 0x2131 1C50 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C44 stack[0] = 0x1c51 // @1C47 stack[1] = stack[-4] // @1C4C stack[2] = memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with call to 0x2131, returns to 0x1C51 label_1C51: // Incoming return from call to 0x2131 at 0x1C50 1C51 5B JUMPDEST 1C52 61 PUSH2 0x1c58 1C55 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1c58 label_1C56: // Incoming jump from 0x1C43, if !storage[0x0d] // Inputs[4] // { // @1C57 stack[-4] // @1C59 stack[-1] // @1C5E stack[-2] // @1C62 memory[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // } 1C56 5B JUMPDEST 1C57 83 DUP4 1C58 5B JUMPDEST 1C59 90 SWAP1 1C5A 50 POP 1C5B 60 PUSH1 0x00 1C5D 80 DUP1 1C5E 83 DUP4 1C5F 60 PUSH1 0x80 1C61 01 ADD 1C62 51 MLOAD 1C63 15 ISZERO 1C64 61 PUSH2 0x1ca0 1C67 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1C59 stack[-1] = stack[-4] // @1C5B stack[0] = 0x00 // @1C5D stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ca0, if !memory[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] label_1C68: // Incoming jump from 0x1C67, if not !memory[0x80 + stack[-3]:0x80 + stack[-3] + 0x20] // Incoming jump from 0x1C67, if not !memory[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // Inputs[3] // { // @1C6A stack[-4] // @1C6C memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] // @1C6E memory[stack[-4]:stack[-4] + 0x20] // } 1C68 60 PUSH1 0x60 1C6A 84 DUP5 1C6B 01 ADD 1C6C 51 MLOAD 1C6D 84 DUP5 1C6E 51 MLOAD 1C6F 61 PUSH2 0x1c81 1C72 91 SWAP2 1C73 60 PUSH1 0x01 1C75 60 PUSH1 0x01 1C77 60 PUSH1 0xf8 1C79 1B SHL 1C7A 03 SUB 1C7B 16 AND 1C7C 90 SWAP1 1C7D 61 PUSH2 0x3854 1C80 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C72 stack[0] = 0x1c81 // @1C7C stack[1] = (0x01 << 0xf8) - 0x01 & memory[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] // @1C7C stack[2] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3854, returns to 0x1C81 label_1C81: // Incoming return from call to 0x3854 at 0x1C80 // Inputs[3] // { // @1C82 stack[-1] // @1C82 stack[-3] // @1C89 storage[0x13] // } 1C81 5B JUMPDEST 1C82 91 SWAP2 1C83 50 POP 1C84 61 PUSH2 0x1c8c 1C87 60 PUSH1 0x13 1C89 54 SLOAD 1C8A 90 SWAP1 1C8B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1C82 stack[-3] = stack[-1] // @1C8A stack[-1] = storage[0x13] // } // Block ends with unconditional jump to 0x1c8c label_1C8C: // Incoming jump from 0x1C8B // Inputs[2] // { // @1C8F storage[0x11] // @1C93 stack[-1] // } 1C8C 5B JUMPDEST 1C8D 60 PUSH1 0x11 1C8F 54 SLOAD 1C90 61 PUSH2 0x1c99 1C93 91 SWAP2 1C94 90 SWAP1 1C95 61 PUSH2 0x3854 1C98 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C93 stack[-1] = 0x1c99 // @1C94 stack[1] = storage[0x11] // @1C94 stack[0] = stack[-1] // } // Block ends with call to 0x3854, returns to 0x1C99 label_1C99: // Incoming return from call to 0x3854 at 0x1C98 // Inputs[2] // { // @1C9A stack[-1] // @1C9A stack[-2] // } 1C99 5B JUMPDEST 1C9A 90 SWAP1 1C9B 50 POP 1C9C 61 PUSH2 0x1cb0 1C9F 56 *JUMP // Stack delta = -1 // Outputs[1] { @1C9A stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x1cb0 label_1CA0: // Incoming jump from 0x1C67, if !memory[0x80 + stack[-3]:0x80 + stack[-3] + 0x20] // Incoming jump from 0x1C67, if !memory[0x80 + stack[-2]:0x80 + stack[-2] + 0x20] // Inputs[4] // { // @1CA1 stack[-4] // @1CA2 memory[stack[-4]:stack[-4] + 0x20] // @1CA3 stack[-2] // @1CAA storage[0x11] // } 1CA0 5B JUMPDEST 1CA1 83 DUP4 1CA2 51 MLOAD 1CA3 91 SWAP2 1CA4 50 POP 1CA5 61 PUSH2 0x1cad 1CA8 60 PUSH1 0x11 1CAA 54 SLOAD 1CAB 90 SWAP1 1CAC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1CA3 stack[-2] = memory[stack[-4]:stack[-4] + 0x20] // @1CAB stack[0] = storage[0x11] // } // Block ends with unconditional jump to 0x1cad label_1CAD: // Incoming jump from 0x1CAC // Inputs[4] // { // @1CAE stack[-2] // @1CAE stack[-1] // @1CB4 stack[-4] // @1CB9 stack[-3] // } 1CAD 5B JUMPDEST 1CAE 90 SWAP1 1CAF 50 POP 1CB0 5B JUMPDEST 1CB1 61 PUSH2 0x1cbe 1CB4 83 DUP4 1CB5 61 PUSH2 0x1173 1CB8 83 DUP4 1CB9 85 DUP6 1CBA 61 PUSH2 0x3854 1CBD 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1CAE stack[-2] = stack[-1] // @1CB1 stack[-1] = 0x1cbe // @1CB4 stack[0] = stack[-4] // @1CB5 stack[1] = 0x1173 // @1CB8 stack[2] = stack[-1] // @1CB9 stack[3] = stack[-3] // } // Block ends with call to 0x3854, returns to 0x1173 label_1CBE: // Incoming return from call to 0x1173 at 0x1CBD // Incoming return from call to 0x1173 at 0x1CBD // Inputs[2] // { // @1CBF stack[-1] // @1CBF stack[-4] // } 1CBE 5B JUMPDEST 1CBF 92 SWAP3 1CC0 50 POP 1CC1 60 PUSH1 0x00 1CC3 83 DUP4 1CC4 11 GT 1CC5 61 PUSH2 0x1d03 1CC8 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1CBF stack[-4] = stack[-1] } // Block ends with conditional jump to 0x1d03, if stack[-1] > 0x00 label_1CC9: // Incoming jump from 0x1CC8, if not stack[-1] > 0x00 // Inputs[1] { @1CCB memory[0x40:0x60] } 1CC9 60 PUSH1 0x40 1CCB 51 MLOAD 1CCC 62 PUSH3 0x461bcd 1CD0 60 PUSH1 0xe5 1CD2 1B SHL 1CD3 81 DUP2 1CD4 52 MSTORE 1CD5 60 PUSH1 0x20 1CD7 60 PUSH1 0x04 1CD9 82 DUP3 1CDA 01 ADD 1CDB 52 MSTORE 1CDC 60 PUSH1 0x10 1CDE 60 PUSH1 0x24 1CE0 82 DUP3 1CE1 01 ADD 1CE2 52 MSTORE 1CE3 6F PUSH16 0x14d95b1b195c8e8814dbdb19081bdd5d 1CF4 60 PUSH1 0x82 1CF6 1B SHL 1CF7 60 PUSH1 0x44 1CF9 82 DUP3 1CFA 01 ADD 1CFB 52 MSTORE 1CFC 60 PUSH1 0x64 1CFE 01 ADD 1CFF 61 PUSH2 0x0807 1D02 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1CD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1CDB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1CE2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1CFB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x14d95b1b195c8e8814dbdb19081bdd5d << 0x82 // @1CFE stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_1D03: // Incoming jump from 0x1CC8, if stack[-1] > 0x00 // Inputs[2] // { // @1D06 stack[-4] // @1D08 memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1D03 5B JUMPDEST 1D04 60 PUSH1 0x20 1D06 84 DUP5 1D07 01 ADD 1D08 51 MLOAD 1D09 15 ISZERO 1D0A 61 PUSH2 0x1e5f 1D0D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e5f, if !memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1D0E: // Incoming jump from 0x1D0D, if not !memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[3] // { // @1D0E msg.sender // @1D17 stack[-7] // @1D20 tx.origin // } 1D0E 33 CALLER 1D0F 60 PUSH1 0x01 1D11 60 PUSH1 0x01 1D13 60 PUSH1 0xa0 1D15 1B SHL 1D16 03 SUB 1D17 88 DUP9 1D18 16 AND 1D19 81 DUP2 1D1A 14 EQ 1D1B 15 ISZERO 1D1C 90 SWAP1 1D1D 60 PUSH1 0x00 1D1F 90 SWAP1 1D20 32 ORIGIN 1D21 14 EQ 1D22 80 DUP1 1D23 15 ISZERO 1D24 90 SWAP1 1D25 61 PUSH2 0x1d37 1D28 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D1C stack[0] = !(msg.sender == stack[-7] & (0x01 << 0xa0) - 0x01) // @1D1F stack[1] = 0x00 // @1D24 stack[2] = !(tx.origin == msg.sender) // } // Block ends with conditional jump to 0x1d37, if tx.origin == msg.sender label_1D29: // Incoming jump from 0x1D28, if not tx.origin == msg.sender // Inputs[5] // { // @1D2A tx.origin // @1D33 stack[-10] // @1D38 stack[-2] // @1D3D stack[-6] // @1D41 memory[0x40:0x60] // } 1D29 50 POP 1D2A 32 ORIGIN 1D2B 60 PUSH1 0x01 1D2D 60 PUSH1 0x01 1D2F 60 PUSH1 0xa0 1D31 1B SHL 1D32 03 SUB 1D33 8A DUP11 1D34 16 AND 1D35 14 EQ 1D36 15 ISZERO 1D37 5B JUMPDEST 1D38 90 SWAP1 1D39 50 POP 1D3A 61 PUSH2 0x1d67 1D3D 85 DUP6 1D3E 8A DUP11 1D3F 60 PUSH1 0x40 1D41 51 MLOAD 1D42 80 DUP1 1D43 60 PUSH1 0x40 1D45 01 ADD 1D46 60 PUSH1 0x40 1D48 52 MSTORE 1D49 80 DUP1 1D4A 60 PUSH1 0x0b 1D4C 81 DUP2 1D4D 52 MSTORE 1D4E 60 PUSH1 0x20 1D50 01 ADD 1D51 6A PUSH11 0x109d5e595c881b1a5b5a5d 1D5D 60 PUSH1 0xaa 1D5F 1B SHL 1D60 81 DUP2 1D61 52 MSTORE 1D62 50 POP 1D63 61 PUSH2 0x24aa 1D66 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @1D38 stack[-2] = !(stack[-10] & (0x01 << 0xa0) - 0x01 == tx.origin) // @1D3A stack[-1] = 0x1d67 // @1D3D stack[0] = stack[-6] // @1D3E stack[1] = stack[-10] // @1D41 stack[2] = memory[0x40:0x60] // @1D48 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1D4D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0b // @1D61 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x109d5e595c881b1a5b5a5d << 0xaa // } // Block ends with call to 0x24aa, returns to 0x1D67 label_1D67: // Incoming return from call to 0x24AA at 0x1D66 // Incoming return from call to 0x24AA at 0x1D66 // Inputs[3] // { // @1D68 stack[-6] // @1D68 stack[-1] // @1D6A stack[-3] // } 1D67 5B JUMPDEST 1D68 94 SWAP5 1D69 50 POP 1D6A 81 DUP2 1D6B 15 ISZERO 1D6C 61 PUSH2 0x1da1 1D6F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1D68 stack[-6] = stack[-1] } // Block ends with conditional jump to 0x1da1, if !stack[-3] label_1D70: // Incoming jump from 0x1D6F, if not !stack[-3] // Inputs[3] // { // @1D73 stack[-5] // @1D74 msg.sender // @1D77 memory[0x40:0x60] // } 1D70 61 PUSH2 0x1d9e 1D73 85 DUP6 1D74 33 CALLER 1D75 60 PUSH1 0x40 1D77 51 MLOAD 1D78 80 DUP1 1D79 60 PUSH1 0x40 1D7B 01 ADD 1D7C 60 PUSH1 0x40 1D7E 52 MSTORE 1D7F 80 DUP1 1D80 60 PUSH1 0x0c 1D82 81 DUP2 1D83 52 MSTORE 1D84 60 PUSH1 0x20 1D86 01 ADD 1D87 6B PUSH12 0x14d95b99195c881b1a5b5a5d 1D94 60 PUSH1 0xa2 1D96 1B SHL 1D97 81 DUP2 1D98 52 MSTORE 1D99 50 POP 1D9A 61 PUSH2 0x24aa 1D9D 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @1D70 stack[0] = 0x1d9e // @1D73 stack[1] = stack[-5] // @1D74 stack[2] = msg.sender // @1D77 stack[3] = memory[0x40:0x60] // @1D7E memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1D83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0c // @1D98 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x14d95b99195c881b1a5b5a5d << 0xa2 // } // Block ends with call to 0x24aa, returns to 0x1D9E label_1D9E: // Incoming return from call to 0x24AA at 0x1D9D // Inputs[2] // { // @1D9F stack[-6] // @1D9F stack[-1] // } 1D9E 5B JUMPDEST 1D9F 94 SWAP5 1DA0 50 POP // Stack delta = -1 // Outputs[1] { @1D9F stack[-6] = stack[-1] } // Block continues label_1DA1: // Incoming jump from 0x1DA0 // Incoming jump from 0x1D6F, if !stack[-3] // Inputs[1] { @1DA2 stack[-1] } 1DA1 5B JUMPDEST 1DA2 80 DUP1 1DA3 15 ISZERO 1DA4 61 PUSH2 0x1dd9 1DA7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1dd9, if !stack[-1] label_1DA8: // Incoming jump from 0x1DA7, if not !stack[-1] // Inputs[3] // { // @1DAB stack[-5] // @1DAC tx.origin // @1DAF memory[0x40:0x60] // } 1DA8 61 PUSH2 0x1dd6 1DAB 85 DUP6 1DAC 32 ORIGIN 1DAD 60 PUSH1 0x40 1DAF 51 MLOAD 1DB0 80 DUP1 1DB1 60 PUSH1 0x40 1DB3 01 ADD 1DB4 60 PUSH1 0x40 1DB6 52 MSTORE 1DB7 80 DUP1 1DB8 60 PUSH1 0x0c 1DBA 81 DUP2 1DBB 52 MSTORE 1DBC 60 PUSH1 0x20 1DBE 01 ADD 1DBF 6B PUSH12 0x13dc9a59da5b881b1a5b5a5d 1DCC 60 PUSH1 0xa2 1DCE 1B SHL 1DCF 81 DUP2 1DD0 52 MSTORE 1DD1 50 POP 1DD2 61 PUSH2 0x24aa 1DD5 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @1DA8 stack[0] = 0x1dd6 // @1DAB stack[1] = stack[-5] // @1DAC stack[2] = tx.origin // @1DAF stack[3] = memory[0x40:0x60] // @1DB6 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1DBB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0c // @1DD0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x13dc9a59da5b881b1a5b5a5d << 0xa2 // } // Block ends with call to 0x24aa, returns to 0x1DD6 label_1DD6: // Incoming return from call to 0x24AA at 0x1DD5 // Inputs[2] // { // @1DD7 stack[-1] // @1DD7 stack[-6] // } 1DD6 5B JUMPDEST 1DD7 94 SWAP5 1DD8 50 POP // Stack delta = -1 // Outputs[1] { @1DD7 stack[-6] = stack[-1] } // Block continues label_1DD9: // Incoming jump from 0x1DA7, if !stack[-1] // Incoming jump from 0x1DD8 // Inputs[4] // { // @1DE2 stack[-9] // @1DF1 memory[0x00:0x40] // @1DF3 storage[keccak256(memory[0x00:0x40])] // @1DF4 stack[-5] // } 1DD9 5B JUMPDEST 1DDA 60 PUSH1 0x01 1DDC 60 PUSH1 0x01 1DDE 60 PUSH1 0xa0 1DE0 1B SHL 1DE1 03 SUB 1DE2 89 DUP10 1DE3 16 AND 1DE4 60 PUSH1 0x00 1DE6 90 SWAP1 1DE7 81 DUP2 1DE8 52 MSTORE 1DE9 60 PUSH1 0x12 1DEB 60 PUSH1 0x20 1DED 52 MSTORE 1DEE 60 PUSH1 0x40 1DF0 81 DUP2 1DF1 20 SHA3 1DF2 80 DUP1 1DF3 54 SLOAD 1DF4 87 DUP8 1DF5 92 SWAP3 1DF6 90 SWAP1 1DF7 61 PUSH2 0x1e01 1DFA 90 SWAP1 1DFB 84 DUP5 1DFC 90 SWAP1 1DFD 61 PUSH2 0x38b0 1E00 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1DE8 memory[0x00:0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @1DED memory[0x20:0x40] = 0x12 // @1DF1 stack[1] = keccak256(memory[0x00:0x40]) // @1DF5 stack[0] = stack[-5] // @1DF6 stack[2] = 0x00 // @1DFA stack[3] = 0x1e01 // @1DFC stack[4] = stack[-5] // @1DFC stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x38b0, returns to 0x1E01 label_1E01: // Incoming return from call to 0x38B0 at 0x1E00 // Inputs[4] // { // @1E02 stack[-2] // @1E02 stack[-1] // @1E03 stack[-3] // @1E07 stack[-6] // } 1E01 5B JUMPDEST 1E02 90 SWAP1 1E03 91 SWAP2 1E04 55 SSTORE 1E05 50 POP 1E06 50 POP 1E07 81 DUP2 1E08 15 ISZERO 1E09 61 PUSH2 0x1e31 1E0C 57 *JUMPI // Stack delta = -4 // Outputs[1] { @1E04 storage[stack[-3]] = stack[-1] } // Block ends with conditional jump to 0x1e31, if !stack[-6] label_1E0D: // Incoming jump from 0x1E0C, if not !stack[-6] // Inputs[4] // { // @1E0D msg.sender // @1E1B memory[0x00:0x40] // @1E1D storage[keccak256(memory[0x00:0x40])] // @1E1E stack[-5] // } 1E0D 33 CALLER 1E0E 60 PUSH1 0x00 1E10 90 SWAP1 1E11 81 DUP2 1E12 52 MSTORE 1E13 60 PUSH1 0x12 1E15 60 PUSH1 0x20 1E17 52 MSTORE 1E18 60 PUSH1 0x40 1E1A 81 DUP2 1E1B 20 SHA3 1E1C 80 DUP1 1E1D 54 SLOAD 1E1E 87 DUP8 1E1F 92 SWAP3 1E20 90 SWAP1 1E21 61 PUSH2 0x1e2b 1E24 90 SWAP1 1E25 84 DUP5 1E26 90 SWAP1 1E27 61 PUSH2 0x38b0 1E2A 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1E12 memory[0x00:0x20] = msg.sender // @1E17 memory[0x20:0x40] = 0x12 // @1E1B stack[1] = keccak256(memory[0x00:0x40]) // @1E1F stack[0] = stack[-5] // @1E20 stack[2] = 0x00 // @1E24 stack[3] = 0x1e2b // @1E26 stack[4] = stack[-5] // @1E26 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x38b0, returns to 0x1E2B label_1E2B: // Incoming return from call to 0x38B0 at 0x1E2A // Inputs[3] // { // @1E2C stack[-1] // @1E2C stack[-2] // @1E2D stack[-3] // } 1E2B 5B JUMPDEST 1E2C 90 SWAP1 1E2D 91 SWAP2 1E2E 55 SSTORE 1E2F 50 POP 1E30 50 POP // Stack delta = -4 // Outputs[1] { @1E2E storage[stack[-3]] = stack[-1] } // Block continues label_1E31: // Incoming jump from 0x1E30 // Incoming jump from 0x1E0C, if !stack[-6] // Inputs[1] { @1E32 stack[-1] } 1E31 5B JUMPDEST 1E32 80 DUP1 1E33 15 ISZERO 1E34 61 PUSH2 0x1e5c 1E37 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e5c, if !stack[-1] label_1E38: // Incoming jump from 0x1E37, if not !stack[-1] // Inputs[4] // { // @1E38 tx.origin // @1E46 memory[0x00:0x40] // @1E48 storage[keccak256(memory[0x00:0x40])] // @1E49 stack[-5] // } 1E38 32 ORIGIN 1E39 60 PUSH1 0x00 1E3B 90 SWAP1 1E3C 81 DUP2 1E3D 52 MSTORE 1E3E 60 PUSH1 0x12 1E40 60 PUSH1 0x20 1E42 52 MSTORE 1E43 60 PUSH1 0x40 1E45 81 DUP2 1E46 20 SHA3 1E47 80 DUP1 1E48 54 SLOAD 1E49 87 DUP8 1E4A 92 SWAP3 1E4B 90 SWAP1 1E4C 61 PUSH2 0x1e56 1E4F 90 SWAP1 1E50 84 DUP5 1E51 90 SWAP1 1E52 61 PUSH2 0x38b0 1E55 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1E3D memory[0x00:0x20] = tx.origin // @1E42 memory[0x20:0x40] = 0x12 // @1E46 stack[1] = keccak256(memory[0x00:0x40]) // @1E4A stack[0] = stack[-5] // @1E4B stack[2] = 0x00 // @1E4F stack[3] = 0x1e56 // @1E51 stack[4] = stack[-5] // @1E51 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x38b0, returns to 0x1E56 label_1E56: // Incoming return from call to 0x38B0 at 0x1E55 // Inputs[3] // { // @1E57 stack[-2] // @1E57 stack[-1] // @1E58 stack[-3] // } 1E56 5B JUMPDEST 1E57 90 SWAP1 1E58 91 SWAP2 1E59 55 SSTORE 1E5A 50 POP 1E5B 50 POP // Stack delta = -4 // Outputs[1] { @1E59 storage[stack[-3]] = stack[-1] } // Block continues label_1E5C: // Incoming jump from 0x1E37, if !stack[-1] // Incoming jump from 0x1E5B 1E5C 5B JUMPDEST 1E5D 50 POP 1E5E 50 POP // Stack delta = -2 // Block continues label_1E5F: // Incoming jump from 0x1E5E // Incoming jump from 0x1D0D, if !memory[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @1E65 stack[-3] // @1E66 stack[-5] // } 1E5F 5B JUMPDEST 1E60 60 PUSH1 0x00 1E62 61 PUSH2 0x1e6b 1E65 84 DUP5 1E66 87 DUP8 1E67 61 PUSH2 0x0e23 1E6A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E60 stack[0] = 0x00 // @1E62 stack[1] = 0x1e6b // @1E65 stack[2] = stack[-3] // @1E66 stack[3] = stack[-5] // } // Block ends with call to 0x0e23, returns to 0x1E6B label_1E6B: // Incoming return from call to 0x0E23 at 0x1E6A // Inputs[3] // { // @1E6C stack[-1] // @1E6C stack[-2] // @1E6F msg.value // } 1E6B 5B JUMPDEST 1E6C 90 SWAP1 1E6D 50 POP 1E6E 80 DUP1 1E6F 34 CALLVALUE 1E70 10 LT 1E71 15 ISZERO 1E72 61 PUSH2 0x1ec1 1E75 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1E6C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1ec1, if !(msg.value < stack[-1]) label_1E76: // Incoming jump from 0x1E75, if not !(msg.value < stack[-1]) // Inputs[1] { @1E81 stack[-1] } 1E76 61 PUSH2 0x1e8b 1E79 61 PUSH2 0x1e86 1E7C 63 PUSH4 0x3b9aca00 1E81 83 DUP4 1E82 61 PUSH2 0x3816 1E85 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E76 stack[0] = 0x1e8b // @1E79 stack[1] = 0x1e86 // @1E7C stack[2] = 0x3b9aca00 // @1E81 stack[3] = stack[-1] // } // Block ends with call to 0x3816, returns to 0x1E86 label_1E86: // Incoming return from call to 0x3816 at 0x1E85 1E86 5B JUMPDEST 1E87 61 PUSH2 0x2178 1E8A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2178 label_1E8B: // Incoming return from call to 0x1E86 at 0x1E85 // Inputs[2] // { // @1E8E memory[0x40:0x60] // @1E95 stack[-1] // } 1E8B 5B JUMPDEST 1E8C 60 PUSH1 0x40 1E8E 51 MLOAD 1E8F 60 PUSH1 0x20 1E91 01 ADD 1E92 61 PUSH2 0x1e9b 1E95 91 SWAP2 1E96 90 SWAP1 1E97 61 PUSH2 0x38c8 1E9A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1E95 stack[-1] = 0x1e9b // @1E96 stack[1] = 0x20 + memory[0x40:0x60] // @1E96 stack[0] = stack[-1] // } // Block ends with call to 0x38c8, returns to 0x1E9B label_1E9B: // Incoming return from call to 0x38C8 at 0x1E9A // Incoming return from call to 0x3A2B at 0x24E8 // Inputs[2] // { // @1E9F memory[0x40:0x60] // @1EA4 stack[-1] // } 1E9B 5B JUMPDEST 1E9C 60 PUSH1 0x40 1E9E 80 DUP1 1E9F 51 MLOAD 1EA0 60 PUSH1 0x1f 1EA2 19 NOT 1EA3 81 DUP2 1EA4 84 DUP5 1EA5 03 SUB 1EA6 01 ADD 1EA7 81 DUP2 1EA8 52 MSTORE 1EA9 90 SWAP1 1EAA 82 DUP3 1EAB 90 SWAP1 1EAC 52 MSTORE 1EAD 62 PUSH3 0x461bcd 1EB1 60 PUSH1 0xe5 1EB3 1B SHL 1EB4 82 DUP3 1EB5 52 MSTORE 1EB6 61 PUSH2 0x0807 1EB9 91 SWAP2 1EBA 60 PUSH1 0x04 1EBC 01 ADD 1EBD 61 PUSH2 0x32cb 1EC0 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1EA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + ~0x1f // @1EA9 stack[0] = memory[0x40:0x60] // @1EAC memory[0x40:0x60] = stack[-1] // @1EB5 memory[stack[-1]:stack[-1] + 0x20] = 0x461bcd << 0xe5 // @1EB9 stack[-1] = 0x0807 // @1EBC stack[1] = 0x04 + stack[-1] // } // Block ends with unconditional jump to 0x32cb label_1EC1: // Incoming jump from 0x1E75, if !(msg.value < stack[-1]) // Inputs[2] // { // @1EC5 stack[-8] // @1EC6 stack[-4] // } 1EC1 5B JUMPDEST 1EC2 61 PUSH2 0x1ecd 1EC5 88 DUP9 1EC6 85 DUP6 1EC7 60 PUSH1 0x00 1EC9 61 PUSH2 0x2147 1ECC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1EC2 stack[0] = 0x1ecd // @1EC5 stack[1] = stack[-8] // @1EC6 stack[2] = stack[-4] // @1EC7 stack[3] = 0x00 // } // Block ends with unconditional jump to 0x2147 1ECD 5B JUMPDEST 1ECE 61 PUSH2 0x1ed8 1ED1 60 PUSH1 0x11 1ED3 85 DUP6 1ED4 61 PUSH2 0x2151 1ED7 56 *JUMP 1ED8 5B JUMPDEST 1ED9 84 DUP5 1EDA 51 MLOAD 1EDB 60 PUSH1 0x11 1EDD 54 SLOAD 1EDE 11 GT 1EDF 15 ISZERO 1EE0 61 PUSH2 0x1eeb 1EE3 57 *JUMPI 1EE4 61 PUSH2 0x1eeb 1EE7 61 PUSH2 0x386b 1EEA 56 *JUMP 1EEB 5B JUMPDEST 1EEC 80 DUP1 1EED 15 ISZERO 1EEE 61 PUSH2 0x1f50 1EF1 57 *JUMPI 1EF2 60 PUSH1 0x10 1EF4 54 SLOAD 1EF5 61 PUSH2 0x1f07 1EF8 90 SWAP1 1EF9 60 PUSH1 0x01 1EFB 60 PUSH1 0x01 1EFD 60 PUSH1 0xa0 1EFF 1B SHL 1F00 03 SUB 1F01 16 AND 1F02 82 DUP3 1F03 61 PUSH2 0x24fc 1F06 56 *JUMP 1F07 5B JUMPDEST 1F08 60 PUSH1 0x10 1F0A 54 SLOAD 1F0B 60 PUSH1 0x40 1F0D 80 DUP1 1F0E 51 MLOAD 1F0F 86 DUP7 1F10 81 DUP2 1F11 52 MSTORE 1F12 60 PUSH1 0x20 1F14 81 DUP2 1F15 01 ADD 1F16 84 DUP5 1F17 90 SWAP1 1F18 52 MSTORE 1F19 60 PUSH1 0x01 1F1B 60 PUSH1 0x01 1F1D 60 PUSH1 0xa0 1F1F 1B SHL 1F20 03 SUB 1F21 90 SWAP1 1F22 92 SWAP3 1F23 16 AND 1F24 91 SWAP2 1F25 7F PUSH32 0x01f51b99bd1c3cca301836178e5dee13aadfe44eff06dc3ddcbf3c9d058454f8 1F46 91 SWAP2 1F47 01 ADD 1F48 60 PUSH1 0x40 1F4A 51 MLOAD 1F4B 80 DUP1 1F4C 91 SWAP2 1F4D 03 SUB 1F4E 90 SWAP1 1F4F A2 LOG2 1F50 5B JUMPDEST 1F51 80 DUP1 1F52 34 CALLVALUE 1F53 11 GT 1F54 15 ISZERO 1F55 61 PUSH2 0x2028 1F58 57 *JUMPI 1F59 33 CALLER 1F5A 60 PUSH1 0x00 1F5C 61 PUSH2 0x1f65 1F5F 83 DUP4 1F60 34 CALLVALUE 1F61 61 PUSH2 0x3854 1F64 56 *JUMP 1F65 5B JUMPDEST 1F66 90 SWAP1 1F67 50 POP 1F68 60 PUSH1 0x00 1F6A 80 DUP1 1F6B 83 DUP4 1F6C 60 PUSH1 0x01 1F6E 60 PUSH1 0x01 1F70 60 PUSH1 0xa0 1F72 1B SHL 1F73 03 SUB 1F74 16 AND 1F75 83 DUP4 1F76 60 PUSH1 0x40 1F78 51 MLOAD 1F79 60 PUSH1 0x00 1F7B 60 PUSH1 0x40 1F7D 51 MLOAD 1F7E 80 DUP1 1F7F 83 DUP4 1F80 03 SUB 1F81 81 DUP2 1F82 85 DUP6 1F83 87 DUP8 1F84 5A GAS 1F85 F1 CALL 1F86 92 SWAP3 1F87 50 POP 1F88 50 POP 1F89 50 POP 1F8A 3D RETURNDATASIZE 1F8B 80 DUP1 1F8C 60 PUSH1 0x00 1F8E 81 DUP2 1F8F 14 EQ 1F90 61 PUSH2 0x1fb5 1F93 57 *JUMPI 1F94 60 PUSH1 0x40 1F96 51 MLOAD 1F97 91 SWAP2 1F98 50 POP 1F99 60 PUSH1 0x1f 1F9B 19 NOT 1F9C 60 PUSH1 0x3f 1F9E 3D RETURNDATASIZE 1F9F 01 ADD 1FA0 16 AND 1FA1 82 DUP3 1FA2 01 ADD 1FA3 60 PUSH1 0x40 1FA5 52 MSTORE 1FA6 3D RETURNDATASIZE 1FA7 82 DUP3 1FA8 52 MSTORE 1FA9 3D RETURNDATASIZE 1FAA 60 PUSH1 0x00 1FAC 60 PUSH1 0x20 1FAE 84 DUP5 1FAF 01 ADD 1FB0 3E RETURNDATACOPY 1FB1 61 PUSH2 0x1fba 1FB4 56 *JUMP 1FB5 5B JUMPDEST 1FB6 60 PUSH1 0x60 1FB8 91 SWAP2 1FB9 50 POP 1FBA 5B JUMPDEST 1FBB 50 POP 1FBC 91 SWAP2 1FBD 50 POP 1FBE 91 SWAP2 1FBF 50 POP 1FC0 81 DUP2 1FC1 81 DUP2 1FC2 90 SWAP1 1FC3 61 PUSH2 0x1fdf 1FC6 57 *JUMPI 1FC7 60 PUSH1 0x40 1FC9 51 MLOAD 1FCA 62 PUSH3 0x461bcd 1FCE 60 PUSH1 0xe5 1FD0 1B SHL 1FD1 81 DUP2 1FD2 52 MSTORE 1FD3 60 PUSH1 0x04 1FD5 01 ADD 1FD6 61 PUSH2 0x0807 1FD9 91 SWAP2 1FDA 90 SWAP1 1FDB 61 PUSH2 0x32cb 1FDE 56 *JUMP 1FDF 5B JUMPDEST 1FE0 50 POP 1FE1 83 DUP4 1FE2 60 PUSH1 0x01 1FE4 60 PUSH1 0x01 1FE6 60 PUSH1 0xa0 1FE8 1B SHL 1FE9 03 SUB 1FEA 16 AND 1FEB 7F PUSH32 0xbb28353e4598c3b9199101a66e0989549b659a59a54d2c27fbb183f1932c8e6d 200C 84 DUP5 200D 60 PUSH1 0x40 200F 51 MLOAD 2010 61 PUSH2 0x201b 2013 91 SWAP2 2014 81 DUP2 2015 52 MSTORE 2016 60 PUSH1 0x20 2018 01 ADD 2019 90 SWAP1 201A 56 *JUMP 201B 5B JUMPDEST 201C 60 PUSH1 0x40 201E 51 MLOAD 201F 80 DUP1 2020 91 SWAP2 2021 03 SUB 2022 90 SWAP1 2023 A2 LOG2 2024 50 POP 2025 50 POP 2026 50 POP 2027 50 POP 2028 5B JUMPDEST 2029 50 POP 202A 50 POP 202B 60 PUSH1 0x01 202D 60 PUSH1 0x0a 202F 55 SSTORE 2030 50 POP 2031 50 POP 2032 50 POP 2033 50 POP 2034 50 POP 2035 50 POP 2036 56 *JUMP label_2037: // Incoming call from 0x10C3, returns to 0x081A // Inputs[1] { @2038 msg.sender } 2037 5B JUMPDEST 2038 33 CALLER 2039 61 PUSH2 0x2041 203C 81 DUP2 203D 61 PUSH2 0x2615 2040 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2038 stack[0] = msg.sender // @2039 stack[1] = 0x2041 // @203C stack[2] = msg.sender // } // Block ends with call to 0x2615, returns to 0x2041 label_2041: // Incoming return from call to 0x2615 at 0x2040 // Inputs[2] // { // @204A stack[-1] // @204B stack[-4] // } 2041 5B JUMPDEST 2042 60 PUSH1 0x01 2044 60 PUSH1 0x01 2046 60 PUSH1 0xa0 2048 1B SHL 2049 03 SUB 204A 16 AND 204B 83 DUP4 204C 60 PUSH1 0x01 204E 60 PUSH1 0x01 2050 60 PUSH1 0xa0 2052 1B SHL 2053 03 SUB 2054 16 AND 2055 14 EQ 2056 15 ISZERO 2057 61 PUSH2 0x20f3 205A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x20f3, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_205B: // Incoming jump from 0x205A, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @205B stack[-2] } 205B 81 DUP2 205C 61 PUSH2 0x2066 205F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2066, if stack[-2] label_2060: // Incoming jump from 0x205F, if not stack[-2] 2060 60 PUSH1 0x01 2062 61 PUSH2 0x2069 2065 56 *JUMP // Stack delta = +1 // Outputs[1] { @2060 stack[0] = 0x01 } // Block ends with unconditional jump to 0x2069 label_2066: // Incoming jump from 0x205F, if stack[-2] // Inputs[3] // { // @2072 stack[-1] // @2081 memory[0x00:0x40] // @2083 storage[keccak256(memory[0x00:0x40])] // } 2066 5B JUMPDEST 2067 60 PUSH1 0x00 2069 5B JUMPDEST 206A 60 PUSH1 0x01 206C 60 PUSH1 0x01 206E 60 PUSH1 0xa0 2070 1B SHL 2071 03 SUB 2072 82 DUP3 2073 16 AND 2074 60 PUSH1 0x00 2076 90 SWAP1 2077 81 DUP2 2078 52 MSTORE 2079 60 PUSH1 0x07 207B 60 PUSH1 0x20 207D 52 MSTORE 207E 60 PUSH1 0x40 2080 90 SWAP1 2081 20 SHA3 2082 80 DUP1 2083 54 SLOAD 2084 60 PUSH1 0xff 2086 19 NOT 2087 16 AND 2088 60 PUSH1 0x01 208A 83 DUP4 208B 81 DUP2 208C 81 DUP2 208D 11 GT 208E 15 ISZERO 208F 61 PUSH2 0x209a 2092 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @2067 stack[0] = 0x00 // @2078 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @207D memory[0x20:0x40] = 0x07 // @2081 stack[1] = keccak256(memory[0x00:0x40]) // @2087 stack[2] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @2088 stack[3] = 0x01 // @208A stack[4] = 0x00 // } // Block ends with conditional jump to 0x209a, if !(0x00 > 0x01) label_2093: // Incoming jump from 0x2092, if not !(stack[-1] > 0x01) // Incoming jump from 0x2092, if not !(0x00 > 0x01) 2093 61 PUSH2 0x209a 2096 61 PUSH2 0x390d 2099 56 *JUMP // Stack delta = +1 // Outputs[1] { @2093 stack[0] = 0x209a } // Block ends with unconditional jump to 0x390d label_209A: // Incoming jump from 0x2092, if !(stack[-1] > 0x01) // Incoming jump from 0x2092, if !(0x00 > 0x01) // Inputs[8] // { // @209B stack[-1] // @209B stack[-2] // @209C stack[-3] // @209D stack[-4] // @20A0 stack[-8] // @20AA stack[-6] // @20D5 stack[-7] // @20D8 memory[0x40:0x60] // } 209A 5B JUMPDEST 209B 02 MUL 209C 17 OR 209D 90 SWAP1 209E 55 SSTORE 209F 50 POP 20A0 82 DUP3 20A1 60 PUSH1 0x01 20A3 60 PUSH1 0x01 20A5 60 PUSH1 0xa0 20A7 1B SHL 20A8 03 SUB 20A9 16 AND 20AA 81 DUP2 20AB 60 PUSH1 0x01 20AD 60 PUSH1 0x01 20AF 60 PUSH1 0xa0 20B1 1B SHL 20B2 03 SUB 20B3 16 AND 20B4 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 20D5 84 DUP5 20D6 60 PUSH1 0x40 20D8 51 MLOAD 20D9 61 PUSH2 0x20e6 20DC 91 SWAP2 20DD 15 ISZERO 20DE 15 ISZERO 20DF 81 DUP2 20E0 52 MSTORE 20E1 60 PUSH1 0x20 20E3 01 ADD 20E4 90 SWAP1 20E5 56 *JUMP // Stack delta = -1 // Outputs[6] // { // @209E storage[stack[-4]] = stack[-1] * stack[-2] | stack[-3] // @20A9 stack[-5] = (0x01 << 0xa0) - 0x01 & stack[-8] // @20B3 stack[-4] = (0x01 << 0xa0) - 0x01 & stack[-6] // @20B4 stack[-3] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @20E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-7] // @20E4 stack[-2] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x20e6 label_20E6: // Incoming jump from 0x2832 // Incoming jump from 0x20E5 // Inputs[7] // { // @20E9 memory[0x40:0x60] // @20EB stack[-1] // @20EE memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @20EE stack[-2] // @20EE stack[-3] // @20EE stack[-4] // @20F2 stack[-8] // } 20E6 5B JUMPDEST 20E7 60 PUSH1 0x40 20E9 51 MLOAD 20EA 80 DUP1 20EB 91 SWAP2 20EC 03 SUB 20ED 90 SWAP1 20EE A3 LOG3 20EF 50 POP 20F0 50 POP 20F1 50 POP 20F2 56 *JUMP // Stack delta = -8 // Outputs[1] { @20EE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-8] label_20F3: // Incoming jump from 0x205A, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @20F7 stack[-1] // @20F8 stack[-3] // @20F9 stack[-2] // } 20F3 5B JUMPDEST 20F4 61 PUSH2 0x0a56 20F7 81 DUP2 20F8 84 DUP5 20F9 84 DUP5 20FA 61 PUSH2 0x276c 20FD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20F4 stack[0] = 0x0a56 // @20F7 stack[1] = stack[-1] // @20F8 stack[2] = stack[-3] // @20F9 stack[3] = stack[-2] // } // Block ends with call to 0x276c, returns to 0x0A56 label_20FE: // Incoming jump from 0x10F5 // Inputs[3] // { // @2102 stack[-4] // @2103 stack[-3] // @2104 stack[-2] // } 20FE 5B JUMPDEST 20FF 61 PUSH2 0x2109 2102 84 DUP5 2103 84 DUP5 2104 84 DUP5 2105 61 PUSH2 0x1764 2108 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20FF stack[0] = 0x2109 // @2102 stack[1] = stack[-4] // @2103 stack[2] = stack[-3] // @2104 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1764 2109 5B JUMPDEST 210A 61 PUSH2 0x2115 210D 84 DUP5 210E 84 DUP5 210F 84 DUP5 2110 84 DUP5 2111 61 PUSH2 0x2833 2114 56 *JUMP 2115 5B JUMPDEST 2116 61 PUSH2 0x10f6 2119 57 *JUMPI 211A 60 PUSH1 0x40 211C 51 MLOAD 211D 62 PUSH3 0x461bcd 2121 60 PUSH1 0xe5 2123 1B SHL 2124 81 DUP2 2125 52 MSTORE 2126 60 PUSH1 0x04 2128 01 ADD 2129 61 PUSH2 0x0807 212C 90 SWAP1 212D 61 PUSH2 0x3923 2130 56 *JUMP label_2131: // Incoming call from 0x1C50, returns to 0x1C51 // Incoming call from 0x24F2, returns to 0x24F3 // Incoming jump from 0x1177 // Inputs[2] // { // @2134 stack[-1] // @2135 stack[-2] // } 2131 5B JUMPDEST 2132 60 PUSH1 0x00 2134 81 DUP2 2135 83 DUP4 2136 10 LT 2137 61 PUSH2 0x2140 213A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2132 stack[0] = 0x00 } // Block ends with conditional jump to 0x2140, if stack[-2] < stack[-1] label_213B: // Incoming jump from 0x213A, if not stack[-2] < stack[-1] // Inputs[1] { @213B stack[-2] } 213B 81 DUP2 213C 61 PUSH2 0x0e2f 213F 56 *JUMP // Stack delta = +1 // Outputs[1] { @213B stack[0] = stack[-2] } // Block ends with unconditional jump to 0x0e2f label_2140: // Incoming jump from 0x213A, if stack[-2] < stack[-1] // Inputs[3] // { // @2142 stack[-3] // @2142 stack[-2] // @2143 stack[-4] // } 2140 5B JUMPDEST 2141 50 POP 2142 90 SWAP1 2143 91 SWAP2 2144 90 SWAP1 2145 50 POP 2146 56 *JUMP // Stack delta = -3 // Outputs[1] { @2143 stack[-4] = stack[-3] } // Block ends with unconditional jump to stack[-4] label_2147: // Incoming jump from 0x1ECC // Incoming jump from 0x122A // Inputs[2] // { // @214B stack[-3] // @214C stack[-2] // } 2147 5B JUMPDEST 2148 61 PUSH2 0x0a56 214B 83 DUP4 214C 83 DUP4 214D 61 PUSH2 0x2931 2150 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2148 stack[0] = 0x0a56 // @214B stack[1] = stack[-3] // @214C stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x2931 label_2151: // Incoming call from 0x2BC9, returns to 0x1063 // Inputs[3] // { // @2152 stack[-1] // @2153 stack[-2] // @215B storage[0x00 + stack[-2]] // } 2151 5B JUMPDEST 2152 80 DUP1 2153 82 DUP3 2154 60 PUSH1 0x00 2156 01 ADD 2157 60 PUSH1 0x00 2159 82 DUP3 215A 82 DUP3 215B 54 SLOAD 215C 61 PUSH2 0x2165 215F 91 SWAP2 2160 90 SWAP1 2161 61 PUSH2 0x38b0 2164 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2152 stack[0] = stack[-1] // @2156 stack[1] = 0x00 + stack[-2] // @2157 stack[2] = 0x00 // @215F stack[3] = 0x2165 // @2160 stack[4] = stack[-1] // @2160 stack[5] = storage[0x00 + stack[-2]] // } // Block ends with call to 0x38b0, returns to 0x2165 label_2165: // Incoming return from call to 0x38B0 at 0x2164 // Inputs[4] // { // @2166 stack[-2] // @2166 stack[-1] // @2167 stack[-3] // @216D stack[-7] // } 2165 5B JUMPDEST 2166 90 SWAP1 2167 91 SWAP2 2168 55 SSTORE 2169 50 POP 216A 50 POP 216B 50 POP 216C 50 POP 216D 56 *JUMP // Stack delta = -7 // Outputs[1] { @2168 storage[stack[-3]] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_216E: // Incoming jump from 0x1328 216E 5B JUMPDEST 216F 60 PUSH1 0x60 2171 61 PUSH2 0x0ff4 2174 61 PUSH2 0x294b 2177 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @216F stack[0] = 0x60 // @2171 stack[1] = 0x0ff4 // } // Block ends with call to 0x294b, returns to 0x0FF4 label_2178: // Incoming jump from 0x1E8A // Incoming call from 0x2416, returns to 0x2417 // Inputs[1] { @217B stack[-1] } 2178 5B JUMPDEST 2179 60 PUSH1 0x60 217B 81 DUP2 217C 61 PUSH2 0x219c 217F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2179 stack[0] = 0x60 } // Block ends with conditional jump to 0x219c, if stack[-1] label_2180: // Incoming jump from 0x217F, if not stack[-1] // Inputs[2] // { // @2185 memory[0x40:0x60] // @219A stack[-3] // } 2180 50 POP 2181 50 POP 2182 60 PUSH1 0x40 2184 80 DUP1 2185 51 MLOAD 2186 80 DUP1 2187 82 DUP3 2188 01 ADD 2189 90 SWAP1 218A 91 SWAP2 218B 52 MSTORE 218C 60 PUSH1 0x01 218E 81 DUP2 218F 52 MSTORE 2190 60 PUSH1 0x03 2192 60 PUSH1 0xfc 2194 1B SHL 2195 60 PUSH1 0x20 2197 82 DUP3 2198 01 ADD 2199 52 MSTORE 219A 90 SWAP1 219B 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @218B memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @218F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @2199 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @219A stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_219C: // Incoming jump from 0x217F, if stack[-1] // Inputs[1] { @219D stack[-2] } 219C 5B JUMPDEST 219D 81 DUP2 219E 60 PUSH1 0x00 21A0 5B JUMPDEST 21A1 81 DUP2 21A2 15 ISZERO 21A3 61 PUSH2 0x21c6 21A6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @219D stack[0] = stack[-2] // @219E stack[1] = 0x00 // } // Block ends with conditional jump to 0x21c6, if !stack[-2] label_21A7: // Incoming jump from 0x21A6, if not !stack[-2] // Incoming jump from 0x21A6, if not !stack[-2] // Inputs[1] { @21A7 stack[-1] } 21A7 80 DUP1 21A8 61 PUSH2 0x21b0 21AB 81 DUP2 21AC 61 PUSH2 0x3975 21AF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21A7 stack[0] = stack[-1] // @21A8 stack[1] = 0x21b0 // @21AB stack[2] = stack[-1] // } // Block ends with call to 0x3975, returns to 0x21B0 label_21B0: // Incoming return from call to 0x3975 at 0x21AF // Inputs[4] // { // @21B1 stack[-1] // @21B1 stack[-3] // @21B6 stack[-2] // @21BA stack[-4] // } 21B0 5B JUMPDEST 21B1 91 SWAP2 21B2 50 POP 21B3 61 PUSH2 0x21bf 21B6 90 SWAP1 21B7 50 POP 21B8 60 PUSH1 0x0a 21BA 83 DUP4 21BB 61 PUSH2 0x3816 21BE 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @21B1 stack[-3] = stack[-1] // @21B6 stack[-2] = 0x21bf // @21B8 stack[-1] = 0x0a // @21BA stack[0] = stack[-4] // } // Block ends with call to 0x3816, returns to 0x21BF label_21BF: // Incoming return from call to 0x3816 at 0x21BE // Inputs[2] // { // @21C0 stack[-3] // @21C0 stack[-1] // } 21BF 5B JUMPDEST 21C0 91 SWAP2 21C1 50 POP 21C2 61 PUSH2 0x21a0 21C5 56 *JUMP // Stack delta = -1 // Outputs[1] { @21C0 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x21a0 label_21C6: // Incoming jump from 0x21A6, if !stack[-2] // Incoming jump from 0x21A6, if !stack[-2] // Inputs[1] { @21C9 stack[-1] } 21C6 5B JUMPDEST 21C7 60 PUSH1 0x00 21C9 81 DUP2 21CA 67 PUSH8 0xffffffffffffffff 21D3 81 DUP2 21D4 11 GT 21D5 15 ISZERO 21D6 61 PUSH2 0x21e1 21D9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21C7 stack[0] = 0x00 // @21C9 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x21e1, if !(stack[-1] > 0xffffffffffffffff) label_21DA: // Incoming jump from 0x21D9, if not !(stack[-1] > 0xffffffffffffffff) 21DA 61 PUSH2 0x21e1 21DD 61 PUSH2 0x33d3 21E0 56 *JUMP // Stack delta = +1 // Outputs[1] { @21DA stack[0] = 0x21e1 } // Block ends with unconditional jump to 0x33d3 label_21E1: // Incoming jump from 0x21D9, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @21E4 memory[0x40:0x60] // @21E5 stack[-1] // } 21E1 5B JUMPDEST 21E2 60 PUSH1 0x40 21E4 51 MLOAD 21E5 90 SWAP1 21E6 80 DUP1 21E7 82 DUP3 21E8 52 MSTORE 21E9 80 DUP1 21EA 60 PUSH1 0x1f 21EC 01 ADD 21ED 60 PUSH1 0x1f 21EF 19 NOT 21F0 16 AND 21F1 60 PUSH1 0x20 21F3 01 ADD 21F4 82 DUP3 21F5 01 ADD 21F6 60 PUSH1 0x40 21F8 52 MSTORE 21F9 80 DUP1 21FA 15 ISZERO 21FB 61 PUSH2 0x220b 21FE 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @21E5 stack[-1] = memory[0x40:0x60] // @21E5 stack[0] = stack[-1] // @21E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @21F8 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x220b, if !stack[-1] label_21FF: // Incoming jump from 0x21FE, if not !stack[-1] // Inputs[6] // { // @2201 stack[-2] // @2203 stack[-1] // @2205 msg.data.length // @2207 msg.data[msg.data.length:msg.data.length + stack[-1]] // @220D stack[-3] // @2210 stack[-7] // } 21FF 60 PUSH1 0x20 2201 82 DUP3 2202 01 ADD 2203 81 DUP2 2204 80 DUP1 2205 36 CALLDATASIZE 2206 83 DUP4 2207 37 CALLDATACOPY 2208 01 ADD 2209 90 SWAP1 220A 50 POP 220B 5B JUMPDEST 220C 50 POP 220D 90 SWAP1 220E 50 POP 220F 5B JUMPDEST 2210 84 DUP5 2211 15 ISZERO 2212 61 PUSH2 0x175c 2215 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2207 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @220D stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x175c, if !stack[-7] label_2216: // Incoming jump from 0x2215, if not !stack[-7] // Incoming jump from 0x2215, if not !stack[-7] // Incoming jump from 0x2215, if not !stack[-5] // Inputs[1] { @221B stack[-2] } 2216 61 PUSH2 0x2220 2219 60 PUSH1 0x01 221B 83 DUP4 221C 61 PUSH2 0x3854 221F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2216 stack[0] = 0x2220 // @2219 stack[1] = 0x01 // @221B stack[2] = stack[-2] // } // Block ends with call to 0x3854, returns to 0x2220 label_2220: // Incoming return from call to 0x3854 at 0x221F // Inputs[3] // { // @2221 stack[-3] // @2221 stack[-1] // @2228 stack[-6] // } 2220 5B JUMPDEST 2221 91 SWAP2 2222 50 POP 2223 61 PUSH2 0x222d 2226 60 PUSH1 0x0a 2228 86 DUP7 2229 61 PUSH2 0x3990 222C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2221 stack[-3] = stack[-1] // @2223 stack[-1] = 0x222d // @2226 stack[0] = 0x0a // @2228 stack[1] = stack[-6] // } // Block ends with call to 0x3990, returns to 0x222D label_222D: // Incoming return from call to 0x3990 at 0x222C // Inputs[1] { @2231 stack[-1] } 222D 5B JUMPDEST 222E 61 PUSH2 0x2238 2231 90 SWAP1 2232 60 PUSH1 0x30 2234 61 PUSH2 0x38b0 2237 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2231 stack[0] = stack[-1] // @2231 stack[-1] = 0x2238 // @2232 stack[1] = 0x30 // } // Block ends with call to 0x38b0, returns to 0x2238 label_2238: // Incoming return from call to 0x38B0 at 0x2237 // Inputs[4] // { // @223B stack[-1] // @223C stack[-2] // @223D stack[-3] // @223F memory[stack[-2]:stack[-2] + 0x20] // } 2238 5B JUMPDEST 2239 60 PUSH1 0xf8 223B 1B SHL 223C 81 DUP2 223D 83 DUP4 223E 81 DUP2 223F 51 MLOAD 2240 81 DUP2 2241 10 LT 2242 61 PUSH2 0x224d 2245 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @223B stack[-1] = stack[-1] << 0xf8 // @223C stack[0] = stack[-2] // @223D stack[1] = stack[-3] // } // Block ends with conditional jump to 0x224d, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_2246: // Incoming jump from 0x2245, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 2246 61 PUSH2 0x224d 2249 61 PUSH2 0x39a4 224C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2246 stack[0] = 0x224d } // Block ends with unconditional jump to 0x39a4 label_224D: // Incoming jump from 0x2245, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @2250 stack[-1] // @2251 stack[-2] // @2252 stack[-3] // @226A stack[-8] // } 224D 5B JUMPDEST 224E 60 PUSH1 0x20 2250 01 ADD 2251 01 ADD 2252 90 SWAP1 2253 60 PUSH1 0x01 2255 60 PUSH1 0x01 2257 60 PUSH1 0xf8 2259 1B SHL 225A 03 SUB 225B 19 NOT 225C 16 AND 225D 90 SWAP1 225E 81 DUP2 225F 60 PUSH1 0x00 2261 1A BYTE 2262 90 SWAP1 2263 53 MSTORE8 2264 50 POP 2265 61 PUSH2 0x226f 2268 60 PUSH1 0x0a 226A 86 DUP7 226B 61 PUSH2 0x3816 226E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2263 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @2265 stack[-3] = 0x226f // @2268 stack[-2] = 0x0a // @226A stack[-1] = stack[-8] // } // Block ends with call to 0x3816, returns to 0x226F label_226F: // Incoming return from call to 0x3816 at 0x226E // Inputs[2] // { // @2270 stack[-1] // @2270 stack[-6] // } 226F 5B JUMPDEST 2270 94 SWAP5 2271 50 POP 2272 61 PUSH2 0x220f 2275 56 *JUMP // Stack delta = -1 // Outputs[1] { @2270 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x220f label_2276: // Incoming call from 0x1413, returns to 0x0E2F // Inputs[5] // { // @2280 stack[-2] // @2292 memory[0x00:0x40] // @2294 stack[-1] // @229D memory[0x00:0x40] // @229E storage[keccak256(memory[0x00:0x40])] // } 2276 5B JUMPDEST 2277 60 PUSH1 0x01 2279 60 PUSH1 0x01 227B 60 PUSH1 0xa0 227D 1B SHL 227E 03 SUB 227F 80 DUP1 2280 83 DUP4 2281 16 AND 2282 60 PUSH1 0x00 2284 90 SWAP1 2285 81 DUP2 2286 52 MSTORE 2287 60 PUSH1 0x05 2289 60 PUSH1 0x20 228B 90 SWAP1 228C 81 DUP2 228D 52 MSTORE 228E 60 PUSH1 0x40 2290 80 DUP1 2291 83 DUP4 2292 20 SHA3 2293 93 SWAP4 2294 85 DUP6 2295 16 AND 2296 83 DUP4 2297 52 MSTORE 2298 92 SWAP3 2299 90 SWAP1 229A 52 MSTORE 229B 90 SWAP1 229C 81 DUP2 229D 20 SHA3 229E 54 SLOAD 229F 60 PUSH1 0xff 22A1 16 AND 22A2 15 ISZERO 22A3 61 PUSH2 0x22ae 22A6 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2286 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @228D memory[0x20:0x40] = 0x05 // @2297 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @229A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @229B stack[0] = 0x00 // } // Block ends with conditional jump to 0x22ae, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_22A7: // Incoming jump from 0x22A6, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) 22A7 50 POP 22A8 60 PUSH1 0x01 22AA 61 PUSH2 0x07d7 22AD 56 *JUMP // Stack delta = +0 // Outputs[1] { @22A8 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x07d7 label_22AE: // Incoming jump from 0x22A6, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @22B7 stack[-3] // @22C6 memory[0x00:0x40] // @22C7 storage[keccak256(memory[0x00:0x40])] // } 22AE 5B JUMPDEST 22AF 60 PUSH1 0x01 22B1 60 PUSH1 0x01 22B3 60 PUSH1 0xa0 22B5 1B SHL 22B6 03 SUB 22B7 83 DUP4 22B8 16 AND 22B9 60 PUSH1 0x00 22BB 90 SWAP1 22BC 81 DUP2 22BD 52 MSTORE 22BE 60 PUSH1 0x07 22C0 60 PUSH1 0x20 22C2 52 MSTORE 22C3 60 PUSH1 0x40 22C5 81 DUP2 22C6 20 SHA3 22C7 54 SLOAD 22C8 60 PUSH1 0xff 22CA 16 AND 22CB 60 PUSH1 0x01 22CD 81 DUP2 22CE 11 GT 22CF 15 ISZERO 22D0 61 PUSH2 0x22db 22D3 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @22BB stack[0] = 0x00 // @22BD memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @22C2 memory[0x20:0x40] = 0x07 // @22CA stack[1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x22db, if !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x01) label_22D4: // Incoming jump from 0x22D3, if not !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x01) 22D4 61 PUSH2 0x22db 22D7 61 PUSH2 0x390d 22DA 56 *JUMP // Stack delta = +1 // Outputs[1] { @22D4 stack[0] = 0x22db } // Block ends with unconditional jump to 0x390d label_22DB: // Incoming jump from 0x22D3, if !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x01) // Inputs[2] // { // @22DC stack[-2] // @22DC stack[-1] // } 22DB 5B JUMPDEST 22DC 14 EQ 22DD 80 DUP1 22DE 15 ISZERO 22DF 61 PUSH2 0x0e2f 22E2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @22DC stack[-2] = stack[-1] == stack[-2] } // Block ends with conditional jump to 0x0e2f, if !(stack[-1] == stack[-2]) label_22E3: // Incoming jump from 0x22E2, if not !(stack[-1] == stack[-2]) // Inputs[2] // { // @22E7 stack[-4] // @22E8 stack[-3] // } 22E3 50 POP 22E4 61 PUSH2 0x0e2f 22E7 83 DUP4 22E8 83 DUP4 22E9 61 PUSH2 0x295a 22EC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @22E4 stack[-1] = 0x0e2f // @22E7 stack[0] = stack[-4] // @22E8 stack[1] = stack[-3] // } // Block ends with call to 0x295a, returns to 0x0E2F label_22ED: // Incoming call from 0x1448, returns to 0x081A // Inputs[2] // { // @22F3 stack[-2] // @22FC stack[-1] // } 22ED 5B JUMPDEST 22EE 60 PUSH1 0x00 22F0 61 PUSH2 0x0e2f 22F3 83 DUP4 22F4 60 PUSH1 0x01 22F6 60 PUSH1 0x01 22F8 60 PUSH1 0xa0 22FA 1B SHL 22FB 03 SUB 22FC 84 DUP5 22FD 16 AND 22FE 61 PUSH2 0x2999 2301 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22EE stack[0] = 0x00 // @22F0 stack[1] = 0x0e2f // @22F3 stack[2] = stack[-2] // @22FD stack[3] = stack[-1] & (0x01 << 0xa0) - 0x01 // } // Block ends with call to 0x2999, returns to 0x0E2F label_2302: // Incoming call from 0x150C, returns to 0x07D7 // Inputs[1] { @2308 stack[-1] } 2302 5B JUMPDEST 2303 60 PUSH1 0x00 2305 61 PUSH2 0x07d7 2308 82 DUP3 2309 61 PUSH2 0x29e8 230C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2303 stack[0] = 0x00 // @2305 stack[1] = 0x07d7 // @2308 stack[2] = stack[-1] // } // Block ends with call to 0x29e8, returns to 0x07D7 label_230D: // Incoming call from 0x168C, returns to 0x0E2F // Inputs[4] // { // @2310 stack[-1] // @2315 stack[-2] // @231D memory[0x00:0x40] // @231E storage[keccak256(memory[0x00:0x40])] // } 230D 5B JUMPDEST 230E 60 PUSH1 0x00 2310 81 DUP2 2311 81 DUP2 2312 52 MSTORE 2313 60 PUSH1 0x01 2315 83 DUP4 2316 01 ADD 2317 60 PUSH1 0x20 2319 52 MSTORE 231A 60 PUSH1 0x40 231C 81 DUP2 231D 20 SHA3 231E 54 SLOAD 231F 80 DUP1 2320 15 ISZERO 2321 61 PUSH2 0x23f6 2324 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @230E stack[0] = 0x00 // @2312 memory[0x00:0x20] = stack[-1] // @2319 memory[0x20:0x40] = stack[-2] + 0x01 // @231E stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x23f6, if !storage[keccak256(memory[0x00:0x40])] label_2325: // Incoming jump from 0x2324, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @232C stack[-1] } 2325 60 PUSH1 0x00 2327 61 PUSH2 0x2331 232A 60 PUSH1 0x01 232C 83 DUP4 232D 61 PUSH2 0x3854 2330 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2325 stack[0] = 0x00 // @2327 stack[1] = 0x2331 // @232A stack[2] = 0x01 // @232C stack[3] = stack[-1] // } // Block ends with call to 0x3854, returns to 0x2331 label_2331: // Incoming return from call to 0x3854 at 0x2330 // Inputs[4] // { // @2332 stack[-6] // @2333 storage[stack[-6]] // @2334 stack[-1] // @2335 stack[-2] // } 2331 5B JUMPDEST 2332 85 DUP6 2333 54 SLOAD 2334 90 SWAP1 2335 91 SWAP2 2336 50 POP 2337 60 PUSH1 0x00 2339 90 SWAP1 233A 61 PUSH2 0x2345 233D 90 SWAP1 233E 60 PUSH1 0x01 2340 90 SWAP1 2341 61 PUSH2 0x3854 2344 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2335 stack[-2] = stack[-1] // @2339 stack[-1] = 0x00 // @233D stack[0] = 0x2345 // @2340 stack[1] = 0x01 // @2340 stack[2] = storage[stack[-6]] // } // Block ends with call to 0x3854, returns to 0x2345 label_2345: // Incoming return from call to 0x3854 at 0x2344 // Inputs[3] // { // @2346 stack[-2] // @2346 stack[-1] // @2348 stack[-3] // } 2345 5B JUMPDEST 2346 90 SWAP1 2347 50 POP 2348 81 DUP2 2349 81 DUP2 234A 14 EQ 234B 61 PUSH2 0x23aa 234E 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2346 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x23aa, if stack[-1] == stack[-3] label_234F: // Incoming jump from 0x234E, if not stack[-1] == stack[-3] // Inputs[3] // { // @2351 stack[-6] // @2355 stack[-1] // @2357 storage[0x00 + stack[-6]] // } 234F 60 PUSH1 0x00 2351 86 DUP7 2352 60 PUSH1 0x00 2354 01 ADD 2355 82 DUP3 2356 81 DUP2 2357 54 SLOAD 2358 81 DUP2 2359 10 LT 235A 61 PUSH2 0x2365 235D 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @234F stack[0] = 0x00 // @2354 stack[1] = 0x00 + stack[-6] // @2355 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x2365, if stack[-1] < storage[0x00 + stack[-6]] label_235E: // Incoming jump from 0x235D, if not stack[-1] < storage[0x00 + stack[-6]] 235E 61 PUSH2 0x2365 2361 61 PUSH2 0x39a4 2364 56 *JUMP // Stack delta = +1 // Outputs[1] { @235E stack[0] = 0x2365 } // Block ends with unconditional jump to 0x39a4 label_2365: // Incoming jump from 0x235D, if stack[-1] < storage[0x00 + stack[-6]] // Inputs[8] // { // @2366 stack[-2] // @2366 stack[-1] // @236E memory[0x00:0x20] // @2370 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2371 stack[-3] // @2374 stack[-9] // @2378 stack[-5] // @237A storage[0x00 + stack[-9]] // } 2365 5B JUMPDEST 2366 90 SWAP1 2367 60 PUSH1 0x00 2369 52 MSTORE 236A 60 PUSH1 0x20 236C 60 PUSH1 0x00 236E 20 SHA3 236F 01 ADD 2370 54 SLOAD 2371 90 SWAP1 2372 50 POP 2373 80 DUP1 2374 87 DUP8 2375 60 PUSH1 0x00 2377 01 ADD 2378 84 DUP5 2379 81 DUP2 237A 54 SLOAD 237B 81 DUP2 237C 10 LT 237D 61 PUSH2 0x2388 2380 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2369 memory[0x00:0x20] = stack[-2] // @2371 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2373 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2377 stack[-1] = 0x00 + stack[-9] // @2378 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x2388, if stack[-5] < storage[0x00 + stack[-9]] label_2381: // Incoming jump from 0x2380, if not stack[-5] < storage[0x00 + stack[-9]] 2381 61 PUSH2 0x2388 2384 61 PUSH2 0x39a4 2387 56 *JUMP // Stack delta = +1 // Outputs[1] { @2381 stack[0] = 0x2388 } // Block ends with unconditional jump to 0x39a4 label_2388: // Incoming jump from 0x2380, if stack[-5] < storage[0x00 + stack[-9]] // Inputs[8] // { // @238B stack[-2] // @2392 memory[0x00:0x20] // @2394 stack[-1] // @2396 stack[-3] // @239A stack[-4] // @239F stack[-10] // @23A6 memory[0x00:0x40] // @23A7 stack[-7] // } 2388 5B JUMPDEST 2389 60 PUSH1 0x00 238B 91 SWAP2 238C 82 DUP3 238D 52 MSTORE 238E 60 PUSH1 0x20 2390 80 DUP1 2391 83 DUP4 2392 20 SHA3 2393 90 SWAP1 2394 91 SWAP2 2395 01 ADD 2396 92 SWAP3 2397 90 SWAP1 2398 92 SWAP3 2399 55 SSTORE 239A 91 SWAP2 239B 82 DUP3 239C 52 MSTORE 239D 60 PUSH1 0x01 239F 88 DUP9 23A0 01 ADD 23A1 90 SWAP1 23A2 52 MSTORE 23A3 60 PUSH1 0x40 23A5 90 SWAP1 23A6 20 SHA3 23A7 83 DUP4 23A8 90 SWAP1 23A9 55 SSTORE // Stack delta = -4 // Outputs[5] // { // @238D memory[0x00:0x20] = stack[-2] // @2399 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @239C memory[0x00:0x20] = stack[-4] // @23A2 memory[0x20:0x40] = stack[-10] + 0x01 // @23A9 storage[keccak256(memory[0x00:0x40])] = stack[-7] // } // Block continues label_23AA: // Incoming jump from 0x23A9 // Incoming jump from 0x234E, if stack[-1] == stack[-3] // Inputs[2] // { // @23AB stack[-6] // @23AC storage[stack[-6]] // } 23AA 5B JUMPDEST 23AB 85 DUP6 23AC 54 SLOAD 23AD 86 DUP7 23AE 90 SWAP1 23AF 80 DUP1 23B0 61 PUSH2 0x23bb 23B3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23AE stack[0] = stack[-6] // @23AE stack[1] = storage[stack[-6]] // } // Block ends with conditional jump to 0x23bb, if storage[stack[-6]] label_23B4: // Incoming jump from 0x23B3, if not storage[stack[-6]] 23B4 61 PUSH2 0x23bb 23B7 61 PUSH2 0x39ba 23BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @23B4 stack[0] = 0x23bb } // Block ends with unconditional jump to 0x39ba label_23BB: // Incoming jump from 0x23B3, if storage[stack[-6]] // Inputs[7] // { // @23BE stack[-1] // @23C0 stack[-2] // @23CA memory[0x00:0x20] // @23D2 stack[-8] // @23D8 stack[-7] // @23E6 memory[0x00:0x40] // @23ED stack[-6] // } 23BB 5B JUMPDEST 23BC 60 PUSH1 0x01 23BE 90 SWAP1 23BF 03 SUB 23C0 81 DUP2 23C1 81 DUP2 23C2 90 SWAP1 23C3 60 PUSH1 0x00 23C5 52 MSTORE 23C6 60 PUSH1 0x20 23C8 60 PUSH1 0x00 23CA 20 SHA3 23CB 01 ADD 23CC 60 PUSH1 0x00 23CE 90 SWAP1 23CF 55 SSTORE 23D0 90 SWAP1 23D1 55 SSTORE 23D2 85 DUP6 23D3 60 PUSH1 0x01 23D5 01 ADD 23D6 60 PUSH1 0x00 23D8 86 DUP7 23D9 81 DUP2 23DA 52 MSTORE 23DB 60 PUSH1 0x20 23DD 01 ADD 23DE 90 SWAP1 23DF 81 DUP2 23E0 52 MSTORE 23E1 60 PUSH1 0x20 23E3 01 ADD 23E4 60 PUSH1 0x00 23E6 20 SHA3 23E7 60 PUSH1 0x00 23E9 90 SWAP1 23EA 55 SSTORE 23EB 60 PUSH1 0x01 23ED 93 SWAP4 23EE 50 POP 23EF 50 POP 23F0 50 POP 23F1 50 POP 23F2 61 PUSH2 0x07d7 23F5 56 *JUMP // Stack delta = -5 // Outputs[7] // { // @23C5 memory[0x00:0x20] = stack[-2] // @23CF storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @23D1 storage[stack[-2]] = stack[-1] - 0x01 // @23DA memory[0x00:0x20] = stack[-7] // @23E0 memory[0x20:0x40] = 0x01 + stack[-8] // @23EA storage[keccak256(memory[0x00:0x40])] = 0x00 // @23ED stack[-6] = 0x01 // } // Block ends with unconditional jump to 0x07d7 label_23F6: // Incoming jump from 0x2324, if !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @23F9 stack[-2] } 23F6 5B JUMPDEST 23F7 60 PUSH1 0x00 23F9 91 SWAP2 23FA 50 POP 23FB 50 POP 23FC 61 PUSH2 0x07d7 23FF 56 *JUMP // Stack delta = -1 // Outputs[1] { @23F9 stack[-2] = 0x00 } // Block ends with unconditional jump to 0x07d7 label_2400: // Incoming jump from 0x2F9F // Incoming jump from 0x1847 // Inputs[3] // { // @2404 stack[-3] // @2405 stack[-2] // @2406 stack[-1] // } 2400 5B JUMPDEST 2401 61 PUSH2 0x0a56 2404 83 DUP4 2405 83 DUP4 2406 83 DUP4 2407 61 PUSH2 0x2a38 240A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2401 stack[0] = 0x0a56 // @2404 stack[1] = stack[-3] // @2405 stack[2] = stack[-2] // @2406 stack[3] = stack[-1] // } // Block ends with call to 0x2a38, returns to 0x0A56 label_240B: // Incoming call from 0x1AAF, returns to 0x07D7 // Inputs[2] // { // @2411 stack[-1] // @2412 memory[stack[-1]:stack[-1] + 0x20] // } 240B 5B JUMPDEST 240C 60 PUSH1 0x00 240E 61 PUSH2 0x2417 2411 82 DUP3 2412 51 MLOAD 2413 61 PUSH2 0x2178 2416 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @240C stack[0] = 0x00 // @240E stack[1] = 0x2417 // @2412 stack[2] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x2178, returns to 0x2417 label_2417: // Incoming return from call to 0x2178 at 0x2416 // Inputs[3] // { // @2418 stack[-3] // @241B memory[0x40:0x60] // @2422 stack[-1] // } 2417 5B JUMPDEST 2418 82 DUP3 2419 60 PUSH1 0x40 241B 51 MLOAD 241C 60 PUSH1 0x20 241E 01 ADD 241F 61 PUSH2 0x2429 2422 92 SWAP3 2423 91 SWAP2 2424 90 SWAP1 2425 61 PUSH2 0x39d0 2428 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2422 stack[-1] = 0x2429 // @2423 stack[0] = stack[-1] // @2424 stack[2] = 0x20 + memory[0x40:0x60] // @2424 stack[1] = stack[-3] // } // Block ends with call to 0x39d0, returns to 0x2429 label_2429: // Incoming return from call to 0x39D0 at 0x2428 // Inputs[7] // { // @242C memory[0x40:0x60] // @2430 stack[-1] // @243A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @243F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @2440 stack[-2] // @2442 stack[-4] // @2443 stack[-3] // } 2429 5B JUMPDEST 242A 60 PUSH1 0x40 242C 51 MLOAD 242D 60 PUSH1 0x20 242F 81 DUP2 2430 83 DUP4 2431 03 SUB 2432 03 SUB 2433 81 DUP2 2434 52 MSTORE 2435 90 SWAP1 2436 60 PUSH1 0x40 2438 52 MSTORE 2439 80 DUP1 243A 51 MLOAD 243B 90 SWAP1 243C 60 PUSH1 0x20 243E 01 ADD 243F 20 SHA3 2440 90 SWAP1 2441 50 POP 2442 91 SWAP2 2443 90 SWAP1 2444 50 POP 2445 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2434 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @2438 memory[0x40:0x60] = stack[-1] // @2442 stack[-4] = 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[-4] 2446 5B JUMPDEST 2447 61 PUSH2 0x2452 244A 84 DUP5 244B 84 DUP5 244C 84 DUP5 244D 84 DUP5 244E 61 PUSH2 0x2b34 2451 56 *JUMP 2452 5B JUMPDEST 2453 61 PUSH2 0x10f6 2456 57 *JUMPI 2457 60 PUSH1 0x40 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 0x23 246C 60 PUSH1 0x24 246E 82 DUP3 246F 01 ADD 2470 52 MSTORE 2471 7F PUSH32 0x5369676e6174757265436865636b65723a20496e76616c6964207369676e6174 2492 60 PUSH1 0x44 2494 82 DUP3 2495 01 ADD 2496 52 MSTORE 2497 62 PUSH3 0x757265 249B 60 PUSH1 0xe8 249D 1B SHL 249E 60 PUSH1 0x64 24A0 82 DUP3 24A1 01 ADD 24A2 52 MSTORE 24A3 60 PUSH1 0x84 24A5 01 ADD 24A6 61 PUSH2 0x0807 24A9 56 *JUMP label_24AA: // Incoming call from 0x1D66, returns to 0x1D67 // Incoming call from 0x1DD5, returns to 0x1DD6 // Incoming call from 0x1D66, returns to 0x1D67 // Incoming call from 0x1D9D, returns to 0x1D9E // Inputs[4] // { // @24B3 stack[-2] // @24C2 memory[0x00:0x40] // @24C3 storage[keccak256(memory[0x00:0x40])] // @24C6 storage[0x0c] // } 24AA 5B JUMPDEST 24AB 60 PUSH1 0x01 24AD 60 PUSH1 0x01 24AF 60 PUSH1 0xa0 24B1 1B SHL 24B2 03 SUB 24B3 82 DUP3 24B4 16 AND 24B5 60 PUSH1 0x00 24B7 90 SWAP1 24B8 81 DUP2 24B9 52 MSTORE 24BA 60 PUSH1 0x12 24BC 60 PUSH1 0x20 24BE 52 MSTORE 24BF 60 PUSH1 0x40 24C1 81 DUP2 24C2 20 SHA3 24C3 54 SLOAD 24C4 60 PUSH1 0x0c 24C6 54 SLOAD 24C7 82 DUP3 24C8 91 SWAP2 24C9 61 PUSH2 0x24d1 24CC 91 SWAP2 24CD 61 PUSH2 0x3854 24D0 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @24B7 stack[0] = 0x00 // @24B9 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @24BE memory[0x20:0x40] = 0x12 // @24C8 stack[3] = storage[keccak256(memory[0x00:0x40])] // @24C8 stack[1] = 0x00 // @24CC stack[2] = 0x24d1 // @24CC stack[4] = storage[0x0c] // } // Block ends with call to 0x3854, returns to 0x24D1 label_24D1: // Incoming return from call to 0x3854 at 0x24D0 // Inputs[2] // { // @24D2 stack[-1] // @24D2 stack[-2] // } 24D1 5B JUMPDEST 24D2 90 SWAP1 24D3 50 POP 24D4 80 DUP1 24D5 61 PUSH2 0x24e9 24D8 57 *JUMPI // Stack delta = -1 // Outputs[1] { @24D2 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x24e9, if stack[-1] label_24D9: // Incoming jump from 0x24D8, if not stack[-1] // Inputs[2] // { // @24D9 stack[-3] // @24DC memory[0x40:0x60] // } 24D9 82 DUP3 24DA 60 PUSH1 0x40 24DC 51 MLOAD 24DD 60 PUSH1 0x20 24DF 01 ADD 24E0 61 PUSH2 0x1e9b 24E3 91 SWAP2 24E4 90 SWAP1 24E5 61 PUSH2 0x3a2b 24E8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24E3 stack[0] = 0x1e9b // @24E4 stack[1] = stack[-3] // @24E4 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x3a2b, returns to 0x1E9B label_24E9: // Incoming jump from 0x24D8, if stack[-1] // Inputs[2] // { // @24ED stack[-5] // @24EE stack[-1] // } 24E9 5B JUMPDEST 24EA 61 PUSH2 0x24f3 24ED 85 DUP6 24EE 82 DUP3 24EF 61 PUSH2 0x2131 24F2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24EA stack[0] = 0x24f3 // @24ED stack[1] = stack[-5] // @24EE stack[2] = stack[-1] // } // Block ends with call to 0x2131, returns to 0x24F3 label_24F3: // Incoming return from call to 0x2131 at 0x24F2 // Inputs[3] // { // @24F4 stack[-1] // @24F4 stack[-7] // @24F5 stack[-6] // } 24F3 5B JUMPDEST 24F4 95 SWAP6 24F5 94 SWAP5 24F6 50 POP 24F7 50 POP 24F8 50 POP 24F9 50 POP 24FA 50 POP 24FB 56 *JUMP // Stack delta = -6 // Outputs[1] { @24F4 stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] 24FC 5B JUMPDEST 24FD 80 DUP1 24FE 47 SELFBALANCE 24FF 10 LT 2500 15 ISZERO 2501 61 PUSH2 0x254c 2504 57 *JUMPI 2505 60 PUSH1 0x40 2507 51 MLOAD 2508 62 PUSH3 0x461bcd 250C 60 PUSH1 0xe5 250E 1B SHL 250F 81 DUP2 2510 52 MSTORE 2511 60 PUSH1 0x20 2513 60 PUSH1 0x04 2515 82 DUP3 2516 01 ADD 2517 52 MSTORE 2518 60 PUSH1 0x1d 251A 60 PUSH1 0x24 251C 82 DUP3 251D 01 ADD 251E 52 MSTORE 251F 7F PUSH32 0x416464726573733a20696e73756666696369656e742062616c616e6365000000 2540 60 PUSH1 0x44 2542 82 DUP3 2543 01 ADD 2544 52 MSTORE 2545 60 PUSH1 0x64 2547 01 ADD 2548 61 PUSH2 0x0807 254B 56 *JUMP 254C 5B JUMPDEST 254D 60 PUSH1 0x00 254F 82 DUP3 2550 60 PUSH1 0x01 2552 60 PUSH1 0x01 2554 60 PUSH1 0xa0 2556 1B SHL 2557 03 SUB 2558 16 AND 2559 82 DUP3 255A 60 PUSH1 0x40 255C 51 MLOAD 255D 60 PUSH1 0x00 255F 60 PUSH1 0x40 2561 51 MLOAD 2562 80 DUP1 2563 83 DUP4 2564 03 SUB 2565 81 DUP2 2566 85 DUP6 2567 87 DUP8 2568 5A GAS 2569 F1 CALL 256A 92 SWAP3 256B 50 POP 256C 50 POP 256D 50 POP 256E 3D RETURNDATASIZE 256F 80 DUP1 2570 60 PUSH1 0x00 2572 81 DUP2 2573 14 EQ 2574 61 PUSH2 0x2599 2577 57 *JUMPI 2578 60 PUSH1 0x40 257A 51 MLOAD 257B 91 SWAP2 257C 50 POP 257D 60 PUSH1 0x1f 257F 19 NOT 2580 60 PUSH1 0x3f 2582 3D RETURNDATASIZE 2583 01 ADD 2584 16 AND 2585 82 DUP3 2586 01 ADD 2587 60 PUSH1 0x40 2589 52 MSTORE 258A 3D RETURNDATASIZE 258B 82 DUP3 258C 52 MSTORE 258D 3D RETURNDATASIZE 258E 60 PUSH1 0x00 2590 60 PUSH1 0x20 2592 84 DUP5 2593 01 ADD 2594 3E RETURNDATACOPY 2595 61 PUSH2 0x259e 2598 56 *JUMP 2599 5B JUMPDEST 259A 60 PUSH1 0x60 259C 91 SWAP2 259D 50 POP 259E 5B JUMPDEST 259F 50 POP 25A0 50 POP 25A1 90 SWAP1 25A2 50 POP 25A3 80 DUP1 25A4 61 PUSH2 0x0a56 25A7 57 *JUMPI 25A8 60 PUSH1 0x40 25AA 51 MLOAD 25AB 62 PUSH3 0x461bcd 25AF 60 PUSH1 0xe5 25B1 1B SHL 25B2 81 DUP2 25B3 52 MSTORE 25B4 60 PUSH1 0x20 25B6 60 PUSH1 0x04 25B8 82 DUP3 25B9 01 ADD 25BA 52 MSTORE 25BB 60 PUSH1 0x3a 25BD 60 PUSH1 0x24 25BF 82 DUP3 25C0 01 ADD 25C1 52 MSTORE 25C2 7F PUSH32 0x416464726573733a20756e61626c6520746f2073656e642076616c75652c2072 25E3 60 PUSH1 0x44 25E5 82 DUP3 25E6 01 ADD 25E7 52 MSTORE 25E8 7F PUSH32 0x6563697069656e74206d61792068617665207265766572746564000000000000 2609 60 PUSH1 0x64 260B 82 DUP3 260C 01 ADD 260D 52 MSTORE 260E 60 PUSH1 0x84 2610 01 ADD 2611 61 PUSH2 0x0807 2614 56 *JUMP label_2615: // Incoming call from 0x2965, returns to 0x2966 // Incoming call from 0x2A99, returns to 0x2A9A // Incoming call from 0x2040, returns to 0x2041 // Inputs[1] { @2619 CHAINID() } 2615 5B JUMPDEST 2616 60 PUSH1 0x00 2618 80 DUP1 2619 46 CHAINID 261A 80 DUP1 261B 60 PUSH1 0x01 261D 81 DUP2 261E 14 EQ 261F 61 PUSH2 0x264a 2622 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2616 stack[0] = 0x00 // @2618 stack[1] = 0x00 // @2619 stack[2] = CHAINID() // @261A stack[3] = CHAINID() // } // Block ends with conditional jump to 0x264a, if CHAINID() == 0x01 label_2623: // Incoming jump from 0x2622, if not CHAINID() == 0x01 // Inputs[1] { @2625 stack[-1] } 2623 60 PUSH1 0x89 2625 81 DUP2 2626 14 EQ 2627 61 PUSH2 0x2666 262A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2666, if stack[-1] == 0x89 label_262B: // Incoming jump from 0x262A, if not stack[-1] == 0x89 // Inputs[1] { @262D stack[-1] } 262B 60 PUSH1 0x04 262D 81 DUP2 262E 14 EQ 262F 61 PUSH2 0x2682 2632 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2682, if stack[-1] == 0x04 label_2633: // Incoming jump from 0x2632, if not stack[-1] == 0x04 // Inputs[1] { @2637 stack[-1] } 2633 62 PUSH3 0x013881 2637 81 DUP2 2638 14 EQ 2639 61 PUSH2 0x269e 263C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x269e, if stack[-1] == 0x013881 label_263D: // Incoming jump from 0x263C, if not stack[-1] == 0x013881 // Inputs[1] { @2640 stack[-1] } 263D 61 PUSH2 0x0539 2640 81 DUP2 2641 14 EQ 2642 61 PUSH2 0x26ba 2645 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x26ba, if stack[-1] == 0x0539 label_2646: // Incoming jump from 0x2645, if not stack[-1] == 0x0539 2646 61 PUSH2 0x26d2 2649 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x26d2 label_264A: // Incoming jump from 0x2622, if CHAINID() == 0x01 // Inputs[1] { @2660 stack[-3] } 264A 5B JUMPDEST 264B 73 PUSH20 0xa5409ec958c83c3f309868babaca7c86dcb077c1 2660 92 SWAP3 2661 50 POP 2662 61 PUSH2 0x26d2 2665 56 *JUMP // Stack delta = +0 // Outputs[1] { @2660 stack[-3] = 0xa5409ec958c83c3f309868babaca7c86dcb077c1 } // Block ends with unconditional jump to 0x26d2 label_2666: // Incoming jump from 0x262A, if stack[-1] == 0x89 // Inputs[1] { @267C stack[-3] } 2666 5B JUMPDEST 2667 73 PUSH20 0x58807bad0b376efc12f5ad86aac70e78ed67deae 267C 92 SWAP3 267D 50 POP 267E 61 PUSH2 0x26d2 2681 56 *JUMP // Stack delta = +0 // Outputs[1] { @267C stack[-3] = 0x58807bad0b376efc12f5ad86aac70e78ed67deae } // Block ends with unconditional jump to 0x26d2 label_2682: // Incoming jump from 0x2632, if stack[-1] == 0x04 // Inputs[1] { @2698 stack[-3] } 2682 5B JUMPDEST 2683 73 PUSH20 0xf57b2c51ded3a29e6891aba85459d600256cf317 2698 92 SWAP3 2699 50 POP 269A 61 PUSH2 0x26d2 269D 56 *JUMP // Stack delta = +0 // Outputs[1] { @2698 stack[-3] = 0xf57b2c51ded3a29e6891aba85459d600256cf317 } // Block ends with unconditional jump to 0x26d2 label_269E: // Incoming jump from 0x263C, if stack[-1] == 0x013881 // Inputs[1] { @26B4 stack[-3] } 269E 5B JUMPDEST 269F 73 PUSH20 0xff7ca10af37178bdd056628ef42fd7f799fac77c 26B4 92 SWAP3 26B5 50 POP 26B6 61 PUSH2 0x26d2 26B9 56 *JUMP // Stack delta = +0 // Outputs[1] { @26B4 stack[-3] = 0xff7ca10af37178bdd056628ef42fd7f799fac77c } // Block ends with unconditional jump to 0x26d2 label_26BA: // Incoming jump from 0x2645, if stack[-1] == 0x0539 // Inputs[1] { @26D0 stack[-3] } 26BA 5B JUMPDEST 26BB 73 PUSH20 0xe1a2bbc877b29adbc56d2659dbcb0ae14ee62071 26D0 92 SWAP3 26D1 50 POP // Stack delta = +0 // Outputs[1] { @26D0 stack[-3] = 0xe1a2bbc877b29adbc56d2659dbcb0ae14ee62071 } // Block continues label_26D2: // Incoming jump from 0x2649 // Incoming jump from 0x26D1 // Incoming jump from 0x269D // Incoming jump from 0x26B9 // Incoming jump from 0x2665 // Incoming jump from 0x2681 // Inputs[1] { @26DC stack[-3] } 26D2 5B JUMPDEST 26D3 50 POP 26D4 60 PUSH1 0x01 26D6 60 PUSH1 0x01 26D8 60 PUSH1 0xa0 26DA 1B SHL 26DB 03 SUB 26DC 82 DUP3 26DD 16 AND 26DE 15 ISZERO 26DF 80 DUP1 26E0 61 PUSH2 0x26e9 26E3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26DE stack[-1] = !(stack[-3] & (0x01 << 0xa0) - 0x01) } // Block ends with conditional jump to 0x26e9, if !(stack[-3] & (0x01 << 0xa0) - 0x01) label_26E4: // Incoming jump from 0x26E3, if not !(stack[-3] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @26E5 stack[-2] } 26E4 50 POP 26E5 80 DUP1 26E6 60 PUSH1 0x89 26E8 14 EQ 26E9 5B JUMPDEST 26EA 80 DUP1 26EB 61 PUSH2 0x26f6 26EE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26E8 stack[-1] = 0x89 == stack[-2] } // Block ends with conditional jump to 0x26f6, if 0x89 == stack[-2] label_26EF: // Incoming jump from 0x26EE, if not stack[-1] // Incoming jump from 0x26EE, if not 0x89 == stack[-2] // Inputs[1] { @26F0 stack[-2] } 26EF 50 POP 26F0 80 DUP1 26F1 62 PUSH3 0x013881 26F5 14 EQ 26F6 5B JUMPDEST 26F7 15 ISZERO 26F8 61 PUSH2 0x2702 26FB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2702, if !(0x013881 == stack[-2]) label_26FC: // Incoming jump from 0x26FB, if not !(0x013881 == stack[-2]) // Incoming jump from 0x26FB, if not !stack[-1] // Inputs[3] // { // @26FD stack[-2] // @26FD stack[-5] // @26FE stack[-4] // } 26FC 50 POP 26FD 92 SWAP3 26FE 91 SWAP2 26FF 50 POP 2700 50 POP 2701 56 *JUMP // Stack delta = -4 // Outputs[1] { @26FD stack[-5] = stack[-2] } // Block ends with unconditional jump to stack[-5] label_2702: // Incoming jump from 0x26FB, if !(0x013881 == stack[-2]) // Incoming jump from 0x26FB, if !stack[-1] // Inputs[7] // { // @2705 memory[0x40:0x60] // @2718 stack[-4] // @2720 stack[-2] // @2730 memory[0x40:0x60] // @2736 msg.gas // @2737 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]] // @2737 address(stack[-2] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 2702 5B JUMPDEST 2703 60 PUSH1 0x40 2705 51 MLOAD 2706 63 PUSH4 0xc4552791 270B 60 PUSH1 0xe0 270D 1B SHL 270E 81 DUP2 270F 52 MSTORE 2710 60 PUSH1 0x01 2712 60 PUSH1 0x01 2714 60 PUSH1 0xa0 2716 1B SHL 2717 03 SUB 2718 85 DUP6 2719 81 DUP2 271A 16 AND 271B 60 PUSH1 0x04 271D 83 DUP4 271E 01 ADD 271F 52 MSTORE 2720 83 DUP4 2721 16 AND 2722 90 SWAP1 2723 63 PUSH4 0xc4552791 2728 90 SWAP1 2729 60 PUSH1 0x24 272B 01 ADD 272C 60 PUSH1 0x20 272E 60 PUSH1 0x40 2730 51 MLOAD 2731 80 DUP1 2732 83 DUP4 2733 03 SUB 2734 81 DUP2 2735 86 DUP7 2736 5A GAS 2737 FA STATICCALL 2738 15 ISZERO 2739 80 DUP1 273A 15 ISZERO 273B 61 PUSH2 0x2748 273E 57 *JUMPI // Stack delta = +4 // Outputs[7] // { // @270F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc4552791 << 0xe0 // @271F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @2722 stack[0] = stack[-2] & (0x01 << 0xa0) - 0x01 // @2728 stack[1] = 0xc4552791 // @272B stack[2] = 0x24 + memory[0x40:0x60] // @2737 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-2] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @2738 stack[3] = !address(stack[-2] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x2748, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_273F: // Incoming jump from 0x273E, if not !!address(stack[-2] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @273F returndata.length // @2743 returndata[0x00:0x00 + returndata.length] // @2744 returndata.length // @2747 memory[0x00:0x00 + returndata.length] // } 273F 3D RETURNDATASIZE 2740 60 PUSH1 0x00 2742 80 DUP1 2743 3E RETURNDATACOPY 2744 3D RETURNDATASIZE 2745 60 PUSH1 0x00 2747 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2743 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2747 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2748: // Incoming jump from 0x273E, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @274F memory[0x40:0x60] // @2750 returndata.length // } 2748 5B JUMPDEST 2749 50 POP 274A 50 POP 274B 50 POP 274C 50 POP 274D 60 PUSH1 0x40 274F 51 MLOAD 2750 3D RETURNDATASIZE 2751 60 PUSH1 0x1f 2753 19 NOT 2754 60 PUSH1 0x1f 2756 82 DUP3 2757 01 ADD 2758 16 AND 2759 82 DUP3 275A 01 ADD 275B 80 DUP1 275C 60 PUSH1 0x40 275E 52 MSTORE 275F 50 POP 2760 81 DUP2 2761 01 ADD 2762 90 SWAP1 2763 61 PUSH2 0x175c 2766 91 SWAP2 2767 90 SWAP1 2768 61 PUSH2 0x3a5b 276B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @275E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @2766 stack[-4] = 0x175c // @2767 stack[-2] = memory[0x40:0x60] // @2767 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x3a5b label_276C: // Incoming call from 0x20FD, returns to 0x0A56 // Inputs[2] // { // @276D stack[-2] // @2777 stack[-3] // } 276C 5B JUMPDEST 276D 81 DUP2 276E 60 PUSH1 0x01 2770 60 PUSH1 0x01 2772 60 PUSH1 0xa0 2774 1B SHL 2775 03 SUB 2776 16 AND 2777 83 DUP4 2778 60 PUSH1 0x01 277A 60 PUSH1 0x01 277C 60 PUSH1 0xa0 277E 1B SHL 277F 03 SUB 2780 16 AND 2781 14 EQ 2782 15 ISZERO 2783 61 PUSH2 0x27ce 2786 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x27ce, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) label_2787: // Incoming jump from 0x2786, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[1] { @2789 memory[0x40:0x60] } 2787 60 PUSH1 0x40 2789 51 MLOAD 278A 62 PUSH3 0x461bcd 278E 60 PUSH1 0xe5 2790 1B SHL 2791 81 DUP2 2792 52 MSTORE 2793 60 PUSH1 0x20 2795 60 PUSH1 0x04 2797 82 DUP3 2798 01 ADD 2799 52 MSTORE 279A 60 PUSH1 0x19 279C 60 PUSH1 0x24 279E 82 DUP3 279F 01 ADD 27A0 52 MSTORE 27A1 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 27C2 60 PUSH1 0x44 27C4 82 DUP3 27C5 01 ADD 27C6 52 MSTORE 27C7 60 PUSH1 0x64 27C9 01 ADD 27CA 61 PUSH2 0x0807 27CD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2792 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2799 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @27A0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @27C6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @27C9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_27CE: // Incoming jump from 0x2786, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[7] // { // @27D7 stack[-3] // @27EA memory[0x00:0x40] // @27EC stack[-2] // @27F7 memory[0x00:0x40] // @27F9 storage[keccak256(memory[0x00:0x40])] // @27FE stack[-1] // @2808 memory[0x40:0x60] // } 27CE 5B JUMPDEST 27CF 60 PUSH1 0x01 27D1 60 PUSH1 0x01 27D3 60 PUSH1 0xa0 27D5 1B SHL 27D6 03 SUB 27D7 83 DUP4 27D8 81 DUP2 27D9 16 AND 27DA 60 PUSH1 0x00 27DC 81 DUP2 27DD 81 DUP2 27DE 52 MSTORE 27DF 60 PUSH1 0x05 27E1 60 PUSH1 0x20 27E3 90 SWAP1 27E4 81 DUP2 27E5 52 MSTORE 27E6 60 PUSH1 0x40 27E8 80 DUP1 27E9 83 DUP4 27EA 20 SHA3 27EB 94 SWAP5 27EC 87 DUP8 27ED 16 AND 27EE 80 DUP1 27EF 84 DUP5 27F0 52 MSTORE 27F1 94 SWAP5 27F2 82 DUP3 27F3 52 MSTORE 27F4 91 SWAP2 27F5 82 DUP3 27F6 90 SWAP1 27F7 20 SHA3 27F8 80 DUP1 27F9 54 SLOAD 27FA 60 PUSH1 0xff 27FC 19 NOT 27FD 16 AND 27FE 86 DUP7 27FF 15 ISZERO 2800 15 ISZERO 2801 90 SWAP1 2802 81 DUP2 2803 17 OR 2804 90 SWAP1 2805 91 SWAP2 2806 55 SSTORE 2807 91 SWAP2 2808 51 MLOAD 2809 91 SWAP2 280A 82 DUP3 280B 52 MSTORE 280C 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 282D 91 SWAP2 282E 01 ADD 282F 61 PUSH2 0x20e6 2832 56 *JUMP // Stack delta = +4 // Outputs[10] // { // @27D9 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-3] // @27DE memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @27E5 memory[0x20:0x40] = 0x05 // @27F0 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @27F1 stack[0] = stack[-2] & (0x01 << 0xa0) - 0x01 // @27F3 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2806 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @280B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @282D stack[2] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @282E stack[3] = memory[0x40:0x60] + 0x20 // } // Block ends with unconditional jump to 0x20e6 2833 5B JUMPDEST 2834 60 PUSH1 0x00 2836 60 PUSH1 0x01 2838 60 PUSH1 0x01 283A 60 PUSH1 0xa0 283C 1B SHL 283D 03 SUB 283E 84 DUP5 283F 16 AND 2840 3B EXTCODESIZE 2841 15 ISZERO 2842 61 PUSH2 0x2926 2845 57 *JUMPI 2846 60 PUSH1 0x40 2848 51 MLOAD 2849 63 PUSH4 0x0a85bd01 284E 60 PUSH1 0xe1 2850 1B SHL 2851 81 DUP2 2852 52 MSTORE 2853 60 PUSH1 0x01 2855 60 PUSH1 0x01 2857 60 PUSH1 0xa0 2859 1B SHL 285A 03 SUB 285B 85 DUP6 285C 16 AND 285D 90 SWAP1 285E 63 PUSH4 0x150b7a02 2863 90 SWAP1 2864 61 PUSH2 0x2877 2867 90 SWAP1 2868 33 CALLER 2869 90 SWAP1 286A 89 DUP10 286B 90 SWAP1 286C 88 DUP9 286D 90 SWAP1 286E 88 DUP9 286F 90 SWAP1 2870 60 PUSH1 0x04 2872 01 ADD 2873 61 PUSH2 0x3a78 2876 56 *JUMP 2877 5B JUMPDEST 2878 60 PUSH1 0x20 287A 60 PUSH1 0x40 287C 51 MLOAD 287D 80 DUP1 287E 83 DUP4 287F 03 SUB 2880 81 DUP2 2881 60 PUSH1 0x00 2883 87 DUP8 2884 5A GAS 2885 F1 CALL 2886 92 SWAP3 2887 50 POP 2888 50 POP 2889 50 POP 288A 80 DUP1 288B 15 ISZERO 288C 61 PUSH2 0x28b2 288F 57 *JUMPI 2890 50 POP 2891 60 PUSH1 0x40 2893 80 DUP1 2894 51 MLOAD 2895 60 PUSH1 0x1f 2897 3D RETURNDATASIZE 2898 90 SWAP1 2899 81 DUP2 289A 01 ADD 289B 60 PUSH1 0x1f 289D 19 NOT 289E 16 AND 289F 82 DUP3 28A0 01 ADD 28A1 90 SWAP1 28A2 92 SWAP3 28A3 52 MSTORE 28A4 61 PUSH2 0x28af 28A7 91 SWAP2 28A8 81 DUP2 28A9 01 ADD 28AA 90 SWAP1 28AB 61 PUSH2 0x3ab5 28AE 56 *JUMP 28AF 5B JUMPDEST 28B0 60 PUSH1 0x01 28B2 5B JUMPDEST 28B3 61 PUSH2 0x290c 28B6 57 *JUMPI 28B7 3D RETURNDATASIZE 28B8 80 DUP1 28B9 80 DUP1 28BA 15 ISZERO 28BB 61 PUSH2 0x28e0 28BE 57 *JUMPI 28BF 60 PUSH1 0x40 28C1 51 MLOAD 28C2 91 SWAP2 28C3 50 POP 28C4 60 PUSH1 0x1f 28C6 19 NOT 28C7 60 PUSH1 0x3f 28C9 3D RETURNDATASIZE 28CA 01 ADD 28CB 16 AND 28CC 82 DUP3 28CD 01 ADD 28CE 60 PUSH1 0x40 28D0 52 MSTORE 28D1 3D RETURNDATASIZE 28D2 82 DUP3 28D3 52 MSTORE 28D4 3D RETURNDATASIZE 28D5 60 PUSH1 0x00 28D7 60 PUSH1 0x20 28D9 84 DUP5 28DA 01 ADD 28DB 3E RETURNDATACOPY 28DC 61 PUSH2 0x28e5 28DF 56 *JUMP 28E0 5B JUMPDEST 28E1 60 PUSH1 0x60 28E3 91 SWAP2 28E4 50 POP 28E5 5B JUMPDEST 28E6 50 POP 28E7 80 DUP1 28E8 51 MLOAD 28E9 61 PUSH2 0x2904 28EC 57 *JUMPI 28ED 60 PUSH1 0x40 28EF 51 MLOAD 28F0 62 PUSH3 0x461bcd 28F4 60 PUSH1 0xe5 28F6 1B SHL 28F7 81 DUP2 28F8 52 MSTORE 28F9 60 PUSH1 0x04 28FB 01 ADD 28FC 61 PUSH2 0x0807 28FF 90 SWAP1 2900 61 PUSH2 0x3923 2903 56 *JUMP 2904 5B JUMPDEST 2905 80 DUP1 2906 51 MLOAD 2907 81 DUP2 2908 60 PUSH1 0x20 290A 01 ADD 290B FD *REVERT 290C 5B JUMPDEST 290D 60 PUSH1 0x01 290F 60 PUSH1 0x01 2911 60 PUSH1 0xe0 2913 1B SHL 2914 03 SUB 2915 19 NOT 2916 16 AND 2917 63 PUSH4 0x0a85bd01 291C 60 PUSH1 0xe1 291E 1B SHL 291F 14 EQ 2920 90 SWAP1 2921 50 POP 2922 61 PUSH2 0x175c 2925 56 *JUMP 2926 5B JUMPDEST 2927 50 POP 2928 60 PUSH1 0x01 292A 94 SWAP5 292B 93 SWAP4 292C 50 POP 292D 50 POP 292E 50 POP 292F 50 POP 2930 56 *JUMP label_2931: // Incoming jump from 0x2150 // Inputs[3] // { // @2935 stack[-2] // @2936 stack[-1] // @2939 memory[0x40:0x60] // } 2931 5B JUMPDEST 2932 61 PUSH2 0x081a 2935 82 DUP3 2936 82 DUP3 2937 60 PUSH1 0x40 2939 51 MLOAD 293A 80 DUP1 293B 60 PUSH1 0x20 293D 01 ADD 293E 60 PUSH1 0x40 2940 52 MSTORE 2941 80 DUP1 2942 60 PUSH1 0x00 2944 81 DUP2 2945 52 MSTORE 2946 50 POP 2947 61 PUSH2 0x2b80 294A 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @2932 stack[0] = 0x081a // @2935 stack[1] = stack[-2] // @2936 stack[2] = stack[-1] // @2939 stack[3] = memory[0x40:0x60] // @2940 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @2945 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x2b80, returns to 0x081A label_294B: // Incoming call from 0x2177, returns to 0x0FF4 // Inputs[1] { @2951 storage[0x09] } 294B 5B JUMPDEST 294C 60 PUSH1 0x60 294E 60 PUSH1 0x09 2950 80 DUP1 2951 54 SLOAD 2952 61 PUSH2 0x082d 2955 90 SWAP1 2956 61 PUSH2 0x373f 2959 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @294C stack[0] = 0x60 // @294E stack[1] = 0x09 // @2955 stack[2] = 0x082d // @2955 stack[3] = storage[0x09] // } // Block ends with call to 0x373f, returns to 0x082D label_295A: // Incoming call from 0x22EC, returns to 0x0E2F // Inputs[1] { @2961 stack[-2] } 295A 5B JUMPDEST 295B 60 PUSH1 0x00 295D 80 DUP1 295E 61 PUSH2 0x2966 2961 84 DUP5 2962 61 PUSH2 0x2615 2965 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @295B stack[0] = 0x00 // @295D stack[1] = 0x00 // @295E stack[2] = 0x2966 // @2961 stack[3] = stack[-2] // } // Block ends with call to 0x2615, returns to 0x2966 label_2966: // Incoming return from call to 0x2615 at 0x2965 // Inputs[2] // { // @2967 stack[-1] // @2967 stack[-2] // } 2966 5B JUMPDEST 2967 90 SWAP1 2968 50 POP 2969 60 PUSH1 0x01 296B 60 PUSH1 0x01 296D 60 PUSH1 0xa0 296F 1B SHL 2970 03 SUB 2971 81 DUP2 2972 16 AND 2973 15 ISZERO 2974 80 DUP1 2975 15 ISZERO 2976 90 SWAP1 2977 61 PUSH2 0x175c 297A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2967 stack[-2] = stack[-1] // @2976 stack[-1] = !!(stack[-1] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x175c, if !(stack[-1] & (0x01 << 0xa0) - 0x01) label_297B: // Incoming jump from 0x297A, if not !(stack[-1] & (0x01 << 0xa0) - 0x01) // Inputs[5] // { // @297C stack[-4] // @2986 stack[-2] // @2991 stack[-3] // @2994 stack[-6] // @2995 stack[-5] // } 297B 50 POP 297C 82 DUP3 297D 60 PUSH1 0x01 297F 60 PUSH1 0x01 2981 60 PUSH1 0xa0 2983 1B SHL 2984 03 SUB 2985 16 AND 2986 81 DUP2 2987 60 PUSH1 0x01 2989 60 PUSH1 0x01 298B 60 PUSH1 0xa0 298D 1B SHL 298E 03 SUB 298F 16 AND 2990 14 EQ 2991 91 SWAP2 2992 50 POP 2993 50 POP 2994 92 SWAP3 2995 91 SWAP2 2996 50 POP 2997 50 POP 2998 56 *JUMP // Stack delta = -5 // Outputs[1] { @2994 stack[-6] = (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-4] } // Block ends with unconditional jump to stack[-6] label_2999: // Incoming call from 0x2301, returns to 0x0E2F // Inputs[4] // { // @299C stack[-1] // @29A1 stack[-2] // @29A9 memory[0x00:0x40] // @29AA storage[keccak256(memory[0x00:0x40])] // } 2999 5B JUMPDEST 299A 60 PUSH1 0x00 299C 81 DUP2 299D 81 DUP2 299E 52 MSTORE 299F 60 PUSH1 0x01 29A1 83 DUP4 29A2 01 ADD 29A3 60 PUSH1 0x20 29A5 52 MSTORE 29A6 60 PUSH1 0x40 29A8 81 DUP2 29A9 20 SHA3 29AA 54 SLOAD 29AB 61 PUSH2 0x29e0 29AE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @299A stack[0] = 0x00 // @299E memory[0x00:0x20] = stack[-1] // @29A5 memory[0x20:0x40] = stack[-2] + 0x01 // } // Block ends with conditional jump to 0x29e0, if storage[keccak256(memory[0x00:0x40])] label_29AF: // Incoming jump from 0x29AE, if not storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @29B0 stack[-3] // @29B1 storage[stack[-3]] // @29C2 memory[0x00:0x20] // @29C6 stack[-2] // @29CA storage[stack[-3]] // @29D7 memory[0x00:0x40] // } 29AF 50 POP 29B0 81 DUP2 29B1 54 SLOAD 29B2 60 PUSH1 0x01 29B4 81 DUP2 29B5 81 DUP2 29B6 01 ADD 29B7 84 DUP5 29B8 55 SSTORE 29B9 60 PUSH1 0x00 29BB 84 DUP5 29BC 81 DUP2 29BD 52 MSTORE 29BE 60 PUSH1 0x20 29C0 80 DUP1 29C1 82 DUP3 29C2 20 SHA3 29C3 90 SWAP1 29C4 93 SWAP4 29C5 01 ADD 29C6 84 DUP5 29C7 90 SWAP1 29C8 55 SSTORE 29C9 84 DUP5 29CA 54 SLOAD 29CB 84 DUP5 29CC 82 DUP3 29CD 52 MSTORE 29CE 82 DUP3 29CF 86 DUP7 29D0 01 ADD 29D1 90 SWAP1 29D2 93 SWAP4 29D3 52 MSTORE 29D4 60 PUSH1 0x40 29D6 90 SWAP1 29D7 20 SHA3 29D8 91 SWAP2 29D9 90 SWAP1 29DA 91 SWAP2 29DB 55 SSTORE 29DC 61 PUSH2 0x07d7 29DF 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @29B8 storage[stack[-3]] = 0x01 + storage[stack[-3]] // @29BD memory[0x00:0x20] = stack[-3] // @29C8 storage[storage[stack[-3]] + keccak256(memory[0x00:0x20])] = stack[-2] // @29CD memory[0x00:0x20] = stack[-2] // @29D3 memory[0x20:0x40] = stack[-3] + 0x01 // @29DA stack[-1] = 0x01 // @29DB storage[keccak256(memory[0x00:0x40])] = storage[stack[-3]] // } // Block ends with unconditional jump to 0x07d7 label_29E0: // Incoming jump from 0x29AE, if storage[keccak256(memory[0x00:0x40])] 29E0 5B JUMPDEST 29E1 50 POP 29E2 60 PUSH1 0x00 29E4 61 PUSH2 0x07d7 29E7 56 *JUMP // Stack delta = +0 // Outputs[1] { @29E2 stack[-1] = 0x00 } // Block ends with unconditional jump to 0x07d7 label_29E8: // Incoming call from 0x230C, returns to 0x07D7 // Inputs[1] { @29F4 stack[-1] } 29E8 5B JUMPDEST 29E9 60 PUSH1 0x00 29EB 60 PUSH1 0x01 29ED 60 PUSH1 0x01 29EF 60 PUSH1 0xe0 29F1 1B SHL 29F2 03 SUB 29F3 19 NOT 29F4 82 DUP3 29F5 16 AND 29F6 63 PUSH4 0x80ac58cd 29FB 60 PUSH1 0xe0 29FD 1B SHL 29FE 14 EQ 29FF 80 DUP1 2A00 61 PUSH2 0x2a19 2A03 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @29E9 stack[0] = 0x00 // @29FE stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x2a19, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2A04: // Incoming jump from 0x2A03, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2A0E stack[-3] } 2A04 50 POP 2A05 60 PUSH1 0x01 2A07 60 PUSH1 0x01 2A09 60 PUSH1 0xe0 2A0B 1B SHL 2A0C 03 SUB 2A0D 19 NOT 2A0E 82 DUP3 2A0F 16 AND 2A10 63 PUSH4 0x5b5e139f 2A15 60 PUSH1 0xe0 2A17 1B SHL 2A18 14 EQ 2A19 5B JUMPDEST 2A1A 80 DUP1 2A1B 61 PUSH2 0x07d7 2A1E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2A18 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x07d7, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_2A1F: // Incoming jump from 0x2A1E, if not stack[-1] // Incoming jump from 0x2A1E, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2A31 stack[-3] } 2A1F 50 POP 2A20 63 PUSH4 0x01ffc9a7 2A25 60 PUSH1 0xe0 2A27 1B SHL 2A28 60 PUSH1 0x01 2A2A 60 PUSH1 0x01 2A2C 60 PUSH1 0xe0 2A2E 1B SHL 2A2F 03 SUB 2A30 19 NOT 2A31 83 DUP4 2A32 16 AND 2A33 14 EQ 2A34 61 PUSH2 0x07d7 2A37 56 *JUMP // Stack delta = +0 // Outputs[1] { @2A33 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x07d7 label_2A38: // Incoming call from 0x240A, returns to 0x0A56 // Inputs[3] // { // @2A3C stack[-3] // @2A3D stack[-2] // @2A3E stack[-1] // } 2A38 5B JUMPDEST 2A39 61 PUSH2 0x2a43 2A3C 83 DUP4 2A3D 83 DUP4 2A3E 83 DUP4 2A3F 61 PUSH2 0x2bca 2A42 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2A39 stack[0] = 0x2a43 // @2A3C stack[1] = stack[-3] // @2A3D stack[2] = stack[-2] // @2A3E stack[3] = stack[-1] // } // Block ends with call to 0x2bca, returns to 0x2A43 label_2A43: // Incoming return from call to 0x2BCA at 0x2A42 // Inputs[1] { @2A4C stack[-2] } 2A43 5B JUMPDEST 2A44 60 PUSH1 0x01 2A46 60 PUSH1 0x01 2A48 60 PUSH1 0xa0 2A4A 1B SHL 2A4B 03 SUB 2A4C 82 DUP3 2A4D 16 AND 2A4E 15 ISZERO 2A4F 80 DUP1 2A50 61 PUSH2 0x2a85 2A53 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A4E stack[0] = !(stack[-2] & (0x01 << 0xa0) - 0x01) } // Block ends with conditional jump to 0x2a85, if !(stack[-2] & (0x01 << 0xa0) - 0x01) label_2A54: // Incoming jump from 0x2A53, if not !(stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @2A5F stack[-3] // @2A6E memory[0x00:0x40] // @2A6F storage[keccak256(memory[0x00:0x40])] // } 2A54 50 POP 2A55 60 PUSH1 0x01 2A57 60 PUSH1 0x01 2A59 60 PUSH1 0x01 2A5B 60 PUSH1 0xa0 2A5D 1B SHL 2A5E 03 SUB 2A5F 83 DUP4 2A60 16 AND 2A61 60 PUSH1 0x00 2A63 90 SWAP1 2A64 81 DUP2 2A65 52 MSTORE 2A66 60 PUSH1 0x07 2A68 60 PUSH1 0x20 2A6A 52 MSTORE 2A6B 60 PUSH1 0x40 2A6D 90 SWAP1 2A6E 20 SHA3 2A6F 54 SLOAD 2A70 60 PUSH1 0xff 2A72 16 AND 2A73 60 PUSH1 0x01 2A75 81 DUP2 2A76 11 GT 2A77 15 ISZERO 2A78 61 PUSH2 0x2a83 2A7B 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2A55 stack[-1] = 0x01 // @2A65 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @2A6A memory[0x20:0x40] = 0x07 // @2A72 stack[0] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x2a83, if !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x01) label_2A7C: // Incoming jump from 0x2A7B, if not !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x01) 2A7C 61 PUSH2 0x2a83 2A7F 61 PUSH2 0x390d 2A82 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A7C stack[0] = 0x2a83 } // Block ends with unconditional jump to 0x390d label_2A83: // Incoming jump from 0x2A7B, if !(0xff & storage[keccak256(memory[0x00:0x40])] > 0x01) // Inputs[2] // { // @2A84 stack[-2] // @2A84 stack[-1] // } 2A83 5B JUMPDEST 2A84 14 EQ // Stack delta = -1 // Outputs[1] { @2A84 stack[-2] = stack[-1] == stack[-2] } // Block continues label_2A85: // Incoming jump from 0x2A53, if !(stack[-2] & (0x01 << 0xa0) - 0x01) // Incoming jump from 0x2A84 // Inputs[1] { @2A86 stack[-1] } 2A85 5B JUMPDEST 2A86 15 ISZERO 2A87 61 PUSH2 0x2a8f 2A8A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2a8f, if !stack[-1] label_2A8B: // Incoming jump from 0x2A8A, if not !stack[-1] // Inputs[1] { @2A8E stack[-4] } 2A8B 50 POP 2A8C 50 POP 2A8D 50 POP 2A8E 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_2A8F: // Incoming jump from 0x2A8A, if !stack[-1] // Inputs[1] { @2A95 stack[-2] } 2A8F 5B JUMPDEST 2A90 60 PUSH1 0x00 2A92 61 PUSH2 0x2a9a 2A95 83 DUP4 2A96 61 PUSH2 0x2615 2A99 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A90 stack[0] = 0x00 // @2A92 stack[1] = 0x2a9a // @2A95 stack[2] = stack[-2] // } // Block ends with call to 0x2615, returns to 0x2A9A label_2A9A: // Incoming return from call to 0x2615 at 0x2A99 // Inputs[2] // { // @2A9B stack[-1] // @2A9B stack[-2] // } 2A9A 5B JUMPDEST 2A9B 90 SWAP1 2A9C 50 POP 2A9D 60 PUSH1 0x01 2A9F 60 PUSH1 0x01 2AA1 60 PUSH1 0xa0 2AA3 1B SHL 2AA4 03 SUB 2AA5 81 DUP2 2AA6 16 AND 2AA7 61 PUSH2 0x2ad1 2AAA 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2A9B stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2ad1, if stack[-1] & (0x01 << 0xa0) - 0x01 label_2AAB: // Incoming jump from 0x2AAA, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @2AB5 stack[-3] // @2AC3 memory[0x00:0x40] // @2AC5 storage[keccak256(memory[0x00:0x40])] // @2AD0 stack[-5] // } 2AAB 50 POP 2AAC 50 POP 2AAD 60 PUSH1 0x01 2AAF 60 PUSH1 0x01 2AB1 60 PUSH1 0xa0 2AB3 1B SHL 2AB4 03 SUB 2AB5 16 AND 2AB6 60 PUSH1 0x00 2AB8 90 SWAP1 2AB9 81 DUP2 2ABA 52 MSTORE 2ABB 60 PUSH1 0x07 2ABD 60 PUSH1 0x20 2ABF 52 MSTORE 2AC0 60 PUSH1 0x40 2AC2 90 SWAP1 2AC3 20 SHA3 2AC4 80 DUP1 2AC5 54 SLOAD 2AC6 60 PUSH1 0xff 2AC8 19 NOT 2AC9 16 AND 2ACA 60 PUSH1 0x01 2ACC 17 OR 2ACD 90 SWAP1 2ACE 55 SSTORE 2ACF 50 POP 2AD0 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @2ABA memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @2ABF memory[0x20:0x40] = 0x07 // @2ACE storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-5] label_2AD1: // Incoming jump from 0x2AAA, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2AD5 stack[-3] } 2AD1 5B JUMPDEST 2AD2 61 PUSH2 0x2ada 2AD5 83 DUP4 2AD6 61 PUSH2 0x0efc 2AD9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2AD2 stack[0] = 0x2ada // @2AD5 stack[1] = stack[-3] // } // Block ends with call to 0x0efc, returns to 0x2ADA label_2ADA: // Incoming return from call to 0x0EFC at 0x2AD9 // Inputs[1] { @2ADE stack[-1] } 2ADA 5B JUMPDEST 2ADB 61 PUSH2 0x10f6 2ADE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x10f6, if stack[-1] label_2ADF: // Incoming jump from 0x2ADE, if not stack[-1] // Inputs[3] // { // @2ADF stack[-1] // @2AE9 stack[-3] // @2B18 memory[0x40:0x60] // } 2ADF 80 DUP1 2AE0 60 PUSH1 0x01 2AE2 60 PUSH1 0x01 2AE4 60 PUSH1 0xa0 2AE6 1B SHL 2AE7 03 SUB 2AE8 16 AND 2AE9 83 DUP4 2AEA 60 PUSH1 0x01 2AEC 60 PUSH1 0x01 2AEE 60 PUSH1 0xa0 2AF0 1B SHL 2AF1 03 SUB 2AF2 16 AND 2AF3 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 2B14 60 PUSH1 0x01 2B16 60 PUSH1 0x40 2B18 51 MLOAD 2B19 61 PUSH2 0x2b26 2B1C 91 SWAP2 2B1D 15 ISZERO 2B1E 15 ISZERO 2B1F 81 DUP2 2B20 52 MSTORE 2B21 60 PUSH1 0x20 2B23 01 ADD 2B24 90 SWAP1 2B25 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2AE8 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2AF2 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-3] // @2AF3 stack[2] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @2B20 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!0x01 // @2B24 stack[3] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2b26 label_2B26: // Incoming jump from 0x2B25 // Inputs[7] // { // @2B29 memory[0x40:0x60] // @2B2B stack[-1] // @2B2E stack[-2] // @2B2E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @2B2E stack[-4] // @2B2E stack[-3] // @2B33 stack[-9] // } 2B26 5B JUMPDEST 2B27 60 PUSH1 0x40 2B29 51 MLOAD 2B2A 80 DUP1 2B2B 91 SWAP2 2B2C 03 SUB 2B2D 90 SWAP1 2B2E A3 LOG3 2B2F 50 POP 2B30 50 POP 2B31 50 POP 2B32 50 POP 2B33 56 *JUMP // Stack delta = -9 // Outputs[1] { @2B2E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-9] 2B34 5B JUMPDEST 2B35 60 PUSH1 0x00 2B37 61 PUSH2 0x24f3 2B3A 61 PUSH2 0x2b79 2B3D 85 DUP6 2B3E 85 DUP6 2B3F 85 DUP6 2B40 80 DUP1 2B41 80 DUP1 2B42 60 PUSH1 0x1f 2B44 01 ADD 2B45 60 PUSH1 0x20 2B47 80 DUP1 2B48 91 SWAP2 2B49 04 DIV 2B4A 02 MUL 2B4B 60 PUSH1 0x20 2B4D 01 ADD 2B4E 60 PUSH1 0x40 2B50 51 MLOAD 2B51 90 SWAP1 2B52 81 DUP2 2B53 01 ADD 2B54 60 PUSH1 0x40 2B56 52 MSTORE 2B57 80 DUP1 2B58 93 SWAP4 2B59 92 SWAP3 2B5A 91 SWAP2 2B5B 90 SWAP1 2B5C 81 DUP2 2B5D 81 DUP2 2B5E 52 MSTORE 2B5F 60 PUSH1 0x20 2B61 01 ADD 2B62 83 DUP4 2B63 83 DUP4 2B64 80 DUP1 2B65 82 DUP3 2B66 84 DUP5 2B67 37 CALLDATACOPY 2B68 60 PUSH1 0x00 2B6A 92 SWAP3 2B6B 01 ADD 2B6C 91 SWAP2 2B6D 90 SWAP1 2B6E 91 SWAP2 2B6F 52 MSTORE 2B70 50 POP 2B71 61 PUSH2 0x2c38 2B74 92 SWAP3 2B75 50 POP 2B76 50 POP 2B77 50 POP 2B78 56 *JUMP 2B79 5B JUMPDEST 2B7A 86 DUP7 2B7B 90 SWAP1 2B7C 61 PUSH2 0x2c5c 2B7F 56 *JUMP label_2B80: // Incoming call from 0x294A, returns to 0x081A // Inputs[1] { @2B88 storage[0x08] } 2B80 5B JUMPDEST 2B81 60 PUSH1 0x00 2B83 61 PUSH2 0x2b8b 2B86 60 PUSH1 0x08 2B88 54 SLOAD 2B89 90 SWAP1 2B8A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2B81 stack[0] = 0x00 // @2B89 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x2b8b label_2B8B: // Incoming jump from 0x2B8A // Inputs[3] // { // @2B8C stack[-2] // @2B8C stack[-1] // @2B93 stack[-4] // } 2B8B 5B JUMPDEST 2B8C 90 SWAP1 2B8D 50 POP 2B8E 60 PUSH1 0x00 2B90 61 PUSH2 0x2b99 2B93 84 DUP5 2B94 83 DUP4 2B95 61 PUSH2 0x38b0 2B98 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2B8C stack[-2] = stack[-1] // @2B8E stack[-1] = 0x00 // @2B90 stack[0] = 0x2b99 // @2B93 stack[1] = stack[-4] // @2B94 stack[2] = stack[-1] // } // Block ends with call to 0x38b0, returns to 0x2B99 label_2B99: // Incoming return from call to 0x38B0 at 0x2B98 // Inputs[3] // { // @2B9A stack[-1] // @2B9A stack[-2] // @2B9E stack[-3] // } 2B99 5B JUMPDEST 2B9A 90 SWAP1 2B9B 50 POP 2B9C 5B JUMPDEST 2B9D 80 DUP1 2B9E 82 DUP3 2B9F 10 LT 2BA0 15 ISZERO 2BA1 61 PUSH2 0x2bbf 2BA4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2B9A stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2bbf, if !(stack[-3] < stack[-1]) label_2BA5: // Incoming jump from 0x2BA4, if not !(stack[-3] < stack[-1]) // Inputs[3] // { // @2BA8 stack[-5] // @2BA9 stack[-2] // @2BAA stack[-3] // } 2BA5 61 PUSH2 0x2baf 2BA8 85 DUP6 2BA9 83 DUP4 2BAA 85 DUP6 2BAB 61 PUSH2 0x2c7e 2BAE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2BA5 stack[0] = 0x2baf // @2BA8 stack[1] = stack[-5] // @2BA9 stack[2] = stack[-2] // @2BAA stack[3] = stack[-3] // } // Block ends with unconditional jump to 0x2c7e 2BAF 5B JUMPDEST 2BB0 61 PUSH2 0x2bb8 2BB3 82 DUP3 2BB4 61 PUSH2 0x3975 2BB7 56 *JUMP 2BB8 5B JUMPDEST 2BB9 91 SWAP2 2BBA 50 POP 2BBB 61 PUSH2 0x2b9c 2BBE 56 *JUMP label_2BBF: // Incoming jump from 0x2BA4, if !(stack[-3] < stack[-1]) // Inputs[1] { @2BC5 stack[-4] } 2BBF 5B JUMPDEST 2BC0 61 PUSH2 0x1063 2BC3 60 PUSH1 0x08 2BC5 85 DUP6 2BC6 61 PUSH2 0x2151 2BC9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2BC0 stack[0] = 0x1063 // @2BC3 stack[1] = 0x08 // @2BC5 stack[2] = stack[-4] // } // Block ends with call to 0x2151, returns to 0x1063 label_2BCA: // Incoming call from 0x2A42, returns to 0x2A43 // Inputs[1] { @2BCD storage[0x06] } 2BCA 5B JUMPDEST 2BCB 60 PUSH1 0x06 2BCD 54 SLOAD 2BCE 60 PUSH1 0x01 2BD0 60 PUSH1 0xa0 2BD2 1B SHL 2BD3 90 SWAP1 2BD4 04 DIV 2BD5 60 PUSH1 0xff 2BD7 16 AND 2BD8 15 ISZERO 2BD9 61 PUSH2 0x0a56 2BDC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a56, if !(0xff & storage[0x06] / (0x01 << 0xa0)) label_2BDD: // Incoming jump from 0x2BDC, if not !(0xff & storage[0x06] / (0x01 << 0xa0)) // Inputs[1] { @2BDF memory[0x40:0x60] } 2BDD 60 PUSH1 0x40 2BDF 51 MLOAD 2BE0 62 PUSH3 0x461bcd 2BE4 60 PUSH1 0xe5 2BE6 1B SHL 2BE7 81 DUP2 2BE8 52 MSTORE 2BE9 60 PUSH1 0x20 2BEB 60 PUSH1 0x04 2BED 82 DUP3 2BEE 01 ADD 2BEF 52 MSTORE 2BF0 60 PUSH1 0x2b 2BF2 60 PUSH1 0x24 2BF4 82 DUP3 2BF5 01 ADD 2BF6 52 MSTORE 2BF7 7F PUSH32 0x4552433732315061757361626c653a20746f6b656e207472616e736665722077 2C18 60 PUSH1 0x44 2C1A 82 DUP3 2C1B 01 ADD 2C1C 52 MSTORE 2C1D 6A PUSH11 0x1a1a5b19481c185d5cd959 2C29 60 PUSH1 0xaa 2C2B 1B SHL 2C2C 60 PUSH1 0x64 2C2E 82 DUP3 2C2F 01 ADD 2C30 52 MSTORE 2C31 60 PUSH1 0x84 2C33 01 ADD 2C34 61 PUSH2 0x0807 2C37 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2BE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2BEF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2BF6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @2C1C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315061757361626c653a20746f6b656e207472616e736665722077 // @2C30 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x1a1a5b19481c185d5cd959 << 0xaa // @2C33 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 2C38 5B JUMPDEST 2C39 60 PUSH1 0x00 2C3B 80 DUP1 2C3C 60 PUSH1 0x00 2C3E 61 PUSH2 0x2c47 2C41 85 DUP6 2C42 85 DUP6 2C43 61 PUSH2 0x2cb1 2C46 56 *JUMP 2C47 5B JUMPDEST 2C48 91 SWAP2 2C49 50 POP 2C4A 91 SWAP2 2C4B 50 POP 2C4C 61 PUSH2 0x2c54 2C4F 81 DUP2 2C50 61 PUSH2 0x2d1e 2C53 56 *JUMP 2C54 5B JUMPDEST 2C55 50 POP 2C56 93 SWAP4 2C57 92 SWAP3 2C58 50 POP 2C59 50 POP 2C5A 50 POP 2C5B 56 *JUMP 2C5C 5B JUMPDEST 2C5D 60 PUSH1 0x01 2C5F 60 PUSH1 0x01 2C61 60 PUSH1 0xa0 2C63 1B SHL 2C64 03 SUB 2C65 81 DUP2 2C66 16 AND 2C67 60 PUSH1 0x00 2C69 90 SWAP1 2C6A 81 DUP2 2C6B 52 MSTORE 2C6C 60 PUSH1 0x01 2C6E 83 DUP4 2C6F 01 ADD 2C70 60 PUSH1 0x20 2C72 52 MSTORE 2C73 60 PUSH1 0x40 2C75 81 DUP2 2C76 20 SHA3 2C77 54 SLOAD 2C78 15 ISZERO 2C79 15 ISZERO 2C7A 61 PUSH2 0x0e2f 2C7D 56 *JUMP label_2C7E: // Incoming jump from 0x2BAE // Inputs[2] // { // @2C82 stack[-3] // @2C83 stack[-2] // } 2C7E 5B JUMPDEST 2C7F 61 PUSH2 0x2c88 2C82 83 DUP4 2C83 83 DUP4 2C84 61 PUSH2 0x2ed9 2C87 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C7F stack[0] = 0x2c88 // @2C82 stack[1] = stack[-3] // @2C83 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x2ed9 2C88 5B JUMPDEST 2C89 61 PUSH2 0x2c95 2C8C 60 PUSH1 0x00 2C8E 84 DUP5 2C8F 84 DUP5 2C90 84 DUP5 2C91 61 PUSH2 0x2833 2C94 56 *JUMP 2C95 5B JUMPDEST 2C96 61 PUSH2 0x0a56 2C99 57 *JUMPI 2C9A 60 PUSH1 0x40 2C9C 51 MLOAD 2C9D 62 PUSH3 0x461bcd 2CA1 60 PUSH1 0xe5 2CA3 1B SHL 2CA4 81 DUP2 2CA5 52 MSTORE 2CA6 60 PUSH1 0x04 2CA8 01 ADD 2CA9 61 PUSH2 0x0807 2CAC 90 SWAP1 2CAD 61 PUSH2 0x3923 2CB0 56 *JUMP 2CB1 5B JUMPDEST 2CB2 60 PUSH1 0x00 2CB4 80 DUP1 2CB5 82 DUP3 2CB6 51 MLOAD 2CB7 60 PUSH1 0x41 2CB9 14 EQ 2CBA 15 ISZERO 2CBB 61 PUSH2 0x2ce8 2CBE 57 *JUMPI 2CBF 60 PUSH1 0x20 2CC1 83 DUP4 2CC2 01 ADD 2CC3 51 MLOAD 2CC4 60 PUSH1 0x40 2CC6 84 DUP5 2CC7 01 ADD 2CC8 51 MLOAD 2CC9 60 PUSH1 0x60 2CCB 85 DUP6 2CCC 01 ADD 2CCD 51 MLOAD 2CCE 60 PUSH1 0x00 2CD0 1A BYTE 2CD1 61 PUSH2 0x2cdc 2CD4 87 DUP8 2CD5 82 DUP3 2CD6 85 DUP6 2CD7 85 DUP6 2CD8 61 PUSH2 0x3027 2CDB 56 *JUMP 2CDC 5B JUMPDEST 2CDD 94 SWAP5 2CDE 50 POP 2CDF 94 SWAP5 2CE0 50 POP 2CE1 50 POP 2CE2 50 POP 2CE3 50 POP 2CE4 61 PUSH2 0x0bf1 2CE7 56 *JUMP 2CE8 5B JUMPDEST 2CE9 82 DUP3 2CEA 51 MLOAD 2CEB 60 PUSH1 0x40 2CED 14 EQ 2CEE 15 ISZERO 2CEF 61 PUSH2 0x2d12 2CF2 57 *JUMPI 2CF3 60 PUSH1 0x20 2CF5 83 DUP4 2CF6 01 ADD 2CF7 51 MLOAD 2CF8 60 PUSH1 0x40 2CFA 84 DUP5 2CFB 01 ADD 2CFC 51 MLOAD 2CFD 61 PUSH2 0x2d07 2D00 86 DUP7 2D01 83 DUP4 2D02 83 DUP4 2D03 61 PUSH2 0x3114 2D06 56 *JUMP 2D07 5B JUMPDEST 2D08 93 SWAP4 2D09 50 POP 2D0A 93 SWAP4 2D0B 50 POP 2D0C 50 POP 2D0D 50 POP 2D0E 61 PUSH2 0x0bf1 2D11 56 *JUMP 2D12 5B JUMPDEST 2D13 50 POP 2D14 60 PUSH1 0x00 2D16 90 SWAP1 2D17 50 POP 2D18 60 PUSH1 0x02 2D1A 61 PUSH2 0x0bf1 2D1D 56 *JUMP 2D1E 5B JUMPDEST 2D1F 60 PUSH1 0x00 2D21 81 DUP2 2D22 60 PUSH1 0x04 2D24 81 DUP2 2D25 11 GT 2D26 15 ISZERO 2D27 61 PUSH2 0x2d32 2D2A 57 *JUMPI 2D2B 61 PUSH2 0x2d32 2D2E 61 PUSH2 0x390d 2D31 56 *JUMP 2D32 5B JUMPDEST 2D33 14 EQ 2D34 15 ISZERO 2D35 61 PUSH2 0x2d3b 2D38 57 *JUMPI 2D39 50 POP 2D3A 56 *JUMP 2D3B 5B JUMPDEST 2D3C 60 PUSH1 0x01 2D3E 81 DUP2 2D3F 60 PUSH1 0x04 2D41 81 DUP2 2D42 11 GT 2D43 15 ISZERO 2D44 61 PUSH2 0x2d4f 2D47 57 *JUMPI 2D48 61 PUSH2 0x2d4f 2D4B 61 PUSH2 0x390d 2D4E 56 *JUMP 2D4F 5B JUMPDEST 2D50 14 EQ 2D51 15 ISZERO 2D52 61 PUSH2 0x2d9d 2D55 57 *JUMPI 2D56 60 PUSH1 0x40 2D58 51 MLOAD 2D59 62 PUSH3 0x461bcd 2D5D 60 PUSH1 0xe5 2D5F 1B SHL 2D60 81 DUP2 2D61 52 MSTORE 2D62 60 PUSH1 0x20 2D64 60 PUSH1 0x04 2D66 82 DUP3 2D67 01 ADD 2D68 52 MSTORE 2D69 60 PUSH1 0x18 2D6B 60 PUSH1 0x24 2D6D 82 DUP3 2D6E 01 ADD 2D6F 52 MSTORE 2D70 7F PUSH32 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 2D91 60 PUSH1 0x44 2D93 82 DUP3 2D94 01 ADD 2D95 52 MSTORE 2D96 60 PUSH1 0x64 2D98 01 ADD 2D99 61 PUSH2 0x0807 2D9C 56 *JUMP 2D9D 5B JUMPDEST 2D9E 60 PUSH1 0x02 2DA0 81 DUP2 2DA1 60 PUSH1 0x04 2DA3 81 DUP2 2DA4 11 GT 2DA5 15 ISZERO 2DA6 61 PUSH2 0x2db1 2DA9 57 *JUMPI 2DAA 61 PUSH2 0x2db1 2DAD 61 PUSH2 0x390d 2DB0 56 *JUMP 2DB1 5B JUMPDEST 2DB2 14 EQ 2DB3 15 ISZERO 2DB4 61 PUSH2 0x2dff 2DB7 57 *JUMPI 2DB8 60 PUSH1 0x40 2DBA 51 MLOAD 2DBB 62 PUSH3 0x461bcd 2DBF 60 PUSH1 0xe5 2DC1 1B SHL 2DC2 81 DUP2 2DC3 52 MSTORE 2DC4 60 PUSH1 0x20 2DC6 60 PUSH1 0x04 2DC8 82 DUP3 2DC9 01 ADD 2DCA 52 MSTORE 2DCB 60 PUSH1 0x1f 2DCD 60 PUSH1 0x24 2DCF 82 DUP3 2DD0 01 ADD 2DD1 52 MSTORE 2DD2 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 2DF3 60 PUSH1 0x44 2DF5 82 DUP3 2DF6 01 ADD 2DF7 52 MSTORE 2DF8 60 PUSH1 0x64 2DFA 01 ADD 2DFB 61 PUSH2 0x0807 2DFE 56 *JUMP 2DFF 5B JUMPDEST 2E00 60 PUSH1 0x03 2E02 81 DUP2 2E03 60 PUSH1 0x04 2E05 81 DUP2 2E06 11 GT 2E07 15 ISZERO 2E08 61 PUSH2 0x2e13 2E0B 57 *JUMPI 2E0C 61 PUSH2 0x2e13 2E0F 61 PUSH2 0x390d 2E12 56 *JUMP 2E13 5B JUMPDEST 2E14 14 EQ 2E15 15 ISZERO 2E16 61 PUSH2 0x2e6c 2E19 57 *JUMPI 2E1A 60 PUSH1 0x40 2E1C 51 MLOAD 2E1D 62 PUSH3 0x461bcd 2E21 60 PUSH1 0xe5 2E23 1B SHL 2E24 81 DUP2 2E25 52 MSTORE 2E26 60 PUSH1 0x20 2E28 60 PUSH1 0x04 2E2A 82 DUP3 2E2B 01 ADD 2E2C 52 MSTORE 2E2D 60 PUSH1 0x22 2E2F 60 PUSH1 0x24 2E31 82 DUP3 2E32 01 ADD 2E33 52 MSTORE 2E34 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 2E55 60 PUSH1 0x44 2E57 82 DUP3 2E58 01 ADD 2E59 52 MSTORE 2E5A 61 PUSH2 0x7565 2E5D 60 PUSH1 0xf0 2E5F 1B SHL 2E60 60 PUSH1 0x64 2E62 82 DUP3 2E63 01 ADD 2E64 52 MSTORE 2E65 60 PUSH1 0x84 2E67 01 ADD 2E68 61 PUSH2 0x0807 2E6B 56 *JUMP 2E6C 5B JUMPDEST 2E6D 60 PUSH1 0x04 2E6F 81 DUP2 2E70 60 PUSH1 0x04 2E72 81 DUP2 2E73 11 GT 2E74 15 ISZERO 2E75 61 PUSH2 0x2e80 2E78 57 *JUMPI 2E79 61 PUSH2 0x2e80 2E7C 61 PUSH2 0x390d 2E7F 56 *JUMP 2E80 5B JUMPDEST 2E81 14 EQ 2E82 15 ISZERO 2E83 61 PUSH2 0x14e1 2E86 57 *JUMPI 2E87 60 PUSH1 0x40 2E89 51 MLOAD 2E8A 62 PUSH3 0x461bcd 2E8E 60 PUSH1 0xe5 2E90 1B SHL 2E91 81 DUP2 2E92 52 MSTORE 2E93 60 PUSH1 0x20 2E95 60 PUSH1 0x04 2E97 82 DUP3 2E98 01 ADD 2E99 52 MSTORE 2E9A 60 PUSH1 0x22 2E9C 60 PUSH1 0x24 2E9E 82 DUP3 2E9F 01 ADD 2EA0 52 MSTORE 2EA1 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 2EC2 60 PUSH1 0x44 2EC4 82 DUP3 2EC5 01 ADD 2EC6 52 MSTORE 2EC7 61 PUSH2 0x7565 2ECA 60 PUSH1 0xf0 2ECC 1B SHL 2ECD 60 PUSH1 0x64 2ECF 82 DUP3 2ED0 01 ADD 2ED1 52 MSTORE 2ED2 60 PUSH1 0x84 2ED4 01 ADD 2ED5 61 PUSH2 0x0807 2ED8 56 *JUMP label_2ED9: // Incoming jump from 0x2C87 // Inputs[1] { @2EE2 stack[-2] } 2ED9 5B JUMPDEST 2EDA 60 PUSH1 0x01 2EDC 60 PUSH1 0x01 2EDE 60 PUSH1 0xa0 2EE0 1B SHL 2EE1 03 SUB 2EE2 82 DUP3 2EE3 16 AND 2EE4 61 PUSH2 0x2f2f 2EE7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2f2f, if stack[-2] & (0x01 << 0xa0) - 0x01 label_2EE8: // Incoming jump from 0x2EE7, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2EEA memory[0x40:0x60] } 2EE8 60 PUSH1 0x40 2EEA 51 MLOAD 2EEB 62 PUSH3 0x461bcd 2EEF 60 PUSH1 0xe5 2EF1 1B SHL 2EF2 81 DUP2 2EF3 52 MSTORE 2EF4 60 PUSH1 0x20 2EF6 60 PUSH1 0x04 2EF8 82 DUP3 2EF9 01 ADD 2EFA 81 DUP2 2EFB 90 SWAP1 2EFC 52 MSTORE 2EFD 60 PUSH1 0x24 2EFF 82 DUP3 2F00 01 ADD 2F01 52 MSTORE 2F02 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 2F23 60 PUSH1 0x44 2F25 82 DUP3 2F26 01 ADD 2F27 52 MSTORE 2F28 60 PUSH1 0x64 2F2A 01 ADD 2F2B 61 PUSH2 0x0807 2F2E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2EF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2EFC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2F01 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @2F27 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @2F2A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_2F2F: // Incoming jump from 0x2EE7, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2F32 stack[-1] // @2F3D memory[0x00:0x40] // @2F3E storage[keccak256(memory[0x00:0x40])] // } 2F2F 5B JUMPDEST 2F30 60 PUSH1 0x00 2F32 81 DUP2 2F33 81 DUP2 2F34 52 MSTORE 2F35 60 PUSH1 0x02 2F37 60 PUSH1 0x20 2F39 52 MSTORE 2F3A 60 PUSH1 0x40 2F3C 90 SWAP1 2F3D 20 SHA3 2F3E 54 SLOAD 2F3F 60 PUSH1 0x01 2F41 60 PUSH1 0x01 2F43 60 PUSH1 0xa0 2F45 1B SHL 2F46 03 SUB 2F47 16 AND 2F48 15 ISZERO 2F49 61 PUSH2 0x2f94 2F4C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2F34 memory[0x00:0x20] = stack[-1] // @2F39 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x2f94, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_2F4D: // Incoming jump from 0x2F4C, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @2F4F memory[0x40:0x60] } 2F4D 60 PUSH1 0x40 2F4F 51 MLOAD 2F50 62 PUSH3 0x461bcd 2F54 60 PUSH1 0xe5 2F56 1B SHL 2F57 81 DUP2 2F58 52 MSTORE 2F59 60 PUSH1 0x20 2F5B 60 PUSH1 0x04 2F5D 82 DUP3 2F5E 01 ADD 2F5F 52 MSTORE 2F60 60 PUSH1 0x1c 2F62 60 PUSH1 0x24 2F64 82 DUP3 2F65 01 ADD 2F66 52 MSTORE 2F67 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 2F88 60 PUSH1 0x44 2F8A 82 DUP3 2F8B 01 ADD 2F8C 52 MSTORE 2F8D 60 PUSH1 0x64 2F8F 01 ADD 2F90 61 PUSH2 0x0807 2F93 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2F58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2F5F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2F66 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @2F8C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @2F8F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0807 label_2F94: // Incoming jump from 0x2F4C, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @2F9A stack[-2] // @2F9B stack[-1] // } 2F94 5B JUMPDEST 2F95 61 PUSH2 0x2fa0 2F98 60 PUSH1 0x00 2F9A 83 DUP4 2F9B 83 DUP4 2F9C 61 PUSH2 0x2400 2F9F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2F95 stack[0] = 0x2fa0 // @2F98 stack[1] = 0x00 // @2F9A stack[2] = stack[-2] // @2F9B stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x2400 2FA0 5B JUMPDEST 2FA1 60 PUSH1 0x01 2FA3 60 PUSH1 0x01 2FA5 60 PUSH1 0xa0 2FA7 1B SHL 2FA8 03 SUB 2FA9 82 DUP3 2FAA 16 AND 2FAB 60 PUSH1 0x00 2FAD 90 SWAP1 2FAE 81 DUP2 2FAF 52 MSTORE 2FB0 60 PUSH1 0x03 2FB2 60 PUSH1 0x20 2FB4 52 MSTORE 2FB5 60 PUSH1 0x40 2FB7 81 DUP2 2FB8 20 SHA3 2FB9 80 DUP1 2FBA 54 SLOAD 2FBB 60 PUSH1 0x01 2FBD 92 SWAP3 2FBE 90 SWAP1 2FBF 61 PUSH2 0x2fc9 2FC2 90 SWAP1 2FC3 84 DUP5 2FC4 90 SWAP1 2FC5 61 PUSH2 0x38b0 2FC8 56 *JUMP 2FC9 5B JUMPDEST 2FCA 90 SWAP1 2FCB 91 SWAP2 2FCC 55 SSTORE 2FCD 50 POP 2FCE 50 POP 2FCF 60 PUSH1 0x00 2FD1 81 DUP2 2FD2 81 DUP2 2FD3 52 MSTORE 2FD4 60 PUSH1 0x02 2FD6 60 PUSH1 0x20 2FD8 52 MSTORE 2FD9 60 PUSH1 0x40 2FDB 80 DUP1 2FDC 82 DUP3 2FDD 20 SHA3 2FDE 80 DUP1 2FDF 54 SLOAD 2FE0 60 PUSH1 0x01 2FE2 60 PUSH1 0x01 2FE4 60 PUSH1 0xa0 2FE6 1B SHL 2FE7 03 SUB 2FE8 19 NOT 2FE9 16 AND 2FEA 60 PUSH1 0x01 2FEC 60 PUSH1 0x01 2FEE 60 PUSH1 0xa0 2FF0 1B SHL 2FF1 03 SUB 2FF2 86 DUP7 2FF3 16 AND 2FF4 90 SWAP1 2FF5 81 DUP2 2FF6 17 OR 2FF7 90 SWAP1 2FF8 91 SWAP2 2FF9 55 SSTORE 2FFA 90 SWAP1 2FFB 51 MLOAD 2FFC 83 DUP4 2FFD 92 SWAP3 2FFE 90 SWAP1 2FFF 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 3020 90 SWAP1 3021 82 DUP3 3022 90 SWAP1 3023 A4 LOG4 3024 50 POP 3025 50 POP 3026 56 *JUMP 3027 5B JUMPDEST 3028 60 PUSH1 0x00 302A 80 DUP1 302B 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 304C 83 DUP4 304D 11 GT 304E 15 ISZERO 304F 61 PUSH2 0x305e 3052 57 *JUMPI 3053 50 POP 3054 60 PUSH1 0x00 3056 90 SWAP1 3057 50 POP 3058 60 PUSH1 0x03 305A 61 PUSH2 0x310b 305D 56 *JUMP 305E 5B JUMPDEST 305F 84 DUP5 3060 60 PUSH1 0xff 3062 16 AND 3063 60 PUSH1 0x1b 3065 14 EQ 3066 15 ISZERO 3067 80 DUP1 3068 15 ISZERO 3069 61 PUSH2 0x3076 306C 57 *JUMPI 306D 50 POP 306E 84 DUP5 306F 60 PUSH1 0xff 3071 16 AND 3072 60 PUSH1 0x1c 3074 14 EQ 3075 15 ISZERO 3076 5B JUMPDEST 3077 15 ISZERO 3078 61 PUSH2 0x3087 307B 57 *JUMPI 307C 50 POP 307D 60 PUSH1 0x00 307F 90 SWAP1 3080 50 POP 3081 60 PUSH1 0x04 3083 61 PUSH2 0x310b 3086 56 *JUMP 3087 5B JUMPDEST 3088 60 PUSH1 0x40 308A 80 DUP1 308B 51 MLOAD 308C 60 PUSH1 0x00 308E 80 DUP1 308F 82 DUP3 3090 52 MSTORE 3091 60 PUSH1 0x20 3093 82 DUP3 3094 01 ADD 3095 80 DUP1 3096 84 DUP5 3097 52 MSTORE 3098 89 DUP10 3099 90 SWAP1 309A 52 MSTORE 309B 60 PUSH1 0xff 309D 88 DUP9 309E 16 AND 309F 92 SWAP3 30A0 82 DUP3 30A1 01 ADD 30A2 92 SWAP3 30A3 90 SWAP1 30A4 92 SWAP3 30A5 52 MSTORE 30A6 60 PUSH1 0x60 30A8 81 DUP2 30A9 01 ADD 30AA 86 DUP7 30AB 90 SWAP1 30AC 52 MSTORE 30AD 60 PUSH1 0x80 30AF 81 DUP2 30B0 01 ADD 30B1 85 DUP6 30B2 90 SWAP1 30B3 52 MSTORE 30B4 60 PUSH1 0x01 30B6 90 SWAP1 30B7 60 PUSH1 0xa0 30B9 01 ADD 30BA 60 PUSH1 0x20 30BC 60 PUSH1 0x40 30BE 51 MLOAD 30BF 60 PUSH1 0x20 30C1 81 DUP2 30C2 03 SUB 30C3 90 SWAP1 30C4 80 DUP1 30C5 84 DUP5 30C6 03 SUB 30C7 90 SWAP1 30C8 85 DUP6 30C9 5A GAS 30CA FA STATICCALL 30CB 15 ISZERO 30CC 80 DUP1 30CD 15 ISZERO 30CE 61 PUSH2 0x30db 30D1 57 *JUMPI 30D2 3D RETURNDATASIZE 30D3 60 PUSH1 0x00 30D5 80 DUP1 30D6 3E RETURNDATACOPY 30D7 3D RETURNDATASIZE 30D8 60 PUSH1 0x00 30DA FD *REVERT 30DB 5B JUMPDEST 30DC 50 POP 30DD 50 POP 30DE 60 PUSH1 0x40 30E0 51 MLOAD 30E1 60 PUSH1 0x1f 30E3 19 NOT 30E4 01 ADD 30E5 51 MLOAD 30E6 91 SWAP2 30E7 50 POP 30E8 50 POP 30E9 60 PUSH1 0x01 30EB 60 PUSH1 0x01 30ED 60 PUSH1 0xa0 30EF 1B SHL 30F0 03 SUB 30F1 81 DUP2 30F2 16 AND 30F3 61 PUSH2 0x3104 30F6 57 *JUMPI 30F7 60 PUSH1 0x00 30F9 60 PUSH1 0x01 30FB 92 SWAP3 30FC 50 POP 30FD 92 SWAP3 30FE 50 POP 30FF 50 POP 3100 61 PUSH2 0x310b 3103 56 *JUMP 3104 5B JUMPDEST 3105 91 SWAP2 3106 50 POP 3107 60 PUSH1 0x00 3109 90 SWAP1 310A 50 POP 310B 5B JUMPDEST 310C 94 SWAP5 310D 50 POP 310E 94 SWAP5 310F 92 SWAP3 3110 50 POP 3111 50 POP 3112 50 POP 3113 56 *JUMP 3114 5B JUMPDEST 3115 60 PUSH1 0x00 3117 80 DUP1 3118 60 PUSH1 0x01 311A 60 PUSH1 0x01 311C 60 PUSH1 0xff 311E 1B SHL 311F 03 SUB 3120 83 DUP4 3121 16 AND 3122 81 DUP2 3123 61 PUSH2 0x3131 3126 60 PUSH1 0xff 3128 86 DUP7 3129 90 SWAP1 312A 1C SHR 312B 60 PUSH1 0x1b 312D 61 PUSH2 0x38b0 3130 56 *JUMP 3131 5B JUMPDEST 3132 90 SWAP1 3133 50 POP 3134 61 PUSH2 0x313f 3137 87 DUP8 3138 82 DUP3 3139 88 DUP9 313A 85 DUP6 313B 61 PUSH2 0x3027 313E 56 *JUMP 313F 5B JUMPDEST 3140 93 SWAP4 3141 50 POP 3142 93 SWAP4 3143 50 POP 3144 50 POP 3145 50 POP 3146 93 SWAP4 3147 50 POP 3148 93 SWAP4 3149 91 SWAP2 314A 50 POP 314B 50 POP 314C 56 *JUMP label_314D: // Incoming jump from 0x0E22 // Inputs[2] // { // @314E stack[-3] // @3150 storage[stack[-3]] // } 314D 5B JUMPDEST 314E 82 DUP3 314F 80 DUP1 3150 54 SLOAD 3151 61 PUSH2 0x3159 3154 90 SWAP1 3155 61 PUSH2 0x373f 3158 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @314E stack[0] = stack[-3] // @3154 stack[1] = 0x3159 // @3154 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x373f, returns to 0x3159 label_3159: // Incoming return from call to 0x373F at 0x3158 // Inputs[5] // { // @315A stack[-1] // @315A stack[-2] // @3162 memory[0x00:0x20] // @316D stack[-4] // @316E stack[-3] // } 3159 5B JUMPDEST 315A 90 SWAP1 315B 60 PUSH1 0x00 315D 52 MSTORE 315E 60 PUSH1 0x20 3160 60 PUSH1 0x00 3162 20 SHA3 3163 90 SWAP1 3164 60 PUSH1 0x1f 3166 01 ADD 3167 60 PUSH1 0x20 3169 90 SWAP1 316A 04 DIV 316B 81 DUP2 316C 01 ADD 316D 92 SWAP3 316E 82 DUP3 316F 61 PUSH2 0x317b 3172 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @315D memory[0x00:0x20] = stack[-2] // @3163 stack[-2] = keccak256(memory[0x00:0x20]) // @316D stack[-1] = stack[-4] // @316D stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x317b, if stack[-3] label_3173: // Incoming jump from 0x3172, if not stack[-3] // Inputs[1] { @3175 stack[-5] } 3173 60 PUSH1 0x00 3175 85 DUP6 3176 55 SSTORE 3177 61 PUSH2 0x31c1 317A 56 *JUMP // Stack delta = +0 // Outputs[1] { @3176 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x31c1 label_317B: // Incoming jump from 0x3172, if stack[-3] // Inputs[1] { @317C stack[-3] } 317B 5B JUMPDEST 317C 82 DUP3 317D 60 PUSH1 0x1f 317F 10 LT 3180 61 PUSH2 0x3194 3183 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3194, if 0x1f < stack[-3] label_3184: // Incoming jump from 0x3183, if not 0x1f < stack[-3] // Inputs[4] // { // @3184 stack[-1] // @3185 memory[stack[-1]:stack[-1] + 0x20] // @318A stack[-3] // @318E stack[-5] // } 3184 80 DUP1 3185 51 MLOAD 3186 60 PUSH1 0xff 3188 19 NOT 3189 16 AND 318A 83 DUP4 318B 80 DUP1 318C 01 ADD 318D 17 OR 318E 85 DUP6 318F 55 SSTORE 3190 61 PUSH2 0x31c1 3193 56 *JUMP // Stack delta = +0 // Outputs[1] { @318F storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x31c1 label_3194: // Incoming jump from 0x3183, if 0x1f < stack[-3] // Inputs[2] // { // @3195 stack[-3] // @319B stack[-5] // } 3194 5B JUMPDEST 3195 82 DUP3 3196 80 DUP1 3197 01 ADD 3198 60 PUSH1 0x01 319A 01 ADD 319B 85 DUP6 319C 55 SSTORE 319D 82 DUP3 319E 15 ISZERO 319F 61 PUSH2 0x31c1 31A2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @319C storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x31c1, if !stack[-3] label_31A3: // Incoming jump from 0x31A2, if not !stack[-3] // Inputs[2] // { // @31A3 stack[-3] // @31A3 stack[-1] // } 31A3 91 SWAP2 31A4 82 DUP3 31A5 01 ADD 31A6 5B JUMPDEST 31A7 82 DUP3 31A8 81 DUP2 31A9 11 GT 31AA 15 ISZERO 31AB 61 PUSH2 0x31c1 31AE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @31A3 stack[-3] = stack[-1] // @31A5 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x31c1, if !(stack[-1] + stack[-3] > stack[-1]) label_31AF: // Incoming jump from 0x31AE, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x31AE, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @31AF stack[-3] // @31B0 memory[stack[-3]:stack[-3] + 0x20] // @31B1 stack[-2] // @31B3 stack[-1] // } 31AF 82 DUP3 31B0 51 MLOAD 31B1 82 DUP3 31B2 55 SSTORE 31B3 91 SWAP2 31B4 60 PUSH1 0x20 31B6 01 ADD 31B7 91 SWAP2 31B8 90 SWAP1 31B9 60 PUSH1 0x01 31BB 01 ADD 31BC 90 SWAP1 31BD 61 PUSH2 0x31a6 31C0 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @31B2 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @31B7 stack[-3] = 0x20 + stack[-3] // @31BC stack[-2] = 0x01 + stack[-2] // @31BC stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x31a6 label_31C1: // Incoming jump from 0x31A2, if !stack[-3] // Incoming jump from 0x31AE, if !(stack[-1] > stack[-3]) // Incoming jump from 0x317A // Incoming jump from 0x3193 // Incoming jump from 0x31AE, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @31C6 stack[-4] // @31C7 stack[-3] // } 31C1 5B JUMPDEST 31C2 50 POP 31C3 61 PUSH2 0x31cd 31C6 92 SWAP3 31C7 91 SWAP2 31C8 50 POP 31C9 61 PUSH2 0x31d1 31CC 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @31C6 stack[-4] = 0x31cd // @31C7 stack[-3] = stack[-4] // } // Block ends with call to 0x31d1, returns to 0x31CD label_31CD: // Incoming jump from 0x31DA, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x31D1 at 0x31CC // Incoming jump from 0x31DA, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @31CF stack[-3] // @31CF stack[-2] // } 31CD 5B JUMPDEST 31CE 50 POP 31CF 90 SWAP1 31D0 56 *JUMP // Stack delta = -2 // Outputs[1] { @31CF stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_31D1: // Incoming call from 0x31CC, returns to 0x31CD // Inputs[2] // { // @31D3 stack[-1] // @31D4 stack[-2] // } 31D1 5B JUMPDEST 31D2 5B JUMPDEST 31D3 80 DUP1 31D4 82 DUP3 31D5 11 GT 31D6 15 ISZERO 31D7 61 PUSH2 0x31cd 31DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x31cd, if !(stack[-2] > stack[-1]) label_31DB: // Incoming jump from 0x31DA, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x31DA, if not !(stack[-2] > stack[-1]) // Inputs[1] { @31DD stack[-1] } 31DB 60 PUSH1 0x00 31DD 81 DUP2 31DE 55 SSTORE 31DF 60 PUSH1 0x01 31E1 01 ADD 31E2 61 PUSH2 0x31d2 31E5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @31DE storage[stack[-1]] = 0x00 // @31E1 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x31d2 label_31E6: // Incoming call from 0x3218, returns to 0x0E2F // Inputs[1] { @31F0 stack[-1] } 31E6 5B JUMPDEST 31E7 60 PUSH1 0x01 31E9 60 PUSH1 0x01 31EB 60 PUSH1 0xe0 31ED 1B SHL 31EE 03 SUB 31EF 19 NOT 31F0 81 DUP2 31F1 16 AND 31F2 81 DUP2 31F3 14 EQ 31F4 61 PUSH2 0x14e1 31F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14e1, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_31F8: // Incoming jump from 0x31F7, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @31FB memory[0x00:0x00] } 31F8 60 PUSH1 0x00 31FA 80 DUP1 31FB FD *REVERT // Stack delta = +0 // Outputs[1] { @31FB revert(memory[0x00:0x00]); } // Block terminates label_31FC: // Incoming call from 0x0265, returns to 0x0266 // Inputs[2] // { // @3201 stack[-1] // @3202 stack[-2] // } 31FC 5B JUMPDEST 31FD 60 PUSH1 0x00 31FF 60 PUSH1 0x20 3201 82 DUP3 3202 84 DUP5 3203 03 SUB 3204 12 SLT 3205 15 ISZERO 3206 61 PUSH2 0x320e 3209 57 *JUMPI // Stack delta = +1 // Outputs[1] { @31FD stack[0] = 0x00 } // Block ends with conditional jump to 0x320e, if !(stack[-2] - stack[-1] i< 0x20) label_320A: // Incoming jump from 0x3209, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @320D memory[0x00:0x00] } 320A 60 PUSH1 0x00 320C 80 DUP1 320D FD *REVERT // Stack delta = +0 // Outputs[1] { @320D revert(memory[0x00:0x00]); } // Block terminates label_320E: // Incoming jump from 0x3209, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @320F stack[-2] // @3210 msg.data[stack[-2]:stack[-2] + 0x20] // } 320E 5B JUMPDEST 320F 81 DUP2 3210 35 CALLDATALOAD 3211 61 PUSH2 0x0e2f 3214 81 DUP2 3215 61 PUSH2 0x31e6 3218 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3210 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @3211 stack[1] = 0x0e2f // @3214 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x31e6, returns to 0x0E2F label_3219: // Incoming call from 0x3314, returns to 0x3315 // Incoming call from 0x333F, returns to 0x0E2F // Incoming call from 0x3A77, returns to 0x0E2F // Incoming call from 0x35B3, returns to 0x35B4 // Incoming call from 0x36F9, returns to 0x36FA // Incoming call from 0x335F, returns to 0x3360 // Incoming call from 0x357B, returns to 0x357C // Incoming call from 0x324B, returns to 0x324C // Incoming call from 0x336F, returns to 0x3370 // Incoming call from 0x3709, returns to 0x3268 // Incoming call from 0x368C, returns to 0x368D // Incoming call from 0x367C, returns to 0x367D // Incoming call from 0x3644, returns to 0x3645 // Inputs[1] { @3222 stack[-1] } 3219 5B JUMPDEST 321A 60 PUSH1 0x01 321C 60 PUSH1 0x01 321E 60 PUSH1 0xa0 3220 1B SHL 3221 03 SUB 3222 81 DUP2 3223 16 AND 3224 81 DUP2 3225 14 EQ 3226 61 PUSH2 0x14e1 3229 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14e1, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_322A: // Incoming jump from 0x3229, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @322D memory[0x00:0x00] } 322A 60 PUSH1 0x00 322C 80 DUP1 322D FD *REVERT // Stack delta = +0 // Outputs[1] { @322D revert(memory[0x00:0x00]); } // Block terminates label_322E: // Incoming call from 0x029A, returns to 0x029B // Inputs[2] // { // @3234 stack[-1] // @3235 stack[-2] // } 322E 5B JUMPDEST 322F 60 PUSH1 0x00 3231 80 DUP1 3232 60 PUSH1 0x40 3234 83 DUP4 3235 85 DUP6 3236 03 SUB 3237 12 SLT 3238 15 ISZERO 3239 61 PUSH2 0x3241 323C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @322F stack[0] = 0x00 // @3231 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3241, if !(stack[-2] - stack[-1] i< 0x40) label_323D: // Incoming jump from 0x323C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3240 memory[0x00:0x00] } 323D 60 PUSH1 0x00 323F 80 DUP1 3240 FD *REVERT // Stack delta = +0 // Outputs[1] { @3240 revert(memory[0x00:0x00]); } // Block terminates label_3241: // Incoming jump from 0x323C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3242 stack[-3] // @3243 msg.data[stack[-3]:stack[-3] + 0x20] // } 3241 5B JUMPDEST 3242 82 DUP3 3243 35 CALLDATALOAD 3244 61 PUSH2 0x324c 3247 81 DUP2 3248 61 PUSH2 0x3219 324B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3243 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @3244 stack[1] = 0x324c // @3247 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x3219, returns to 0x324C label_324C: // Incoming return from call to 0x3219 at 0x324B // Inputs[4] // { // @324D stack[-1] // @324D stack[-3] // @3251 stack[-4] // @3253 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 324C 5B JUMPDEST 324D 91 SWAP2 324E 50 POP 324F 60 PUSH1 0x20 3251 83 DUP4 3252 01 ADD 3253 35 CALLDATALOAD 3254 60 PUSH1 0x01 3256 60 PUSH1 0x01 3258 60 PUSH1 0x60 325A 1B SHL 325B 03 SUB 325C 81 DUP2 325D 16 AND 325E 81 DUP2 325F 14 EQ 3260 61 PUSH2 0x3268 3263 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @324D stack[-3] = stack[-1] // @3253 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x3268, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 label_3264: // Incoming jump from 0x3263, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 // Inputs[1] { @3267 memory[0x00:0x00] } 3264 60 PUSH1 0x00 3266 80 DUP1 3267 FD *REVERT // Stack delta = +0 // Outputs[1] { @3267 revert(memory[0x00:0x00]); } // Block terminates label_3268: // Incoming jump from 0x3263, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 // Incoming return from call to 0x3219 at 0x3709 // Inputs[6] // { // @3269 stack[-1] // @326A stack[-2] // @326D stack[-5] // @326F stack[-6] // @326F stack[-3] // @3270 stack[-4] // } 3268 5B JUMPDEST 3269 80 DUP1 326A 91 SWAP2 326B 50 POP 326C 50 POP 326D 92 SWAP3 326E 50 POP 326F 92 SWAP3 3270 90 SWAP1 3271 50 POP 3272 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @326D stack[-5] = stack[-1] // @326F stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_3273: // Incoming call from 0x32B6, returns to 0x32B7 // Incoming call from 0x38F0, returns to 0x38F1 // Incoming call from 0x3A07, returns to 0x3A08 // Incoming call from 0x3A4D, returns to 0x3A4E // Incoming call from 0x3A1E, returns to 0x3A1F // Inputs[1] { @3277 stack[-3] } 3273 5B JUMPDEST 3274 60 PUSH1 0x00 3276 5B JUMPDEST 3277 83 DUP4 3278 81 DUP2 3279 10 LT 327A 15 ISZERO 327B 61 PUSH2 0x328e 327E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3274 stack[0] = 0x00 } // Block ends with conditional jump to 0x328e, if !(0x00 < stack[-3]) label_327F: // Incoming jump from 0x327E, if not !(0x00 < stack[-3]) // Incoming jump from 0x327E, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @327F stack[-2] // @3280 stack[-1] // @3282 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3283 stack[-3] // } 327F 81 DUP2 3280 81 DUP2 3281 01 ADD 3282 51 MLOAD 3283 83 DUP4 3284 82 DUP3 3285 01 ADD 3286 52 MSTORE 3287 60 PUSH1 0x20 3289 01 ADD 328A 61 PUSH2 0x3276 328D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3286 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3289 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x3276 label_328E: // Incoming jump from 0x327E, if !(0x00 < stack[-3]) // Incoming jump from 0x327E, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @328F stack[-4] // @3290 stack[-1] // } 328E 5B JUMPDEST 328F 83 DUP4 3290 81 DUP2 3291 11 GT 3292 15 ISZERO 3293 61 PUSH2 0x10f6 3296 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10f6, if !(stack[-1] > stack[-4]) label_3297: // Incoming jump from 0x3296, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @329B stack[-4] // @329C stack[-3] // @329E stack[-5] // } 3297 50 POP 3298 50 POP 3299 60 PUSH1 0x00 329B 91 SWAP2 329C 01 ADD 329D 52 MSTORE 329E 56 *JUMP // Stack delta = -5 // Outputs[1] { @329D memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_329F: // Incoming call from 0x32DD, returns to 0x0E2F // Inputs[3] // { // @32A2 stack[-1] // @32A3 memory[stack[-1]:stack[-1] + 0x20] // @32A5 stack[-2] // } 329F 5B JUMPDEST 32A0 60 PUSH1 0x00 32A2 81 DUP2 32A3 51 MLOAD 32A4 80 DUP1 32A5 84 DUP5 32A6 52 MSTORE 32A7 61 PUSH2 0x32b7 32AA 81 DUP2 32AB 60 PUSH1 0x20 32AD 86 DUP7 32AE 01 ADD 32AF 60 PUSH1 0x20 32B1 86 DUP7 32B2 01 ADD 32B3 61 PUSH2 0x3273 32B6 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @32A0 stack[0] = 0x00 // @32A3 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @32A6 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @32A7 stack[2] = 0x32b7 // @32AA stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @32AE stack[4] = stack[-2] + 0x20 // @32B2 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x3273, returns to 0x32B7 label_32B7: // Incoming return from call to 0x3273 at 0x32B6 // Inputs[4] // { // @32BA stack[-1] // @32BF stack[-4] // @32C0 stack[-2] // @32C6 stack[-5] // } 32B7 5B JUMPDEST 32B8 60 PUSH1 0x1f 32BA 01 ADD 32BB 60 PUSH1 0x1f 32BD 19 NOT 32BE 16 AND 32BF 92 SWAP3 32C0 90 SWAP1 32C1 92 SWAP3 32C2 01 ADD 32C3 60 PUSH1 0x20 32C5 01 ADD 32C6 92 SWAP3 32C7 91 SWAP2 32C8 50 POP 32C9 50 POP 32CA 56 *JUMP // Stack delta = -4 // Outputs[1] { @32C6 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_32CB: // Incoming jump from 0x1EC0 // Incoming jump from 0x02C3 // Inputs[2] // { // @32CE stack[-1] // @32D9 stack[-2] // } 32CB 5B JUMPDEST 32CC 60 PUSH1 0x20 32CE 81 DUP2 32CF 52 MSTORE 32D0 60 PUSH1 0x00 32D2 61 PUSH2 0x0e2f 32D5 60 PUSH1 0x20 32D7 83 DUP4 32D8 01 ADD 32D9 84 DUP5 32DA 61 PUSH2 0x329f 32DD 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @32CF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @32D0 stack[0] = 0x00 // @32D2 stack[1] = 0x0e2f // @32D8 stack[2] = stack[-1] + 0x20 // @32D9 stack[3] = stack[-2] // } // Block ends with call to 0x329f, returns to 0x0E2F label_32DE: // Incoming call from 0x04E9, returns to 0x04EA // Incoming call from 0x0731, returns to 0x0732 // Incoming call from 0x0538, returns to 0x0539 // Incoming call from 0x0751, returns to 0x0752 // Incoming call from 0x02DE, returns to 0x02DF // Inputs[2] // { // @32E3 stack[-1] // @32E4 stack[-2] // } 32DE 5B JUMPDEST 32DF 60 PUSH1 0x00 32E1 60 PUSH1 0x20 32E3 82 DUP3 32E4 84 DUP5 32E5 03 SUB 32E6 12 SLT 32E7 15 ISZERO 32E8 61 PUSH2 0x32f0 32EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @32DF stack[0] = 0x00 } // Block ends with conditional jump to 0x32f0, if !(stack[-2] - stack[-1] i< 0x20) label_32EC: // Incoming jump from 0x32EB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @32EF memory[0x00:0x00] } 32EC 60 PUSH1 0x00 32EE 80 DUP1 32EF FD *REVERT // Stack delta = +0 // Outputs[1] { @32EF revert(memory[0x00:0x00]); } // Block terminates label_32F0: // Incoming jump from 0x32EB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @32F2 msg.data[stack[-2]:stack[-2] + 0x20] // @32F2 stack[-2] // @32F3 stack[-4] // @32F4 stack[-3] // } 32F0 5B JUMPDEST 32F1 50 POP 32F2 35 CALLDATALOAD 32F3 91 SWAP2 32F4 90 SWAP1 32F5 50 POP 32F6 56 *JUMP // Stack delta = -3 // Outputs[1] { @32F3 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_32F7: // Incoming call from 0x0711, returns to 0x0712 // Incoming call from 0x0610, returns to 0x0611 // Incoming call from 0x0316, returns to 0x0317 // Inputs[2] // { // @32FD stack[-1] // @32FE stack[-2] // } 32F7 5B JUMPDEST 32F8 60 PUSH1 0x00 32FA 80 DUP1 32FB 60 PUSH1 0x40 32FD 83 DUP4 32FE 85 DUP6 32FF 03 SUB 3300 12 SLT 3301 15 ISZERO 3302 61 PUSH2 0x330a 3305 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @32F8 stack[0] = 0x00 // @32FA stack[1] = 0x00 // } // Block ends with conditional jump to 0x330a, if !(stack[-2] - stack[-1] i< 0x40) label_3306: // Incoming jump from 0x3305, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3309 memory[0x00:0x00] } 3306 60 PUSH1 0x00 3308 80 DUP1 3309 FD *REVERT // Stack delta = +0 // Outputs[1] { @3309 revert(memory[0x00:0x00]); } // Block terminates label_330A: // Incoming jump from 0x3305, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @330B stack[-3] // @330C msg.data[stack[-3]:stack[-3] + 0x20] // } 330A 5B JUMPDEST 330B 82 DUP3 330C 35 CALLDATALOAD 330D 61 PUSH2 0x3315 3310 81 DUP2 3311 61 PUSH2 0x3219 3314 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @330C stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @330D stack[1] = 0x3315 // @3310 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x3219, returns to 0x3315 label_3315: // Incoming return from call to 0x3219 at 0x3314 // Inputs[5] // { // @3316 stack[-1] // @3316 stack[-6] // @3319 stack[-4] // @331D msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @331E stack[-5] // } 3315 5B JUMPDEST 3316 94 SWAP5 3317 60 PUSH1 0x20 3319 93 SWAP4 331A 90 SWAP1 331B 93 SWAP4 331C 01 ADD 331D 35 CALLDATALOAD 331E 93 SWAP4 331F 50 POP 3320 50 POP 3321 50 POP 3322 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3316 stack[-6] = stack[-1] // @331E stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_3323: // Incoming call from 0x0558, returns to 0x0559 // Incoming call from 0x07A6, returns to 0x07A7 // Incoming call from 0x037B, returns to 0x037C // Incoming call from 0x07C6, returns to 0x07C7 // Incoming call from 0x0336, returns to 0x0337 // Inputs[2] // { // @3328 stack[-1] // @3329 stack[-2] // } 3323 5B JUMPDEST 3324 60 PUSH1 0x00 3326 60 PUSH1 0x20 3328 82 DUP3 3329 84 DUP5 332A 03 SUB 332B 12 SLT 332C 15 ISZERO 332D 61 PUSH2 0x3335 3330 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3324 stack[0] = 0x00 } // Block ends with conditional jump to 0x3335, if !(stack[-2] - stack[-1] i< 0x20) label_3331: // Incoming jump from 0x3330, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3334 memory[0x00:0x00] } 3331 60 PUSH1 0x00 3333 80 DUP1 3334 FD *REVERT // Stack delta = +0 // Outputs[1] { @3334 revert(memory[0x00:0x00]); } // Block terminates label_3335: // Incoming jump from 0x3330, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3336 stack[-2] // @3337 msg.data[stack[-2]:stack[-2] + 0x20] // } 3335 5B JUMPDEST 3336 81 DUP2 3337 35 CALLDATALOAD 3338 61 PUSH2 0x0e2f 333B 81 DUP2 333C 61 PUSH2 0x3219 333F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3337 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @3338 stack[1] = 0x0e2f // @333B stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3219, returns to 0x0E2F label_3340: // Incoming call from 0x039B, returns to 0x039C // Incoming call from 0x04AF, returns to 0x04B0 // Inputs[2] // { // @3348 stack[-1] // @3349 stack[-2] // } 3340 5B JUMPDEST 3341 60 PUSH1 0x00 3343 80 DUP1 3344 60 PUSH1 0x00 3346 60 PUSH1 0x60 3348 84 DUP5 3349 86 DUP7 334A 03 SUB 334B 12 SLT 334C 15 ISZERO 334D 61 PUSH2 0x3355 3350 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3341 stack[0] = 0x00 // @3343 stack[1] = 0x00 // @3344 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3355, if !(stack[-2] - stack[-1] i< 0x60) label_3351: // Incoming jump from 0x3350, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @3354 memory[0x00:0x00] } 3351 60 PUSH1 0x00 3353 80 DUP1 3354 FD *REVERT // Stack delta = +0 // Outputs[1] { @3354 revert(memory[0x00:0x00]); } // Block terminates label_3355: // Incoming jump from 0x3350, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3356 stack[-4] // @3357 msg.data[stack[-4]:stack[-4] + 0x20] // } 3355 5B JUMPDEST 3356 83 DUP4 3357 35 CALLDATALOAD 3358 61 PUSH2 0x3360 335B 81 DUP2 335C 61 PUSH2 0x3219 335F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3357 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @3358 stack[1] = 0x3360 // @335B stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3219, returns to 0x3360 label_3360: // Incoming return from call to 0x3219 at 0x335F // Inputs[4] // { // @3361 stack[-4] // @3361 stack[-1] // @3365 stack[-5] // @3367 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 3360 5B JUMPDEST 3361 92 SWAP3 3362 50 POP 3363 60 PUSH1 0x20 3365 84 DUP5 3366 01 ADD 3367 35 CALLDATALOAD 3368 61 PUSH2 0x3370 336B 81 DUP2 336C 61 PUSH2 0x3219 336F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @3361 stack[-4] = stack[-1] // @3367 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3368 stack[0] = 0x3370 // @336B stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x3219, returns to 0x3370 label_3370: // Incoming return from call to 0x3219 at 0x336F // Inputs[6] // { // @3371 stack[-4] // @3371 stack[-1] // @3372 stack[-7] // @3374 stack[-6] // @337A stack[-5] // @337E msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 3370 5B JUMPDEST 3371 92 SWAP3 3372 95 SWAP6 3373 92 SWAP3 3374 94 SWAP5 3375 50 POP 3376 50 POP 3377 50 POP 3378 60 PUSH1 0x40 337A 91 SWAP2 337B 90 SWAP1 337C 91 SWAP2 337D 01 ADD 337E 35 CALLDATALOAD 337F 90 SWAP1 3380 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @3372 stack[-7] = stack[-4] // @3374 stack[-6] = stack[-1] // @337F stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_3381: // Incoming call from 0x346E, returns to 0x346F // Incoming call from 0x3652, returns to 0x3653 // Incoming call from 0x3490, returns to 0x3491 // Incoming call from 0x33B0, returns to 0x0E2F // Incoming call from 0x347F, returns to 0x3480 // Inputs[2] // { // @3382 stack[-1] // @3383 msg.data[stack[-1]:stack[-1] + 0x20] // } 3381 5B JUMPDEST 3382 80 DUP1 3383 35 CALLDATALOAD 3384 80 DUP1 3385 15 ISZERO 3386 15 ISZERO 3387 81 DUP2 3388 14 EQ 3389 61 PUSH2 0x3391 338C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3383 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x3391, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_338D: // Incoming jump from 0x338C, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @3390 memory[0x00:0x00] } 338D 60 PUSH1 0x00 338F 80 DUP1 3390 FD *REVERT // Stack delta = +0 // Outputs[1] { @3390 revert(memory[0x00:0x00]); } // Block terminates label_3391: // Incoming jump from 0x338C, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @3392 stack[-1] // @3392 stack[-3] // @3393 stack[-2] // } 3391 5B JUMPDEST 3392 91 SWAP2 3393 90 SWAP1 3394 50 POP 3395 56 *JUMP // Stack delta = -2 // Outputs[1] { @3392 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_3396: // Incoming call from 0x03BB, returns to 0x03BC // Inputs[2] // { // @339B stack[-1] // @339C stack[-2] // } 3396 5B JUMPDEST 3397 60 PUSH1 0x00 3399 60 PUSH1 0x20 339B 82 DUP3 339C 84 DUP5 339D 03 SUB 339E 12 SLT 339F 15 ISZERO 33A0 61 PUSH2 0x33a8 33A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3397 stack[0] = 0x00 } // Block ends with conditional jump to 0x33a8, if !(stack[-2] - stack[-1] i< 0x20) label_33A4: // Incoming jump from 0x33A3, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @33A7 memory[0x00:0x00] } 33A4 60 PUSH1 0x00 33A6 80 DUP1 33A7 FD *REVERT // Stack delta = +0 // Outputs[1] { @33A7 revert(memory[0x00:0x00]); } // Block terminates label_33A8: // Incoming jump from 0x33A3, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @33AC stack[-2] } 33A8 5B JUMPDEST 33A9 61 PUSH2 0x0e2f 33AC 82 DUP3 33AD 61 PUSH2 0x3381 33B0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @33A9 stack[0] = 0x0e2f // @33AC stack[1] = stack[-2] // } // Block ends with call to 0x3381, returns to 0x0E2F label_33B1: // Incoming call from 0x047A, returns to 0x047B // Incoming call from 0x03DB, returns to 0x03DC // Inputs[2] // { // @33B7 stack[-1] // @33B8 stack[-2] // } 33B1 5B JUMPDEST 33B2 60 PUSH1 0x00 33B4 80 DUP1 33B5 60 PUSH1 0x40 33B7 83 DUP4 33B8 85 DUP6 33B9 03 SUB 33BA 12 SLT 33BB 15 ISZERO 33BC 61 PUSH2 0x33c4 33BF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @33B2 stack[0] = 0x00 // @33B4 stack[1] = 0x00 // } // Block ends with conditional jump to 0x33c4, if !(stack[-2] - stack[-1] i< 0x40) label_33C0: // Incoming jump from 0x33BF, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @33C3 memory[0x00:0x00] } 33C0 60 PUSH1 0x00 33C2 80 DUP1 33C3 FD *REVERT // Stack delta = +0 // Outputs[1] { @33C3 revert(memory[0x00:0x00]); } // Block terminates label_33C4: // Incoming jump from 0x33BF, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @33C7 stack[-3] // @33C8 msg.data[stack[-3]:stack[-3] + 0x20] // @33C9 stack[-5] // @33CF msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @33D0 stack[-4] // } 33C4 5B JUMPDEST 33C5 50 POP 33C6 50 POP 33C7 80 DUP1 33C8 35 CALLDATALOAD 33C9 92 SWAP3 33CA 60 PUSH1 0x20 33CC 90 SWAP1 33CD 91 SWAP2 33CE 01 ADD 33CF 35 CALLDATALOAD 33D0 91 SWAP2 33D1 50 POP 33D2 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @33C9 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @33D0 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_33D3: // Incoming jump from 0x34DF // Incoming jump from 0x21E0 // Incoming jump from 0x34B7 // Incoming jump from 0x340B // Inputs[1] { @33E8 memory[0x00:0x24] } 33D3 5B JUMPDEST 33D4 63 PUSH4 0x4e487b71 33D9 60 PUSH1 0xe0 33DB 1B SHL 33DC 60 PUSH1 0x00 33DE 52 MSTORE 33DF 60 PUSH1 0x41 33E1 60 PUSH1 0x04 33E3 52 MSTORE 33E4 60 PUSH1 0x24 33E6 60 PUSH1 0x00 33E8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @33DE memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @33E3 memory[0x04:0x24] = 0x41 // @33E8 revert(memory[0x00:0x24]); // } // Block terminates label_33E9: // Incoming call from 0x342B, returns to 0x342C // Inputs[1] { @33EC memory[0x40:0x60] } 33E9 5B JUMPDEST 33EA 60 PUSH1 0x40 33EC 51 MLOAD 33ED 60 PUSH1 0xe0 33EF 81 DUP2 33F0 01 ADD 33F1 67 PUSH8 0xffffffffffffffff 33FA 81 DUP2 33FB 11 GT 33FC 82 DUP3 33FD 82 DUP3 33FE 10 LT 33FF 17 OR 3400 15 ISZERO 3401 61 PUSH2 0x340c 3404 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @33EC stack[0] = memory[0x40:0x60] // @33F0 stack[1] = memory[0x40:0x60] + 0xe0 // } // Block ends with conditional jump to 0x340c, if !((memory[0x40:0x60] + 0xe0 < memory[0x40:0x60]) | (memory[0x40:0x60] + 0xe0 > 0xffffffffffffffff)) label_3405: // Incoming jump from 0x3404, if not !((memory[0x40:0x60] + 0xe0 < memory[0x40:0x60]) | (memory[0x40:0x60] + 0xe0 > 0xffffffffffffffff)) 3405 61 PUSH2 0x340c 3408 61 PUSH2 0x33d3 340B 56 *JUMP // Stack delta = +1 // Outputs[1] { @3405 stack[0] = 0x340c } // Block ends with unconditional jump to 0x33d3 label_340C: // Incoming jump from 0x3404, if !((memory[0x40:0x60] + 0xe0 < memory[0x40:0x60]) | (memory[0x40:0x60] + 0xe0 > 0xffffffffffffffff)) // Inputs[3] // { // @340F stack[-1] // @3410 stack[-2] // @3410 stack[-3] // } 340C 5B JUMPDEST 340D 60 PUSH1 0x40 340F 52 MSTORE 3410 90 SWAP1 3411 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @340F memory[0x40:0x60] = stack[-1] // @3410 stack[-3] = stack[-2] // } // Block ends with unconditional jump to stack[-3] label_3412: // Incoming call from 0x041A, returns to 0x041B // Inputs[2] // { // @3417 stack[-1] // @3418 stack[-2] // } 3412 5B JUMPDEST 3413 60 PUSH1 0x00 3415 60 PUSH1 0xe0 3417 82 DUP3 3418 84 DUP5 3419 03 SUB 341A 12 SLT 341B 15 ISZERO 341C 61 PUSH2 0x3424 341F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3413 stack[0] = 0x00 } // Block ends with conditional jump to 0x3424, if !(stack[-2] - stack[-1] i< 0xe0) label_3420: // Incoming jump from 0x341F, if not !(stack[-2] - stack[-1] i< 0xe0) // Inputs[1] { @3423 memory[0x00:0x00] } 3420 60 PUSH1 0x00 3422 80 DUP1 3423 FD *REVERT // Stack delta = +0 // Outputs[1] { @3423 revert(memory[0x00:0x00]); } // Block terminates label_3424: // Incoming jump from 0x341F, if !(stack[-2] - stack[-1] i< 0xe0) 3424 5B JUMPDEST 3425 61 PUSH2 0x342c 3428 61 PUSH2 0x33e9 342B 56 *JUMP // Stack delta = +1 // Outputs[1] { @3425 stack[0] = 0x342c } // Block ends with call to 0x33e9, returns to 0x342C label_342C: // Incoming return from call to 0x33E9 at 0x342B // Inputs[6] // { // @342D stack[-3] // @342E msg.data[stack[-3]:stack[-3] + 0x20] // @342F stack[-1] // @3436 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @3440 msg.data[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @3449 msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // } 342C 5B JUMPDEST 342D 82 DUP3 342E 35 CALLDATALOAD 342F 81 DUP2 3430 52 MSTORE 3431 60 PUSH1 0x20 3433 80 DUP1 3434 84 DUP5 3435 01 ADD 3436 35 CALLDATALOAD 3437 90 SWAP1 3438 82 DUP3 3439 01 ADD 343A 52 MSTORE 343B 60 PUSH1 0x40 343D 80 DUP1 343E 84 DUP5 343F 01 ADD 3440 35 CALLDATALOAD 3441 90 SWAP1 3442 82 DUP3 3443 01 ADD 3444 52 MSTORE 3445 60 PUSH1 0x60 3447 83 DUP4 3448 01 ADD 3449 35 CALLDATALOAD 344A 60 PUSH1 0x01 344C 60 PUSH1 0x01 344E 60 PUSH1 0xf8 3450 1B SHL 3451 03 SUB 3452 81 DUP2 3453 16 AND 3454 81 DUP2 3455 14 EQ 3456 61 PUSH2 0x345e 3459 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @3430 memory[stack[-1]:stack[-1] + 0x20] = msg.data[stack[-3]:stack[-3] + 0x20] // @343A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @3444 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = msg.data[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @3449 stack[0] = msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x345e, if msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] == msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] & (0x01 << 0xf8) - 0x01 label_345A: // Incoming jump from 0x3459, if not msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] == msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] & (0x01 << 0xf8) - 0x01 // Inputs[1] { @345D memory[0x00:0x00] } 345A 60 PUSH1 0x00 345C 80 DUP1 345D FD *REVERT // Stack delta = +0 // Outputs[1] { @345D revert(memory[0x00:0x00]); } // Block terminates label_345E: // Incoming jump from 0x3459, if msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] == msg.data[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] & (0x01 << 0xf8) - 0x01 // Inputs[3] // { // @3461 stack[-2] // @3463 stack[-1] // @3469 stack[-4] // } 345E 5B JUMPDEST 345F 60 PUSH1 0x60 3461 82 DUP3 3462 01 ADD 3463 52 MSTORE 3464 61 PUSH2 0x346f 3467 60 PUSH1 0x80 3469 84 DUP5 346A 01 ADD 346B 61 PUSH2 0x3381 346E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3463 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = stack[-1] // @3464 stack[-1] = 0x346f // @346A stack[0] = stack[-4] + 0x80 // } // Block ends with call to 0x3381, returns to 0x346F label_346F: // Incoming return from call to 0x3381 at 0x346E // Inputs[3] // { // @3472 stack[-2] // @3474 stack[-1] // @347A stack[-4] // } 346F 5B JUMPDEST 3470 60 PUSH1 0x80 3472 82 DUP3 3473 01 ADD 3474 52 MSTORE 3475 61 PUSH2 0x3480 3478 60 PUSH1 0xa0 347A 84 DUP5 347B 01 ADD 347C 61 PUSH2 0x3381 347F 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3474 memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] = stack[-1] // @3475 stack[-1] = 0x3480 // @347B stack[0] = stack[-4] + 0xa0 // } // Block ends with call to 0x3381, returns to 0x3480 label_3480: // Incoming return from call to 0x3381 at 0x347F // Inputs[3] // { // @3483 stack[-2] // @3485 stack[-1] // @348B stack[-4] // } 3480 5B JUMPDEST 3481 60 PUSH1 0xa0 3483 82 DUP3 3484 01 ADD 3485 52 MSTORE 3486 61 PUSH2 0x3491 3489 60 PUSH1 0xc0 348B 84 DUP5 348C 01 ADD 348D 61 PUSH2 0x3381 3490 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3485 memory[stack[-2] + 0xa0:stack[-2] + 0xa0 + 0x20] = stack[-1] // @3486 stack[-1] = 0x3491 // @348C stack[0] = stack[-4] + 0xc0 // } // Block ends with call to 0x3381, returns to 0x3491 label_3491: // Incoming return from call to 0x3381 at 0x3490 // Inputs[4] // { // @3494 stack[-2] // @3496 stack[-1] // @3497 stack[-6] // @3498 stack[-5] // } 3491 5B JUMPDEST 3492 60 PUSH1 0xc0 3494 82 DUP3 3495 01 ADD 3496 52 MSTORE 3497 93 SWAP4 3498 92 SWAP3 3499 50 POP 349A 50 POP 349B 50 POP 349C 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @3496 memory[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] = stack[-1] // @3497 stack[-6] = stack[-2] // } // Block ends with unconditional jump to stack[-6] label_349D: // Incoming call from 0x36CF, returns to 0x36D0 // Incoming call from 0x355B, returns to 0x175C // Inputs[1] { @34AA stack[-2] } 349D 5B JUMPDEST 349E 60 PUSH1 0x00 34A0 67 PUSH8 0xffffffffffffffff 34A9 80 DUP1 34AA 84 DUP5 34AB 11 GT 34AC 15 ISZERO 34AD 61 PUSH2 0x34b8 34B0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @349E stack[0] = 0x00 // @34A0 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x34b8, if !(stack[-2] > 0xffffffffffffffff) label_34B1: // Incoming jump from 0x34B0, if not !(stack[-2] > 0xffffffffffffffff) 34B1 61 PUSH2 0x34b8 34B4 61 PUSH2 0x33d3 34B7 56 *JUMP // Stack delta = +1 // Outputs[1] { @34B1 stack[0] = 0x34b8 } // Block ends with unconditional jump to 0x33d3 label_34B8: // Incoming jump from 0x34B0, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @34BB memory[0x40:0x60] // @34BE stack[-4] // @34CD stack[-1] // } 34B8 5B JUMPDEST 34B9 60 PUSH1 0x40 34BB 51 MLOAD 34BC 60 PUSH1 0x1f 34BE 85 DUP6 34BF 01 ADD 34C0 60 PUSH1 0x1f 34C2 19 NOT 34C3 90 SWAP1 34C4 81 DUP2 34C5 16 AND 34C6 60 PUSH1 0x3f 34C8 01 ADD 34C9 16 AND 34CA 81 DUP2 34CB 01 ADD 34CC 90 SWAP1 34CD 82 DUP3 34CE 82 DUP3 34CF 11 GT 34D0 81 DUP2 34D1 83 DUP4 34D2 10 LT 34D3 17 OR 34D4 15 ISZERO 34D5 61 PUSH2 0x34e0 34D8 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @34CC stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @34CC stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x34e0, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_34D9: // Incoming jump from 0x34D8, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 34D9 61 PUSH2 0x34e0 34DC 61 PUSH2 0x33d3 34DF 56 *JUMP // Stack delta = +1 // Outputs[1] { @34D9 stack[0] = 0x34e0 } // Block ends with unconditional jump to 0x33d3 label_34E0: // Incoming jump from 0x34D8, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @34E1 stack[-2] // @34E5 stack[-1] // @34E6 stack[-4] // @34E8 stack[-6] // @34EB stack[-7] // @34ED stack[-5] // } 34E0 5B JUMPDEST 34E1 81 DUP2 34E2 60 PUSH1 0x40 34E4 52 MSTORE 34E5 80 DUP1 34E6 93 SWAP4 34E7 50 POP 34E8 85 DUP6 34E9 81 DUP2 34EA 52 MSTORE 34EB 86 DUP7 34EC 86 DUP7 34ED 86 DUP7 34EE 01 ADD 34EF 11 GT 34F0 15 ISZERO 34F1 61 PUSH2 0x34f9 34F4 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @34E4 memory[0x40:0x60] = stack[-2] // @34E6 stack[-4] = stack[-1] // @34EA memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x34f9, if !(stack[-5] + stack[-6] > stack[-7]) label_34F5: // Incoming jump from 0x34F4, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @34F8 memory[0x00:0x00] } 34F5 60 PUSH1 0x00 34F7 80 DUP1 34F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @34F8 revert(memory[0x00:0x00]); } // Block terminates label_34F9: // Incoming jump from 0x34F4, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @34FA stack[-6] // @34FB stack[-5] // @34FE stack[-1] // @3500 msg.data[stack[-5]:stack[-5] + stack[-6]] // @350D stack[-4] // @350D stack[-8] // @350E stack[-7] // } 34F9 5B JUMPDEST 34FA 85 DUP6 34FB 85 DUP6 34FC 60 PUSH1 0x20 34FE 83 DUP4 34FF 01 ADD 3500 37 CALLDATACOPY 3501 60 PUSH1 0x00 3503 60 PUSH1 0x20 3505 87 DUP8 3506 83 DUP4 3507 01 ADD 3508 01 ADD 3509 52 MSTORE 350A 50 POP 350B 50 POP 350C 50 POP 350D 93 SWAP4 350E 92 SWAP3 350F 50 POP 3510 50 POP 3511 50 POP 3512 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @3500 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @3509 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @350D stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_3513: // Incoming call from 0x043A, returns to 0x043B // Inputs[2] // { // @3518 stack[-1] // @3519 stack[-2] // } 3513 5B JUMPDEST 3514 60 PUSH1 0x00 3516 60 PUSH1 0x20 3518 82 DUP3 3519 84 DUP5 351A 03 SUB 351B 12 SLT 351C 15 ISZERO 351D 61 PUSH2 0x3525 3520 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3514 stack[0] = 0x00 } // Block ends with conditional jump to 0x3525, if !(stack[-2] - stack[-1] i< 0x20) label_3521: // Incoming jump from 0x3520, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3524 memory[0x00:0x00] } 3521 60 PUSH1 0x00 3523 80 DUP1 3524 FD *REVERT // Stack delta = +0 // Outputs[1] { @3524 revert(memory[0x00:0x00]); } // Block terminates label_3525: // Incoming jump from 0x3520, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3526 stack[-2] // @3527 msg.data[stack[-2]:stack[-2] + 0x20] // } 3525 5B JUMPDEST 3526 81 DUP2 3527 35 CALLDATALOAD 3528 67 PUSH8 0xffffffffffffffff 3531 81 DUP2 3532 11 GT 3533 15 ISZERO 3534 61 PUSH2 0x353c 3537 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3527 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x353c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_3538: // Incoming jump from 0x3537, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @353B memory[0x00:0x00] } 3538 60 PUSH1 0x00 353A 80 DUP1 353B FD *REVERT // Stack delta = +0 // Outputs[1] { @353B revert(memory[0x00:0x00]); } // Block terminates label_353C: // Incoming jump from 0x3537, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @353D stack[-3] // @353E stack[-1] // @3543 stack[-4] // } 353C 5B JUMPDEST 353D 82 DUP3 353E 01 ADD 353F 60 PUSH1 0x1f 3541 81 DUP2 3542 01 ADD 3543 84 DUP5 3544 13 SGT 3545 61 PUSH2 0x354d 3548 57 *JUMPI // Stack delta = +0 // Outputs[1] { @353E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x354d, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_3549: // Incoming jump from 0x3548, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @354C memory[0x00:0x00] } 3549 60 PUSH1 0x00 354B 80 DUP1 354C FD *REVERT // Stack delta = +0 // Outputs[1] { @354C revert(memory[0x00:0x00]); } // Block terminates label_354D: // Incoming jump from 0x3548, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @3551 stack[-4] // @3552 stack[-1] // @3553 msg.data[stack[-1]:stack[-1] + 0x20] // } 354D 5B JUMPDEST 354E 61 PUSH2 0x175c 3551 84 DUP5 3552 82 DUP3 3553 35 CALLDATALOAD 3554 60 PUSH1 0x20 3556 84 DUP5 3557 01 ADD 3558 61 PUSH2 0x349d 355B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @354E stack[0] = 0x175c // @3551 stack[1] = stack[-4] // @3553 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @3557 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x349d, returns to 0x175C label_355C: // Incoming call from 0x05D5, returns to 0x05D6 // Inputs[2] // { // @3564 stack[-1] // @3565 stack[-2] // } 355C 5B JUMPDEST 355D 60 PUSH1 0x00 355F 80 DUP1 3560 60 PUSH1 0x00 3562 60 PUSH1 0x60 3564 84 DUP5 3565 86 DUP7 3566 03 SUB 3567 12 SLT 3568 15 ISZERO 3569 61 PUSH2 0x3571 356C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @355D stack[0] = 0x00 // @355F stack[1] = 0x00 // @3560 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3571, if !(stack[-2] - stack[-1] i< 0x60) label_356D: // Incoming jump from 0x356C, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @3570 memory[0x00:0x00] } 356D 60 PUSH1 0x00 356F 80 DUP1 3570 FD *REVERT // Stack delta = +0 // Outputs[1] { @3570 revert(memory[0x00:0x00]); } // Block terminates label_3571: // Incoming jump from 0x356C, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3572 stack[-4] // @3573 msg.data[stack[-4]:stack[-4] + 0x20] // } 3571 5B JUMPDEST 3572 83 DUP4 3573 35 CALLDATALOAD 3574 61 PUSH2 0x357c 3577 81 DUP2 3578 61 PUSH2 0x3219 357B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3573 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @3574 stack[1] = 0x357c // @3577 stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3219, returns to 0x357C label_357C: // Incoming return from call to 0x3219 at 0x357B // Inputs[7] // { // @357D stack[-7] // @357D stack[-1] // @3580 stack[-5] // @3582 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3583 stack[-6] // @358A msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @358C stack[-4] // } 357C 5B JUMPDEST 357D 95 SWAP6 357E 60 PUSH1 0x20 3580 85 DUP6 3581 01 ADD 3582 35 CALLDATALOAD 3583 95 SWAP6 3584 50 POP 3585 60 PUSH1 0x40 3587 90 SWAP1 3588 94 SWAP5 3589 01 ADD 358A 35 CALLDATALOAD 358B 93 SWAP4 358C 92 SWAP3 358D 50 POP 358E 50 POP 358F 50 POP 3590 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @357D stack[-7] = stack[-1] // @3583 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @358B stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_3591: // Incoming call from 0x05FD, returns to 0x05FE // Inputs[2] // { // @359C stack[-1] // @359D stack[-2] // } 3591 5B JUMPDEST 3592 60 PUSH1 0x00 3594 80 DUP1 3595 60 PUSH1 0x00 3597 80 DUP1 3598 60 PUSH1 0x00 359A 60 PUSH1 0x80 359C 86 DUP7 359D 88 DUP9 359E 03 SUB 359F 12 SLT 35A0 15 ISZERO 35A1 61 PUSH2 0x35a9 35A4 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @3592 stack[0] = 0x00 // @3594 stack[1] = 0x00 // @3595 stack[2] = 0x00 // @3597 stack[3] = 0x00 // @3598 stack[4] = 0x00 // } // Block ends with conditional jump to 0x35a9, if !(stack[-2] - stack[-1] i< 0x80) label_35A5: // Incoming jump from 0x35A4, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @35A8 memory[0x00:0x00] } 35A5 60 PUSH1 0x00 35A7 80 DUP1 35A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @35A8 revert(memory[0x00:0x00]); } // Block terminates label_35A9: // Incoming jump from 0x35A4, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @35AA stack[-6] // @35AB msg.data[stack[-6]:stack[-6] + 0x20] // } 35A9 5B JUMPDEST 35AA 85 DUP6 35AB 35 CALLDATALOAD 35AC 61 PUSH2 0x35b4 35AF 81 DUP2 35B0 61 PUSH2 0x3219 35B3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @35AB stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @35AC stack[1] = 0x35b4 // @35AF stack[2] = msg.data[stack[-6]:stack[-6] + 0x20] // } // Block ends with call to 0x3219, returns to 0x35B4 label_35B4: // Incoming return from call to 0x3219 at 0x35B3 // Inputs[8] // { // @35B5 stack[-6] // @35B5 stack[-1] // @35B9 stack[-7] // @35BB msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @35BC stack[-5] // @35C2 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @35C3 stack[-4] // @35C9 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } 35B4 5B JUMPDEST 35B5 94 SWAP5 35B6 50 POP 35B7 60 PUSH1 0x20 35B9 86 DUP7 35BA 01 ADD 35BB 35 CALLDATALOAD 35BC 93 SWAP4 35BD 50 POP 35BE 60 PUSH1 0x40 35C0 86 DUP7 35C1 01 ADD 35C2 35 CALLDATALOAD 35C3 92 SWAP3 35C4 50 POP 35C5 60 PUSH1 0x60 35C7 86 DUP7 35C8 01 ADD 35C9 35 CALLDATALOAD 35CA 67 PUSH8 0xffffffffffffffff 35D3 80 DUP1 35D4 82 DUP3 35D5 11 GT 35D6 15 ISZERO 35D7 61 PUSH2 0x35df 35DA 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @35B5 stack[-6] = stack[-1] // @35BC stack[-5] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @35C3 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @35C9 stack[-1] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @35CA stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x35df, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) label_35DB: // Incoming jump from 0x35DA, if not !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @35DE memory[0x00:0x00] } 35DB 60 PUSH1 0x00 35DD 80 DUP1 35DE FD *REVERT // Stack delta = +0 // Outputs[1] { @35DE revert(memory[0x00:0x00]); } // Block terminates label_35DF: // Incoming jump from 0x35DA, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @35E0 stack[-2] // @35E1 stack[-8] // @35E5 stack[-9] // } 35DF 5B JUMPDEST 35E0 81 DUP2 35E1 88 DUP9 35E2 01 ADD 35E3 91 SWAP2 35E4 50 POP 35E5 88 DUP9 35E6 60 PUSH1 0x1f 35E8 83 DUP4 35E9 01 ADD 35EA 12 SLT 35EB 61 PUSH2 0x35f3 35EE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @35E3 stack[-2] = stack[-8] + stack[-2] } // Block ends with conditional jump to 0x35f3, if stack[-8] + stack[-2] + 0x1f i< stack[-9] label_35EF: // Incoming jump from 0x35EE, if not stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[1] { @35F2 memory[0x00:0x00] } 35EF 60 PUSH1 0x00 35F1 80 DUP1 35F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @35F2 revert(memory[0x00:0x00]); } // Block terminates label_35F3: // Incoming jump from 0x35EE, if stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[3] // { // @35F4 stack[-2] // @35F5 msg.data[stack[-2]:stack[-2] + 0x20] // @35F6 stack[-1] // } 35F3 5B JUMPDEST 35F4 81 DUP2 35F5 35 CALLDATALOAD 35F6 81 DUP2 35F7 81 DUP2 35F8 11 GT 35F9 15 ISZERO 35FA 61 PUSH2 0x3602 35FD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @35F5 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3602, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_35FE: // Incoming jump from 0x35FD, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @3601 memory[0x00:0x00] } 35FE 60 PUSH1 0x00 3600 80 DUP1 3601 FD *REVERT // Stack delta = +0 // Outputs[1] { @3601 revert(memory[0x00:0x00]); } // Block terminates label_3602: // Incoming jump from 0x35FD, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @3603 stack[-10] // @3606 stack[-1] // @3607 stack[-3] // } 3602 5B JUMPDEST 3603 89 DUP10 3604 60 PUSH1 0x20 3606 82 DUP3 3607 85 DUP6 3608 01 ADD 3609 01 ADD 360A 11 GT 360B 15 ISZERO 360C 61 PUSH2 0x3614 360F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3614, if !(stack[-3] + stack[-1] + 0x20 > stack[-10]) label_3610: // Incoming jump from 0x360F, if not !(stack[-3] + stack[-1] + 0x20 > stack[-10]) // Inputs[1] { @3613 memory[0x00:0x00] } 3610 60 PUSH1 0x00 3612 80 DUP1 3613 FD *REVERT // Stack delta = +0 // Outputs[1] { @3613 revert(memory[0x00:0x00]); } // Block terminates label_3614: // Incoming jump from 0x360F, if !(stack[-3] + stack[-1] + 0x20 > stack[-10]) // Inputs[9] // { // @3615 stack[-8] // @3615 stack[-1] // @3616 stack[-11] // @3617 stack[-7] // @3618 stack[-10] // @361A stack[-6] // @361A stack[-2] // @361B stack[-9] // @361F stack[-3] // } 3614 5B JUMPDEST 3615 96 SWAP7 3616 99 SWAP10 3617 95 SWAP6 3618 98 SWAP9 3619 50 POP 361A 93 SWAP4 361B 96 SWAP7 361C 50 POP 361D 60 PUSH1 0x20 361F 01 ADD 3620 94 SWAP5 3621 93 SWAP4 3622 92 SWAP3 3623 50 POP 3624 50 POP 3625 50 POP 3626 56 *JUMP // Stack delta = -6 // Outputs[5] // { // @3616 stack[-11] = stack[-8] // @3618 stack[-10] = stack[-7] // @361B stack[-9] = stack[-6] // @3620 stack[-8] = 0x20 + stack[-3] // @3621 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-11] label_3627: // Incoming call from 0x0630, returns to 0x0631 // Inputs[2] // { // @362D stack[-1] // @362E stack[-2] // } 3627 5B JUMPDEST 3628 60 PUSH1 0x00 362A 80 DUP1 362B 60 PUSH1 0x40 362D 83 DUP4 362E 85 DUP6 362F 03 SUB 3630 12 SLT 3631 15 ISZERO 3632 61 PUSH2 0x363a 3635 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3628 stack[0] = 0x00 // @362A stack[1] = 0x00 // } // Block ends with conditional jump to 0x363a, if !(stack[-2] - stack[-1] i< 0x40) label_3636: // Incoming jump from 0x3635, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @3639 memory[0x00:0x00] } 3636 60 PUSH1 0x00 3638 80 DUP1 3639 FD *REVERT // Stack delta = +0 // Outputs[1] { @3639 revert(memory[0x00:0x00]); } // Block terminates label_363A: // Incoming jump from 0x3635, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @363B stack[-3] // @363C msg.data[stack[-3]:stack[-3] + 0x20] // } 363A 5B JUMPDEST 363B 82 DUP3 363C 35 CALLDATALOAD 363D 61 PUSH2 0x3645 3640 81 DUP2 3641 61 PUSH2 0x3219 3644 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @363C stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @363D stack[1] = 0x3645 // @3640 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x3219, returns to 0x3645 label_3645: // Incoming return from call to 0x3219 at 0x3644 // Inputs[3] // { // @3646 stack[-3] // @3646 stack[-1] // @364D stack[-4] // } 3645 5B JUMPDEST 3646 91 SWAP2 3647 50 POP 3648 61 PUSH2 0x3653 364B 60 PUSH1 0x20 364D 84 DUP5 364E 01 ADD 364F 61 PUSH2 0x3381 3652 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @3646 stack[-3] = stack[-1] // @3648 stack[-1] = 0x3653 // @364E stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x3381, returns to 0x3653 label_3653: // Incoming return from call to 0x3381 at 0x3652 // Inputs[6] // { // @3654 stack[-2] // @3654 stack[-1] // @3656 stack[-5] // @3658 stack[-3] // @3658 stack[-6] // @3659 stack[-4] // } 3653 5B JUMPDEST 3654 90 SWAP1 3655 50 POP 3656 92 SWAP3 3657 50 POP 3658 92 SWAP3 3659 90 SWAP1 365A 50 POP 365B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3656 stack[-5] = stack[-1] // @3658 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_365C: // Incoming call from 0x0666, returns to 0x0667 // Inputs[2] // { // @3665 stack[-1] // @3666 stack[-2] // } 365C 5B JUMPDEST 365D 60 PUSH1 0x00 365F 80 DUP1 3660 60 PUSH1 0x00 3662 80 DUP1 3663 60 PUSH1 0x80 3665 85 DUP6 3666 87 DUP8 3667 03 SUB 3668 12 SLT 3669 15 ISZERO 366A 61 PUSH2 0x3672 366D 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @365D stack[0] = 0x00 // @365F stack[1] = 0x00 // @3660 stack[2] = 0x00 // @3662 stack[3] = 0x00 // } // Block ends with conditional jump to 0x3672, if !(stack[-2] - stack[-1] i< 0x80) label_366E: // Incoming jump from 0x366D, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @3671 memory[0x00:0x00] } 366E 60 PUSH1 0x00 3670 80 DUP1 3671 FD *REVERT // Stack delta = +0 // Outputs[1] { @3671 revert(memory[0x00:0x00]); } // Block terminates label_3672: // Incoming jump from 0x366D, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3673 stack[-5] // @3674 msg.data[stack[-5]:stack[-5] + 0x20] // } 3672 5B JUMPDEST 3673 84 DUP5 3674 35 CALLDATALOAD 3675 61 PUSH2 0x367d 3678 81 DUP2 3679 61 PUSH2 0x3219 367C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3674 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @3675 stack[1] = 0x367d // @3678 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x3219, returns to 0x367D label_367D: // Incoming return from call to 0x3219 at 0x367C // Inputs[4] // { // @367E stack[-1] // @367E stack[-5] // @3682 stack[-6] // @3684 msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 367D 5B JUMPDEST 367E 93 SWAP4 367F 50 POP 3680 60 PUSH1 0x20 3682 85 DUP6 3683 01 ADD 3684 35 CALLDATALOAD 3685 61 PUSH2 0x368d 3688 81 DUP2 3689 61 PUSH2 0x3219 368C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @367E stack[-5] = stack[-1] // @3684 stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @3685 stack[0] = 0x368d // @3688 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x3219, returns to 0x368D label_368D: // Incoming return from call to 0x3219 at 0x368C // Inputs[6] // { // @368E stack[-1] // @368E stack[-4] // @3692 stack[-6] // @3694 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @3695 stack[-3] // @369B msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 368D 5B JUMPDEST 368E 92 SWAP3 368F 50 POP 3690 60 PUSH1 0x40 3692 85 DUP6 3693 01 ADD 3694 35 CALLDATALOAD 3695 91 SWAP2 3696 50 POP 3697 60 PUSH1 0x60 3699 85 DUP6 369A 01 ADD 369B 35 CALLDATALOAD 369C 67 PUSH8 0xffffffffffffffff 36A5 81 DUP2 36A6 11 GT 36A7 15 ISZERO 36A8 61 PUSH2 0x36b0 36AB 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @368E stack[-4] = stack[-1] // @3695 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @369B stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x36b0, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_36AC: // Incoming jump from 0x36AB, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @36AF memory[0x00:0x00] } 36AC 60 PUSH1 0x00 36AE 80 DUP1 36AF FD *REVERT // Stack delta = +0 // Outputs[1] { @36AF revert(memory[0x00:0x00]); } // Block terminates label_36B0: // Incoming jump from 0x36AB, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @36B1 stack[-6] // @36B2 stack[-1] // @36B7 stack[-7] // } 36B0 5B JUMPDEST 36B1 85 DUP6 36B2 01 ADD 36B3 60 PUSH1 0x1f 36B5 81 DUP2 36B6 01 ADD 36B7 87 DUP8 36B8 13 SGT 36B9 61 PUSH2 0x36c1 36BC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @36B2 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x36c1, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_36BD: // Incoming jump from 0x36BC, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @36C0 memory[0x00:0x00] } 36BD 60 PUSH1 0x00 36BF 80 DUP1 36C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @36C0 revert(memory[0x00:0x00]); } // Block terminates label_36C1: // Incoming jump from 0x36BC, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @36C5 stack[-7] // @36C6 stack[-1] // @36C7 msg.data[stack[-1]:stack[-1] + 0x20] // } 36C1 5B JUMPDEST 36C2 61 PUSH2 0x36d0 36C5 87 DUP8 36C6 82 DUP3 36C7 35 CALLDATALOAD 36C8 60 PUSH1 0x20 36CA 84 DUP5 36CB 01 ADD 36CC 61 PUSH2 0x349d 36CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @36C2 stack[0] = 0x36d0 // @36C5 stack[1] = stack[-7] // @36C7 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @36CB stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x349d, returns to 0x36D0 label_36D0: // Incoming return from call to 0x349D at 0x36CF // Inputs[8] // { // @36D1 stack[-3] // @36D1 stack[-1] // @36D4 stack[-6] // @36D5 stack[-9] // @36D6 stack[-5] // @36D7 stack[-8] // @36D9 stack[-4] // @36D9 stack[-7] // } 36D0 5B JUMPDEST 36D1 91 SWAP2 36D2 50 POP 36D3 50 POP 36D4 92 SWAP3 36D5 95 SWAP6 36D6 91 SWAP2 36D7 94 SWAP5 36D8 50 POP 36D9 92 SWAP3 36DA 50 POP 36DB 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @36D4 stack[-6] = stack[-1] // @36D5 stack[-9] = stack[-6] // @36D7 stack[-8] = stack[-5] // @36D9 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_36DC: // Incoming jump from 0x0786 // Inputs[2] // { // @36E2 stack[-1] // @36E3 stack[-2] // } 36DC 5B JUMPDEST 36DD 60 PUSH1 0x00 36DF 80 DUP1 36E0 60 PUSH1 0x40 36E2 83 DUP4 36E3 85 DUP6 36E4 03 SUB 36E5 12 SLT 36E6 15 ISZERO 36E7 61 PUSH2 0x36ef 36EA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @36DD stack[0] = 0x00 // @36DF stack[1] = 0x00 // } // Block ends with conditional jump to 0x36ef, if !(stack[-2] - stack[-1] i< 0x40) label_36EB: // Incoming jump from 0x36EA, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @36EE memory[0x00:0x00] } 36EB 60 PUSH1 0x00 36ED 80 DUP1 36EE FD *REVERT // Stack delta = +0 // Outputs[1] { @36EE revert(memory[0x00:0x00]); } // Block terminates label_36EF: // Incoming jump from 0x36EA, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @36F0 stack[-3] // @36F1 msg.data[stack[-3]:stack[-3] + 0x20] // } 36EF 5B JUMPDEST 36F0 82 DUP3 36F1 35 CALLDATALOAD 36F2 61 PUSH2 0x36fa 36F5 81 DUP2 36F6 61 PUSH2 0x3219 36F9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @36F1 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @36F2 stack[1] = 0x36fa // @36F5 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x3219, returns to 0x36FA label_36FA: // Incoming return from call to 0x3219 at 0x36F9 // Inputs[4] // { // @36FB stack[-1] // @36FB stack[-3] // @36FF stack[-4] // @3701 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 36FA 5B JUMPDEST 36FB 91 SWAP2 36FC 50 POP 36FD 60 PUSH1 0x20 36FF 83 DUP4 3700 01 ADD 3701 35 CALLDATALOAD 3702 61 PUSH2 0x3268 3705 81 DUP2 3706 61 PUSH2 0x3219 3709 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @36FB stack[-3] = stack[-1] // @3701 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @3702 stack[0] = 0x3268 // @3705 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x3219, returns to 0x3268 label_370A: // Incoming call from 0x0E0F, returns to 0x0807 // Incoming call from 0x143D, returns to 0x0807 // Incoming call from 0x0C21, returns to 0x0807 // Incoming call from 0x1125, returns to 0x0807 // Incoming call from 0x129A, returns to 0x0807 // Incoming call from 0x0A84, returns to 0x0807 // Incoming call from 0x0FAC, returns to 0x0807 // Incoming call from 0x0AB9, returns to 0x0807 // Incoming call from 0x0B36, returns to 0x0807 // Incoming call from 0x0806, returns to 0x0807 // Incoming call from 0x0FE0, returns to 0x0807 // Incoming call from 0x1472, returns to 0x0807 // Incoming call from 0x0E5F, returns to 0x0807 // Inputs[2] // { // @370E stack[-1] // @373D stack[-2] // } 370A 5B JUMPDEST 370B 60 PUSH1 0x20 370D 80 DUP1 370E 82 DUP3 370F 52 MSTORE 3710 81 DUP2 3711 81 DUP2 3712 01 ADD 3713 52 MSTORE 3714 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 3735 60 PUSH1 0x40 3737 82 DUP3 3738 01 ADD 3739 52 MSTORE 373A 60 PUSH1 0x60 373C 01 ADD 373D 90 SWAP1 373E 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @370F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3713 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @3739 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @373D stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_373F: // Incoming call from 0x1386, returns to 0x1387 // Incoming call from 0x0858, returns to 0x0859 // Incoming call from 0x13B2, returns to 0x13B3 // Incoming call from 0x3158, returns to 0x3159 // Incoming call from 0x082C, returns to 0x082D // Incoming call from 0x103C, returns to 0x082D // Incoming call from 0x2959, returns to 0x082D // Inputs[1] { @3742 stack[-1] } 373F 5B JUMPDEST 3740 60 PUSH1 0x01 3742 81 DUP2 3743 81 DUP2 3744 1C SHR 3745 90 SWAP1 3746 82 DUP3 3747 16 AND 3748 80 DUP1 3749 61 PUSH2 0x3753 374C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3745 stack[0] = stack[-1] >> 0x01 // @3747 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x3753, if stack[-1] & 0x01 label_374D: // Incoming jump from 0x374C, if not stack[-1] & 0x01 // Inputs[2] // { // @374F stack[-2] // @3758 stack[-1] // } 374D 60 PUSH1 0x7f 374F 82 DUP3 3750 16 AND 3751 91 SWAP2 3752 50 POP 3753 5B JUMPDEST 3754 60 PUSH1 0x20 3756 82 DUP3 3757 10 LT 3758 81 DUP2 3759 14 EQ 375A 15 ISZERO 375B 61 PUSH2 0x3774 375E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3751 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x3774, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_375F: // Incoming jump from 0x375E, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x375E, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @3773 memory[0x00:0x24] } 375F 63 PUSH4 0x4e487b71 3764 60 PUSH1 0xe0 3766 1B SHL 3767 60 PUSH1 0x00 3769 52 MSTORE 376A 60 PUSH1 0x22 376C 60 PUSH1 0x04 376E 52 MSTORE 376F 60 PUSH1 0x24 3771 60 PUSH1 0x00 3773 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3769 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @376E memory[0x04:0x24] = 0x22 // @3773 revert(memory[0x00:0x24]); // } // Block terminates label_3774: // Incoming jump from 0x375E, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x375E, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @3776 stack[-2] // @3776 stack[-4] // @3777 stack[-3] // } 3774 5B JUMPDEST 3775 50 POP 3776 91 SWAP2 3777 90 SWAP1 3778 50 POP 3779 56 *JUMP // Stack delta = -3 // Outputs[1] { @3776 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_377A: // Incoming call from 0x0B01, returns to 0x0807 // Incoming call from 0x10E9, returns to 0x0807 // Inputs[2] // { // @377E stack[-1] // @37C9 stack[-2] // } 377A 5B JUMPDEST 377B 60 PUSH1 0x20 377D 80 DUP1 377E 82 DUP3 377F 52 MSTORE 3780 60 PUSH1 0x31 3782 90 SWAP1 3783 82 DUP3 3784 01 ADD 3785 52 MSTORE 3786 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 37A7 60 PUSH1 0x40 37A9 82 DUP3 37AA 01 ADD 37AB 52 MSTORE 37AC 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 37BE 60 PUSH1 0x7a 37C0 1B SHL 37C1 60 PUSH1 0x60 37C3 82 DUP3 37C4 01 ADD 37C5 52 MSTORE 37C6 60 PUSH1 0x80 37C8 01 ADD 37C9 90 SWAP1 37CA 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @377F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3785 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x31 // @37AB memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @37C5 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x1ddb995c881b9bdc88185c1c1c9bdd9959 << 0x7a // @37C9 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_37CB: // Incoming jump from 0x3988 // Incoming jump from 0x38C2 // Incoming jump from 0x37FA // Incoming jump from 0x3865 // Inputs[1] { @37E0 memory[0x00:0x24] } 37CB 5B JUMPDEST 37CC 63 PUSH4 0x4e487b71 37D1 60 PUSH1 0xe0 37D3 1B SHL 37D4 60 PUSH1 0x00 37D6 52 MSTORE 37D7 60 PUSH1 0x11 37D9 60 PUSH1 0x04 37DB 52 MSTORE 37DC 60 PUSH1 0x24 37DE 60 PUSH1 0x00 37E0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @37D6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @37DB memory[0x04:0x24] = 0x11 // @37E0 revert(memory[0x00:0x24]); // } // Block terminates label_37E1: // Incoming call from 0x0E2E, returns to 0x0E2F // Incoming call from 0x0BDD, returns to 0x0BDE // Incoming call from 0x0BDD, returns to 0x0BDE // Inputs[2] // { // @37E4 stack[-1] // @37E9 stack[-2] // } 37E1 5B JUMPDEST 37E2 60 PUSH1 0x00 37E4 81 DUP2 37E5 60 PUSH1 0x00 37E7 19 NOT 37E8 04 DIV 37E9 83 DUP4 37EA 11 GT 37EB 82 DUP3 37EC 15 ISZERO 37ED 15 ISZERO 37EE 16 AND 37EF 15 ISZERO 37F0 61 PUSH2 0x37fb 37F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @37E2 stack[0] = 0x00 } // Block ends with conditional jump to 0x37fb, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_37F4: // Incoming jump from 0x37F3, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 37F4 61 PUSH2 0x37fb 37F7 61 PUSH2 0x37cb 37FA 56 *JUMP // Stack delta = +1 // Outputs[1] { @37F4 stack[0] = 0x37fb } // Block ends with unconditional jump to 0x37cb label_37FB: // Incoming jump from 0x37F3, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @37FD stack[-3] // @37FD stack[-2] // @37FE stack[-4] // } 37FB 5B JUMPDEST 37FC 50 POP 37FD 02 MUL 37FE 90 SWAP1 37FF 56 *JUMP // Stack delta = -3 // Outputs[1] { @37FE stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_3800: // Incoming jump from 0x399E // Incoming jump from 0x3824 // Inputs[1] { @3815 memory[0x00:0x24] } 3800 5B JUMPDEST 3801 63 PUSH4 0x4e487b71 3806 60 PUSH1 0xe0 3808 1B SHL 3809 60 PUSH1 0x00 380B 52 MSTORE 380C 60 PUSH1 0x12 380E 60 PUSH1 0x04 3810 52 MSTORE 3811 60 PUSH1 0x24 3813 60 PUSH1 0x00 3815 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @380B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @3810 memory[0x04:0x24] = 0x12 // @3815 revert(memory[0x00:0x24]); // } // Block terminates label_3816: // Incoming call from 0x226E, returns to 0x226F // Incoming call from 0x21BE, returns to 0x21BF // Incoming call from 0x0BE7, returns to 0x0BE8 // Incoming call from 0x1E85, returns to 0x1E86 // Inputs[1] { @3819 stack[-2] } 3816 5B JUMPDEST 3817 60 PUSH1 0x00 3819 82 DUP3 381A 61 PUSH2 0x3825 381D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3817 stack[0] = 0x00 } // Block ends with conditional jump to 0x3825, if stack[-2] label_381E: // Incoming jump from 0x381D, if not stack[-2] 381E 61 PUSH2 0x3825 3821 61 PUSH2 0x3800 3824 56 *JUMP // Stack delta = +1 // Outputs[1] { @381E stack[0] = 0x3825 } // Block ends with unconditional jump to 0x3800 label_3825: // Incoming jump from 0x381D, if stack[-2] // Inputs[3] // { // @3827 stack[-3] // @3827 stack[-2] // @3828 stack[-4] // } 3825 5B JUMPDEST 3826 50 POP 3827 04 DIV 3828 90 SWAP1 3829 56 *JUMP // Stack delta = -3 // Outputs[1] { @3828 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_382A: // Incoming call from 0x1A23, returns to 0x0807 // Incoming call from 0x114F, returns to 0x0807 // Incoming call from 0x1BDA, returns to 0x0807 // Inputs[2] // { // @382E stack[-1] // @3852 stack[-2] // } 382A 5B JUMPDEST 382B 60 PUSH1 0x20 382D 80 DUP1 382E 82 DUP3 382F 52 MSTORE 3830 60 PUSH1 0x10 3832 90 SWAP1 3833 82 DUP3 3834 01 ADD 3835 52 MSTORE 3836 6F PUSH16 0x14185d5cd8589b194e881c185d5cd959 3847 60 PUSH1 0x82 3849 1B SHL 384A 60 PUSH1 0x40 384C 82 DUP3 384D 01 ADD 384E 52 MSTORE 384F 60 PUSH1 0x60 3851 01 ADD 3852 90 SWAP1 3853 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @382F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3835 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x10 // @384E memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x14185d5cd8589b194e881c185d5cd959 << 0x82 // @3852 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_3854: // Incoming call from 0x24D0, returns to 0x24D1 // Incoming call from 0x221F, returns to 0x2220 // Incoming call from 0x1C80, returns to 0x1C81 // Incoming call from 0x1CBD, returns to 0x1173 // Incoming call from 0x2344, returns to 0x2345 // Incoming call from 0x1C98, returns to 0x1C99 // Incoming call from 0x2330, returns to 0x2331 // Incoming call from 0x1CBD, returns to 0x1173 // Incoming call from 0x1172, returns to 0x1173 // Inputs[2] // { // @3857 stack[-2] // @3858 stack[-1] // } 3854 5B JUMPDEST 3855 60 PUSH1 0x00 3857 82 DUP3 3858 82 DUP3 3859 10 LT 385A 15 ISZERO 385B 61 PUSH2 0x3866 385E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3855 stack[0] = 0x00 } // Block ends with conditional jump to 0x3866, if !(stack[-1] < stack[-2]) label_385F: // Incoming jump from 0x385E, if not !(stack[-1] < stack[-2]) 385F 61 PUSH2 0x3866 3862 61 PUSH2 0x37cb 3865 56 *JUMP // Stack delta = +1 // Outputs[1] { @385F stack[0] = 0x3866 } // Block ends with unconditional jump to 0x37cb label_3866: // Incoming jump from 0x385E, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @3868 stack[-3] // @3868 stack[-2] // @3869 stack[-4] // } 3866 5B JUMPDEST 3867 50 POP 3868 03 SUB 3869 90 SWAP1 386A 56 *JUMP // Stack delta = -3 // Outputs[1] { @3869 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] 386B 5B JUMPDEST 386C 63 PUSH4 0x4e487b71 3871 60 PUSH1 0xe0 3873 1B SHL 3874 60 PUSH1 0x00 3876 52 MSTORE 3877 60 PUSH1 0x01 3879 60 PUSH1 0x04 387B 52 MSTORE 387C 60 PUSH1 0x24 387E 60 PUSH1 0x00 3880 FD *REVERT 3881 5B JUMPDEST 3882 60 PUSH1 0x00 3884 83 DUP4 3885 51 MLOAD 3886 61 PUSH2 0x3893 3889 81 DUP2 388A 84 DUP5 388B 60 PUSH1 0x20 388D 88 DUP9 388E 01 ADD 388F 61 PUSH2 0x3273 3892 56 *JUMP 3893 5B JUMPDEST 3894 83 DUP4 3895 51 MLOAD 3896 90 SWAP1 3897 83 DUP4 3898 01 ADD 3899 90 SWAP1 389A 61 PUSH2 0x38a7 389D 81 DUP2 389E 83 DUP4 389F 60 PUSH1 0x20 38A1 88 DUP9 38A2 01 ADD 38A3 61 PUSH2 0x3273 38A6 56 *JUMP 38A7 5B JUMPDEST 38A8 01 ADD 38A9 94 SWAP5 38AA 93 SWAP4 38AB 50 POP 38AC 50 POP 38AD 50 POP 38AE 50 POP 38AF 56 *JUMP label_38B0: // Incoming call from 0x2164, returns to 0x2165 // Incoming call from 0x1E00, returns to 0x1E01 // Incoming call from 0x1E55, returns to 0x1E56 // Incoming call from 0x2237, returns to 0x2238 // Incoming call from 0x2B98, returns to 0x2B99 // Incoming call from 0x1E2A, returns to 0x1E2B // Inputs[2] // { // @38B3 stack[-2] // @38B5 stack[-1] // } 38B0 5B JUMPDEST 38B1 60 PUSH1 0x00 38B3 82 DUP3 38B4 19 NOT 38B5 82 DUP3 38B6 11 GT 38B7 15 ISZERO 38B8 61 PUSH2 0x38c3 38BB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @38B1 stack[0] = 0x00 } // Block ends with conditional jump to 0x38c3, if !(stack[-1] > ~stack[-2]) label_38BC: // Incoming jump from 0x38BB, if not !(stack[-1] > ~stack[-2]) 38BC 61 PUSH2 0x38c3 38BF 61 PUSH2 0x37cb 38C2 56 *JUMP // Stack delta = +1 // Outputs[1] { @38BC stack[0] = 0x38c3 } // Block ends with unconditional jump to 0x37cb label_38C3: // Incoming jump from 0x38BB, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @38C5 stack[-3] // @38C5 stack[-2] // @38C6 stack[-4] // } 38C3 5B JUMPDEST 38C4 50 POP 38C5 01 ADD 38C6 90 SWAP1 38C7 56 *JUMP // Stack delta = -3 // Outputs[1] { @38C6 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_38C8: // Incoming call from 0x1E9A, returns to 0x1E9B // Inputs[3] // { // @38DB stack[-1] // @38DF stack[-2] // @38E0 memory[stack[-2]:stack[-2] + 0x20] // } 38C8 5B JUMPDEST 38C9 6D PUSH14 0x029b2b63632b91d1021b7b9ba399 38D8 60 PUSH1 0x95 38DA 1B SHL 38DB 81 DUP2 38DC 52 MSTORE 38DD 60 PUSH1 0x00 38DF 82 DUP3 38E0 51 MLOAD 38E1 61 PUSH2 0x38f1 38E4 81 DUP2 38E5 60 PUSH1 0x0e 38E7 85 DUP6 38E8 01 ADD 38E9 60 PUSH1 0x20 38EB 87 DUP8 38EC 01 ADD 38ED 61 PUSH2 0x3273 38F0 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @38DC memory[stack[-1]:stack[-1] + 0x20] = 0x029b2b63632b91d1021b7b9ba399 << 0x95 // @38DD stack[0] = 0x00 // @38E0 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @38E1 stack[2] = 0x38f1 // @38E4 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @38E8 stack[4] = stack[-1] + 0x0e // @38EC stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x3273, returns to 0x38F1 label_38F1: // Incoming return from call to 0x3273 at 0x38F0 // Inputs[4] // { // @38FD stack[-3] // @38FF stack[-1] // @3909 stack[-5] // @390A stack[-4] // } 38F1 5B JUMPDEST 38F2 64 PUSH5 0x2047576569 38F8 60 PUSH1 0xd8 38FA 1B SHL 38FB 60 PUSH1 0x0e 38FD 93 SWAP4 38FE 90 SWAP1 38FF 91 SWAP2 3900 01 ADD 3901 92 SWAP3 3902 83 DUP4 3903 01 ADD 3904 52 MSTORE 3905 50 POP 3906 60 PUSH1 0x13 3908 01 ADD 3909 91 SWAP2 390A 90 SWAP1 390B 50 POP 390C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3904 memory[stack[-1] + stack[-3] + 0x0e:stack[-1] + stack[-3] + 0x0e + 0x20] = 0x2047576569 << 0xd8 // @3909 stack[-5] = 0x13 + stack[-1] + stack[-3] // } // Block ends with unconditional jump to stack[-5] label_390D: // Incoming jump from 0x22DA // Incoming jump from 0x2099 // Incoming jump from 0x2A82 // Inputs[1] { @3922 memory[0x00:0x24] } 390D 5B JUMPDEST 390E 63 PUSH4 0x4e487b71 3913 60 PUSH1 0xe0 3915 1B SHL 3916 60 PUSH1 0x00 3918 52 MSTORE 3919 60 PUSH1 0x21 391B 60 PUSH1 0x04 391D 52 MSTORE 391E 60 PUSH1 0x24 3920 60 PUSH1 0x00 3922 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @3918 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @391D memory[0x04:0x24] = 0x21 // @3922 revert(memory[0x00:0x24]); // } // Block terminates 3923 5B JUMPDEST 3924 60 PUSH1 0x20 3926 80 DUP1 3927 82 DUP3 3928 52 MSTORE 3929 60 PUSH1 0x32 392B 90 SWAP1 392C 82 DUP3 392D 01 ADD 392E 52 MSTORE 392F 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 3950 60 PUSH1 0x40 3952 82 DUP3 3953 01 ADD 3954 52 MSTORE 3955 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 3968 60 PUSH1 0x71 396A 1B SHL 396B 60 PUSH1 0x60 396D 82 DUP3 396E 01 ADD 396F 52 MSTORE 3970 60 PUSH1 0x80 3972 01 ADD 3973 90 SWAP1 3974 56 *JUMP label_3975: // Incoming call from 0x21AF, returns to 0x21B0 // Inputs[1] { @397B stack[-1] } 3975 5B JUMPDEST 3976 60 PUSH1 0x00 3978 60 PUSH1 0x00 397A 19 NOT 397B 82 DUP3 397C 14 EQ 397D 15 ISZERO 397E 61 PUSH2 0x3989 3981 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3976 stack[0] = 0x00 } // Block ends with conditional jump to 0x3989, if !(stack[-1] == ~0x00) label_3982: // Incoming jump from 0x3981, if not !(stack[-1] == ~0x00) 3982 61 PUSH2 0x3989 3985 61 PUSH2 0x37cb 3988 56 *JUMP // Stack delta = +1 // Outputs[1] { @3982 stack[0] = 0x3989 } // Block ends with unconditional jump to 0x37cb label_3989: // Incoming jump from 0x3981, if !(stack[-1] == ~0x00) // Inputs[2] // { // @398D stack[-2] // @398E stack[-3] // } 3989 5B JUMPDEST 398A 50 POP 398B 60 PUSH1 0x01 398D 01 ADD 398E 90 SWAP1 398F 56 *JUMP // Stack delta = -2 // Outputs[1] { @398E stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_3990: // Incoming call from 0x222C, returns to 0x222D // Inputs[1] { @3993 stack[-2] } 3990 5B JUMPDEST 3991 60 PUSH1 0x00 3993 82 DUP3 3994 61 PUSH2 0x399f 3997 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3991 stack[0] = 0x00 } // Block ends with conditional jump to 0x399f, if stack[-2] label_3998: // Incoming jump from 0x3997, if not stack[-2] 3998 61 PUSH2 0x399f 399B 61 PUSH2 0x3800 399E 56 *JUMP // Stack delta = +1 // Outputs[1] { @3998 stack[0] = 0x399f } // Block ends with unconditional jump to 0x3800 label_399F: // Incoming jump from 0x3997, if stack[-2] // Inputs[3] // { // @39A1 stack[-2] // @39A1 stack[-3] // @39A2 stack[-4] // } 399F 5B JUMPDEST 39A0 50 POP 39A1 06 MOD 39A2 90 SWAP1 39A3 56 *JUMP // Stack delta = -3 // Outputs[1] { @39A2 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_39A4: // Incoming jump from 0x2364 // Incoming jump from 0x224C // Incoming jump from 0x2387 // Inputs[1] { @39B9 memory[0x00:0x24] } 39A4 5B JUMPDEST 39A5 63 PUSH4 0x4e487b71 39AA 60 PUSH1 0xe0 39AC 1B SHL 39AD 60 PUSH1 0x00 39AF 52 MSTORE 39B0 60 PUSH1 0x32 39B2 60 PUSH1 0x04 39B4 52 MSTORE 39B5 60 PUSH1 0x24 39B7 60 PUSH1 0x00 39B9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @39AF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @39B4 memory[0x04:0x24] = 0x32 // @39B9 revert(memory[0x00:0x24]); // } // Block terminates label_39BA: // Incoming jump from 0x23BA // Inputs[1] { @39CF memory[0x00:0x24] } 39BA 5B JUMPDEST 39BB 63 PUSH4 0x4e487b71 39C0 60 PUSH1 0xe0 39C2 1B SHL 39C3 60 PUSH1 0x00 39C5 52 MSTORE 39C6 60 PUSH1 0x31 39C8 60 PUSH1 0x04 39CA 52 MSTORE 39CB 60 PUSH1 0x24 39CD 60 PUSH1 0x00 39CF FD *REVERT // Stack delta = +0 // Outputs[3] // { // @39C5 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @39CA memory[0x04:0x24] = 0x31 // @39CF revert(memory[0x00:0x24]); // } // Block terminates label_39D0: // Incoming call from 0x2428, returns to 0x2429 // Inputs[3] // { // @39F2 stack[-1] // @39F6 stack[-3] // @39F7 memory[stack[-3]:stack[-3] + 0x20] // } 39D0 5B JUMPDEST 39D1 7F PUSH32 0x19457468657265756d205369676e6564204d6573736167653a0a000000000000 39F2 81 DUP2 39F3 52 MSTORE 39F4 60 PUSH1 0x00 39F6 83 DUP4 39F7 51 MLOAD 39F8 61 PUSH2 0x3a08 39FB 81 DUP2 39FC 60 PUSH1 0x1a 39FE 85 DUP6 39FF 01 ADD 3A00 60 PUSH1 0x20 3A02 88 DUP9 3A03 01 ADD 3A04 61 PUSH2 0x3273 3A07 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @39F3 memory[stack[-1]:stack[-1] + 0x20] = 0x19457468657265756d205369676e6564204d6573736167653a0a000000000000 // @39F4 stack[0] = 0x00 // @39F7 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @39F8 stack[2] = 0x3a08 // @39FB stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @39FF stack[4] = stack[-1] + 0x1a // @3A03 stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x3273, returns to 0x3A08 label_3A08: // Incoming return from call to 0x3273 at 0x3A07 // Inputs[4] // { // @3A09 stack[-4] // @3A0A memory[stack[-4]:stack[-4] + 0x20] // @3A0B stack[-1] // @3A0C stack[-3] // } 3A08 5B JUMPDEST 3A09 83 DUP4 3A0A 51 MLOAD 3A0B 90 SWAP1 3A0C 83 DUP4 3A0D 01 ADD 3A0E 90 SWAP1 3A0F 61 PUSH2 0x3a1f 3A12 81 DUP2 3A13 60 PUSH1 0x1a 3A15 84 DUP5 3A16 01 ADD 3A17 60 PUSH1 0x20 3A19 88 DUP9 3A1A 01 ADD 3A1B 61 PUSH2 0x3273 3A1E 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @3A0E stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @3A0E stack[-1] = stack[-3] + stack[-1] // @3A0F stack[1] = 0x3a1f // @3A12 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @3A16 stack[3] = stack[-3] + stack[-1] + 0x1a // @3A1A stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x3273, returns to 0x3A1F label_3A1F: // Incoming return from call to 0x3273 at 0x3A1E // Inputs[4] // { // @3A20 stack[-1] // @3A20 stack[-2] // @3A24 stack[-7] // @3A25 stack[-6] // } 3A1F 5B JUMPDEST 3A20 01 ADD 3A21 60 PUSH1 0x1a 3A23 01 ADD 3A24 94 SWAP5 3A25 93 SWAP4 3A26 50 POP 3A27 50 POP 3A28 50 POP 3A29 50 POP 3A2A 56 *JUMP // Stack delta = -6 // Outputs[1] { @3A24 stack[-7] = 0x1a + stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] label_3A2B: // Incoming call from 0x24E8, returns to 0x1E9B // Inputs[3] // { // @3A38 stack[-1] // @3A3C stack[-2] // @3A3D memory[stack[-2]:stack[-2] + 0x20] // } 3A2B 5B JUMPDEST 3A2C 67 PUSH8 0x029b2b63632b91d1 3A35 60 PUSH1 0xc5 3A37 1B SHL 3A38 81 DUP2 3A39 52 MSTORE 3A3A 60 PUSH1 0x00 3A3C 82 DUP3 3A3D 51 MLOAD 3A3E 61 PUSH2 0x3a4e 3A41 81 DUP2 3A42 60 PUSH1 0x08 3A44 85 DUP6 3A45 01 ADD 3A46 60 PUSH1 0x20 3A48 87 DUP8 3A49 01 ADD 3A4A 61 PUSH2 0x3273 3A4D 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @3A39 memory[stack[-1]:stack[-1] + 0x20] = 0x029b2b63632b91d1 << 0xc5 // @3A3A stack[0] = 0x00 // @3A3D stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @3A3E stack[2] = 0x3a4e // @3A41 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @3A45 stack[4] = stack[-1] + 0x08 // @3A49 stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x3273, returns to 0x3A4E label_3A4E: // Incoming return from call to 0x3273 at 0x3A4D // Inputs[5] // { // @3A4F stack[-1] // @3A4F stack[-3] // @3A50 stack[-2] // @3A56 stack[-5] // @3A57 stack[-4] // } 3A4E 5B JUMPDEST 3A4F 91 SWAP2 3A50 90 SWAP1 3A51 91 SWAP2 3A52 01 ADD 3A53 60 PUSH1 0x08 3A55 01 ADD 3A56 92 SWAP3 3A57 91 SWAP2 3A58 50 POP 3A59 50 POP 3A5A 56 *JUMP // Stack delta = -4 // Outputs[1] { @3A56 stack[-5] = 0x08 + stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] label_3A5B: // Incoming jump from 0x276B // Inputs[2] // { // @3A60 stack[-1] // @3A61 stack[-2] // } 3A5B 5B JUMPDEST 3A5C 60 PUSH1 0x00 3A5E 60 PUSH1 0x20 3A60 82 DUP3 3A61 84 DUP5 3A62 03 SUB 3A63 12 SLT 3A64 15 ISZERO 3A65 61 PUSH2 0x3a6d 3A68 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A5C stack[0] = 0x00 } // Block ends with conditional jump to 0x3a6d, if !(stack[-2] - stack[-1] i< 0x20) label_3A69: // Incoming jump from 0x3A68, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @3A6C memory[0x00:0x00] } 3A69 60 PUSH1 0x00 3A6B 80 DUP1 3A6C FD *REVERT // Stack delta = +0 // Outputs[1] { @3A6C revert(memory[0x00:0x00]); } // Block terminates label_3A6D: // Incoming jump from 0x3A68, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3A6E stack[-2] // @3A6F memory[stack[-2]:stack[-2] + 0x20] // } 3A6D 5B JUMPDEST 3A6E 81 DUP2 3A6F 51 MLOAD 3A70 61 PUSH2 0x0e2f 3A73 81 DUP2 3A74 61 PUSH2 0x3219 3A77 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3A6F stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @3A70 stack[1] = 0x0e2f // @3A73 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3219, returns to 0x0E2F 3A78 5B JUMPDEST 3A79 60 PUSH1 0x01 3A7B 60 PUSH1 0x01 3A7D 60 PUSH1 0xa0 3A7F 1B SHL 3A80 03 SUB 3A81 85 DUP6 3A82 81 DUP2 3A83 16 AND 3A84 82 DUP3 3A85 52 MSTORE 3A86 84 DUP5 3A87 16 AND 3A88 60 PUSH1 0x20 3A8A 82 DUP3 3A8B 01 ADD 3A8C 52 MSTORE 3A8D 60 PUSH1 0x40 3A8F 81 DUP2 3A90 01 ADD 3A91 83 DUP4 3A92 90 SWAP1 3A93 52 MSTORE 3A94 60 PUSH1 0x80 3A96 60 PUSH1 0x60 3A98 82 DUP3 3A99 01 ADD 3A9A 81 DUP2 3A9B 90 SWAP1 3A9C 52 MSTORE 3A9D 60 PUSH1 0x00 3A9F 90 SWAP1 3AA0 61 PUSH2 0x3aab 3AA3 90 SWAP1 3AA4 83 DUP4 3AA5 01 ADD 3AA6 84 DUP5 3AA7 61 PUSH2 0x329f 3AAA 56 *JUMP 3AAB 5B JUMPDEST 3AAC 96 SWAP7 3AAD 95 SWAP6 3AAE 50 POP 3AAF 50 POP 3AB0 50 POP 3AB1 50 POP 3AB2 50 POP 3AB3 50 POP 3AB4 56 *JUMP 3AB5 5B JUMPDEST 3AB6 60 PUSH1 0x00 3AB8 60 PUSH1 0x20 3ABA 82 DUP3 3ABB 84 DUP5 3ABC 03 SUB 3ABD 12 SLT 3ABE 15 ISZERO 3ABF 61 PUSH2 0x3ac7 3AC2 57 *JUMPI 3AC3 60 PUSH1 0x00 3AC5 80 DUP1 3AC6 FD *REVERT 3AC7 5B JUMPDEST 3AC8 81 DUP2 3AC9 51 MLOAD 3ACA 61 PUSH2 0x0e2f 3ACD 81 DUP2 3ACE 61 PUSH2 0x31e6 3AD1 56 *JUMP 3AD2 FE *ASSERT 3AD3 A2 LOG2 3AD4 64 PUSH5 0x6970667358 3ADA 22 22 3ADB 12 SLT 3ADC 20 SHA3 3ADD F3 *RETURN 3ADE 83 DUP4 3ADF 87 DUP8 3AE0 08 ADDMOD 3AE1 9F SWAP16 3AE2 3C EXTCODECOPY 3AE3 A9 A9 3AE4 CD CD 3AE5 9B SWAP12 3AE6 6C PUSH13 0x296bf459a417c9697e23e4c99e 3AF4 D7 D7 3AF5 92 SWAP3 3AF6 9A SWAP11 3AF7 8D DUP14 3AF8 40 BLOCKHASH 3AF9 AE AE 3AFA D6 D6 3AFB 41 COINBASE 3AFC 3A GASPRICE 3AFD 64 PUSH5 0x736f6c6343 3B03 00 *STOP 3B04 08 ADDMOD 3B05 0B SIGNEXTEND 3B06 00 *STOP 3B07 33 CALLER