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 0x01f8 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01f8, 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 0x70a08231 0019 11 GT 001A 61 PUSH2 0x010d 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x010d, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa22cb465 0024 11 GT 0025 61 PUSH2 0x00a0 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a0, 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 0xb88d4fde 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xb88d4fde > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xb88d4fde 003A 14 EQ 003B 61 PUSH2 0x0535 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0535, if 0xb88d4fde == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xb88d4fde == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xc87b56dd 0045 14 EQ 0046 61 PUSH2 0x0555 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0555, 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 0xd031370b 0050 14 EQ 0051 61 PUSH2 0x0575 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0575, if 0xd031370b == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xd031370b == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x0595 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0595, 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 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x05b5 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b5, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == stack[-1] 006B 61 PUSH2 0x01f8 006E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f8 label_006F: // Incoming jump from 0x0033, if 0xb88d4fde > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xa22cb465 0076 14 EQ 0077 61 PUSH2 0x04cb 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cb, if 0xa22cb465 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xa22cb465 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xa4fe0ecc 0081 14 EQ 0082 61 PUSH2 0x04eb 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04eb, if 0xa4fe0ecc == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xa4fe0ecc == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xaa66797b 008C 14 EQ 008D 61 PUSH2 0x050b 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050b, if 0xaa66797b == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xaa66797b == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xb66a0e5d 0097 14 EQ 0098 61 PUSH2 0x0520 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0520, if 0xb66a0e5d == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xb66a0e5d == stack[-1] 009C 61 PUSH2 0x01f8 009F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f8 label_00A0: // Incoming jump from 0x0028, if 0xa22cb465 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x8b78e8f7 00A7 11 GT 00A8 61 PUSH2 0x00dc 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0x8b78e8f7 > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x8b78e8f7 > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x8b78e8f7 00B2 14 EQ 00B3 61 PUSH2 0x0479 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0479, if 0x8b78e8f7 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x8b78e8f7 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x8da5cb5b 00BD 14 EQ 00BE 61 PUSH2 0x048e 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048e, if 0x8da5cb5b == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x95d89b41 00C8 14 EQ 00C9 61 PUSH2 0x04a3 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a3, if 0x95d89b41 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xa0712d68 00D3 14 EQ 00D4 61 PUSH2 0x04b8 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b8, if 0xa0712d68 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xa0712d68 == stack[-1] 00D8 61 PUSH2 0x01f8 00DB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f8 label_00DC: // Incoming jump from 0x00AB, if 0x8b78e8f7 > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x70a08231 00E3 14 EQ 00E4 61 PUSH2 0x0404 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0404, if 0x70a08231 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x70a08231 == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x743976a0 00EE 14 EQ 00EF 61 PUSH2 0x0424 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0424, if 0x743976a0 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x743976a0 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x7835c635 00F9 14 EQ 00FA 61 PUSH2 0x0439 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0439, if 0x7835c635 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x7835c635 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x8462151c 0104 14 EQ 0105 61 PUSH2 0x044c 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044c, if 0x8462151c == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x8462151c == stack[-1] 0109 61 PUSH2 0x01f8 010C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f8 label_010D: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @010E stack[-1] } 010D 5B JUMPDEST 010E 80 DUP1 010F 63 PUSH4 0x2e280e32 0114 11 GT 0115 61 PUSH2 0x0190 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0190, if 0x2e280e32 > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x2e280e32 > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x42842e0e 011F 11 GT 0120 61 PUSH2 0x015f 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x015f, if 0x42842e0e > stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x42842e0e > stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x42842e0e 012A 14 EQ 012B 61 PUSH2 0x036f 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036f, if 0x42842e0e == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x42842e0e == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x4f6ccce7 0135 14 EQ 0136 61 PUSH2 0x038f 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038f, if 0x4f6ccce7 == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x55f804b3 0140 14 EQ 0141 61 PUSH2 0x03af 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03af, if 0x55f804b3 == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x6352211e 014B 14 EQ 014C 61 PUSH2 0x03cf 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cf, if 0x6352211e == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x6352211e == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x6b8dc355 0156 14 EQ 0157 61 PUSH2 0x03ef 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ef, if 0x6b8dc355 == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x6b8dc355 == stack[-1] 015B 61 PUSH2 0x01f8 015E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f8 label_015F: // Incoming jump from 0x0123, if 0x42842e0e > stack[-1] // Inputs[1] { @0160 stack[-1] } 015F 5B JUMPDEST 0160 80 DUP1 0161 63 PUSH4 0x2e280e32 0166 14 EQ 0167 61 PUSH2 0x0310 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0310, if 0x2e280e32 == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x2e280e32 == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x2f745c59 0171 14 EQ 0172 61 PUSH2 0x0325 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0325, if 0x2f745c59 == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x32cb6b0c 017C 14 EQ 017D 61 PUSH2 0x0345 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0345, if 0x32cb6b0c == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x3ccfd60b 0187 14 EQ 0188 61 PUSH2 0x035a 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035a, if 0x3ccfd60b == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x3ccfd60b == stack[-1] 018C 61 PUSH2 0x01f8 018F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f8 label_0190: // Incoming jump from 0x0118, if 0x2e280e32 > stack[-1] // Inputs[1] { @0191 stack[-1] } 0190 5B JUMPDEST 0191 80 DUP1 0192 63 PUSH4 0x095ea7b3 0197 11 GT 0198 61 PUSH2 0x01cc 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cc, if 0x095ea7b3 > stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x095ea7b3 01A2 14 EQ 01A3 61 PUSH2 0x0297 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0297, if 0x095ea7b3 == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x0c5a78d9 01AD 14 EQ 01AE 61 PUSH2 0x02b9 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b9, if 0x0c5a78d9 == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x0c5a78d9 == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x18160ddd 01B8 14 EQ 01B9 61 PUSH2 0x02ce 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ce, if 0x18160ddd == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x18160ddd == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x23b872dd 01C3 14 EQ 01C4 61 PUSH2 0x02f0 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f0, if 0x23b872dd == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x23b872dd == stack[-1] 01C8 61 PUSH2 0x01f8 01CB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x01f8 label_01CC: // Incoming jump from 0x019B, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01CD stack[-1] } 01CC 5B JUMPDEST 01CD 80 DUP1 01CE 62 PUSH3 0x8ca816 01D2 14 EQ 01D3 61 PUSH2 0x01fd 01D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fd, if 0x8ca816 == stack[-1] label_01D7: // Incoming jump from 0x01D6, if not 0x8ca816 == stack[-1] // Inputs[1] { @01D7 stack[-1] } 01D7 80 DUP1 01D8 63 PUSH4 0x01ffc9a7 01DD 14 EQ 01DE 61 PUSH2 0x0228 01E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0228, if 0x01ffc9a7 == stack[-1] label_01E2: // Incoming jump from 0x01E1, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01E2 stack[-1] } 01E2 80 DUP1 01E3 63 PUSH4 0x06fdde03 01E8 14 EQ 01E9 61 PUSH2 0x0248 01EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0248, if 0x06fdde03 == stack[-1] label_01ED: // Incoming jump from 0x01EC, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01ED stack[-1] } 01ED 80 DUP1 01EE 63 PUSH4 0x081812fc 01F3 14 EQ 01F4 61 PUSH2 0x026a 01F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026a, if 0x081812fc == stack[-1] label_01F8: // Incoming jump from 0x018F // Incoming jump from 0x00DB // Incoming jump from 0x01CB // Incoming jump from 0x010C // Incoming jump from 0x015E // Incoming jump from 0x009F // Incoming jump from 0x01F7, if not 0x081812fc == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x006E // Inputs[1] { @01FC memory[0x00:0x00] } 01F8 5B JUMPDEST 01F9 60 PUSH1 0x00 01FB 80 DUP1 01FC FD *REVERT // Stack delta = +0 // Outputs[1] { @01FC revert(memory[0x00:0x00]); } // Block terminates label_01FD: // Incoming jump from 0x01D6, if 0x8ca816 == stack[-1] // Inputs[1] { @01FE msg.value } 01FD 5B JUMPDEST 01FE 34 CALLVALUE 01FF 80 DUP1 0200 15 ISZERO 0201 61 PUSH2 0x0209 0204 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01FE stack[0] = msg.value } // Block ends with conditional jump to 0x0209, if !msg.value label_0205: // Incoming jump from 0x0204, if not !msg.value // Inputs[1] { @0208 memory[0x00:0x00] } 0205 60 PUSH1 0x00 0207 80 DUP1 0208 FD *REVERT // Stack delta = +0 // Outputs[1] { @0208 revert(memory[0x00:0x00]); } // Block terminates label_0209: // Incoming jump from 0x0204, if !msg.value 0209 5B JUMPDEST 020A 50 POP 020B 61 PUSH2 0x0212 020E 61 PUSH2 0x05d5 0211 56 *JUMP // Stack delta = +0 // Outputs[1] { @020B stack[-1] = 0x0212 } // Block ends with call to 0x05d5, returns to 0x0212 label_0212: // Incoming return from call to 0x05B0 at 0x05AF // Incoming return from call to 0x05D5 at 0x0211 // Incoming return from call to 0x0812 at 0x0324 // Inputs[2] // { // @0215 memory[0x40:0x60] // @0219 stack[-1] // } 0212 5B JUMPDEST 0213 60 PUSH1 0x40 0215 51 MLOAD 0216 61 PUSH2 0x021f 0219 91 SWAP2 021A 90 SWAP1 021B 61 PUSH2 0x1f70 021E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0219 stack[-1] = 0x021f // @021A stack[1] = memory[0x40:0x60] // @021A stack[0] = stack[-1] // } // Block ends with call to 0x1f70, returns to 0x021F label_021F: // Incoming return from call to 0x2621 at 0x02EF // Incoming return from call to 0x1F70 at 0x021E // Incoming return from call to 0x1EDB at 0x0296 // Incoming return from call to 0x1F2C at 0x0478 // Inputs[3] // { // @0222 memory[0x40:0x60] // @0224 stack[-1] // @0227 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 021F 5B JUMPDEST 0220 60 PUSH1 0x40 0222 51 MLOAD 0223 80 DUP1 0224 91 SWAP2 0225 03 SUB 0226 90 SWAP1 0227 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0227 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0228: // Incoming jump from 0x01E1, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0229 msg.value } 0228 5B JUMPDEST 0229 34 CALLVALUE 022A 80 DUP1 022B 15 ISZERO 022C 61 PUSH2 0x0234 022F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0229 stack[0] = msg.value } // Block ends with conditional jump to 0x0234, if !msg.value label_0230: // Incoming jump from 0x022F, if not !msg.value // Inputs[1] { @0233 memory[0x00:0x00] } 0230 60 PUSH1 0x00 0232 80 DUP1 0233 FD *REVERT // Stack delta = +0 // Outputs[1] { @0233 revert(memory[0x00:0x00]); } // Block terminates label_0234: // Incoming jump from 0x022F, if !msg.value // Inputs[1] { @023C msg.data.length } 0234 5B JUMPDEST 0235 50 POP 0236 61 PUSH2 0x0212 0239 61 PUSH2 0x0243 023C 36 CALLDATASIZE 023D 60 PUSH1 0x04 023F 61 PUSH2 0x1de7 0242 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0236 stack[-1] = 0x0212 // @0239 stack[0] = 0x0243 // @023C stack[1] = msg.data.length // @023D stack[2] = 0x04 // } // Block ends with call to 0x1de7, returns to 0x0243 label_0243: // Incoming return from call to 0x1DE7 at 0x0242 0243 5B JUMPDEST 0244 61 PUSH2 0x05de 0247 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05de label_0248: // Incoming jump from 0x01EC, if 0x06fdde03 == stack[-1] // Inputs[1] { @0249 msg.value } 0248 5B JUMPDEST 0249 34 CALLVALUE 024A 80 DUP1 024B 15 ISZERO 024C 61 PUSH2 0x0254 024F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0249 stack[0] = msg.value } // Block ends with conditional jump to 0x0254, if !msg.value label_0250: // Incoming jump from 0x024F, if not !msg.value // Inputs[1] { @0253 memory[0x00:0x00] } 0250 60 PUSH1 0x00 0252 80 DUP1 0253 FD *REVERT // Stack delta = +0 // Outputs[1] { @0253 revert(memory[0x00:0x00]); } // Block terminates label_0254: // Incoming jump from 0x024F, if !msg.value 0254 5B JUMPDEST 0255 50 POP 0256 61 PUSH2 0x025d 0259 61 PUSH2 0x060b 025C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0256 stack[-1] = 0x025d } // Block ends with call to 0x060b, returns to 0x025D label_025D: // Incoming return from call to 0x060B at 0x025C // Incoming return from call to 0x0A88 at 0x0438 // Incoming return from call to 0x0DC5 at 0x04B7 // Inputs[2] // { // @0260 memory[0x40:0x60] // @0264 stack[-1] // } 025D 5B JUMPDEST 025E 60 PUSH1 0x40 0260 51 MLOAD 0261 61 PUSH2 0x021f 0264 91 SWAP2 0265 90 SWAP1 0266 61 PUSH2 0x1f7b 0269 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0264 stack[-1] = 0x021f // @0265 stack[1] = memory[0x40:0x60] // @0265 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1f7b label_026A: // Incoming jump from 0x01F7, if 0x081812fc == stack[-1] // Inputs[1] { @026B msg.value } 026A 5B JUMPDEST 026B 34 CALLVALUE 026C 80 DUP1 026D 15 ISZERO 026E 61 PUSH2 0x0276 0271 57 *JUMPI // Stack delta = +1 // Outputs[1] { @026B stack[0] = msg.value } // Block ends with conditional jump to 0x0276, if !msg.value label_0272: // Incoming jump from 0x0271, if not !msg.value // Inputs[1] { @0275 memory[0x00:0x00] } 0272 60 PUSH1 0x00 0274 80 DUP1 0275 FD *REVERT // Stack delta = +0 // Outputs[1] { @0275 revert(memory[0x00:0x00]); } // Block terminates label_0276: // Incoming jump from 0x0271, if !msg.value // Inputs[1] { @027E msg.data.length } 0276 5B JUMPDEST 0277 50 POP 0278 61 PUSH2 0x028a 027B 61 PUSH2 0x0285 027E 36 CALLDATASIZE 027F 60 PUSH1 0x04 0281 61 PUSH2 0x1e65 0284 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0278 stack[-1] = 0x028a // @027B stack[0] = 0x0285 // @027E stack[1] = msg.data.length // @027F stack[2] = 0x04 // } // Block ends with call to 0x1e65, returns to 0x0285 label_0285: // Incoming return from call to 0x1E65 at 0x0284 0285 5B JUMPDEST 0286 61 PUSH2 0x069d 0289 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x069d label_028A: // Incoming return from call to 0x0285 at 0x0284 // Incoming return from call to 0x0DB6 at 0x04A2 // Inputs[2] // { // @028D memory[0x40:0x60] // @0291 stack[-1] // } 028A 5B JUMPDEST 028B 60 PUSH1 0x40 028D 51 MLOAD 028E 61 PUSH2 0x021f 0291 91 SWAP2 0292 90 SWAP1 0293 61 PUSH2 0x1edb 0296 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0291 stack[-1] = 0x021f // @0292 stack[1] = memory[0x40:0x60] // @0292 stack[0] = stack[-1] // } // Block ends with call to 0x1edb, returns to 0x021F label_0297: // Incoming jump from 0x01A6, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0298 msg.value } 0297 5B JUMPDEST 0298 34 CALLVALUE 0299 80 DUP1 029A 15 ISZERO 029B 61 PUSH2 0x02a3 029E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0298 stack[0] = msg.value } // Block ends with conditional jump to 0x02a3, if !msg.value label_029F: // Incoming jump from 0x029E, if not !msg.value // Inputs[1] { @02A2 memory[0x00:0x00] } 029F 60 PUSH1 0x00 02A1 80 DUP1 02A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A2 revert(memory[0x00:0x00]); } // Block terminates label_02A3: // Incoming jump from 0x029E, if !msg.value // Inputs[1] { @02AB msg.data.length } 02A3 5B JUMPDEST 02A4 50 POP 02A5 61 PUSH2 0x02b7 02A8 61 PUSH2 0x02b2 02AB 36 CALLDATASIZE 02AC 60 PUSH1 0x04 02AE 61 PUSH2 0x1dbe 02B1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02A5 stack[-1] = 0x02b7 // @02A8 stack[0] = 0x02b2 // @02AB stack[1] = msg.data.length // @02AC stack[2] = 0x04 // } // Block ends with call to 0x1dbe, returns to 0x02B2 label_02B2: // Incoming return from call to 0x1DBE at 0x02B1 02B2 5B JUMPDEST 02B3 61 PUSH2 0x06e9 02B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06e9 label_02B7: // Incoming return from call to 0x0878 at 0x036E // Incoming return from call to 0x0781 at 0x02CD // Incoming return from call to 0x0D5A at 0x048D // Incoming return from call to 0x0F97 at 0x0534 // Incoming return from call to 0x04E6 at 0x04E5 02B7 5B JUMPDEST 02B8 00 *STOP // Stack delta = +0 // Outputs[1] { @02B8 stop(); } // Block terminates label_02B9: // Incoming jump from 0x01B1, if 0x0c5a78d9 == stack[-1] // Inputs[1] { @02BA msg.value } 02B9 5B JUMPDEST 02BA 34 CALLVALUE 02BB 80 DUP1 02BC 15 ISZERO 02BD 61 PUSH2 0x02c5 02C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02BA stack[0] = msg.value } // Block ends with conditional jump to 0x02c5, if !msg.value label_02C1: // Incoming jump from 0x02C0, if not !msg.value // Inputs[1] { @02C4 memory[0x00:0x00] } 02C1 60 PUSH1 0x00 02C3 80 DUP1 02C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C4 revert(memory[0x00:0x00]); } // Block terminates label_02C5: // Incoming jump from 0x02C0, if !msg.value 02C5 5B JUMPDEST 02C6 50 POP 02C7 61 PUSH2 0x02b7 02CA 61 PUSH2 0x0781 02CD 56 *JUMP // Stack delta = +0 // Outputs[1] { @02C7 stack[-1] = 0x02b7 } // Block ends with call to 0x0781, returns to 0x02B7 label_02CE: // Incoming jump from 0x01BC, if 0x18160ddd == stack[-1] // Inputs[1] { @02CF msg.value } 02CE 5B JUMPDEST 02CF 34 CALLVALUE 02D0 80 DUP1 02D1 15 ISZERO 02D2 61 PUSH2 0x02da 02D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CF stack[0] = msg.value } // Block ends with conditional jump to 0x02da, if !msg.value label_02D6: // Incoming jump from 0x02D5, if not !msg.value // Inputs[1] { @02D9 memory[0x00:0x00] } 02D6 60 PUSH1 0x00 02D8 80 DUP1 02D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D9 revert(memory[0x00:0x00]); } // Block terminates label_02DA: // Incoming jump from 0x02D5, if !msg.value 02DA 5B JUMPDEST 02DB 50 POP 02DC 61 PUSH2 0x02e3 02DF 61 PUSH2 0x07d4 02E2 56 *JUMP // Stack delta = +0 // Outputs[1] { @02DC stack[-1] = 0x02e3 } // Block ends with call to 0x07d4, returns to 0x02E3 label_02E3: // Incoming return from call to 0x03AA at 0x03A9 // Incoming return from call to 0x0A3E at 0x0403 // Incoming return from call to 0x041F at 0x041E // Incoming return from call to 0x0872 at 0x0359 // Incoming return from call to 0x0F91 at 0x051F // Incoming return from call to 0x07D4 at 0x02E2 // Incoming return from call to 0x0340 at 0x033F // Incoming return from call to 0x0506 at 0x0505 // Inputs[2] // { // @02E6 memory[0x40:0x60] // @02EA stack[-1] // } 02E3 5B JUMPDEST 02E4 60 PUSH1 0x40 02E6 51 MLOAD 02E7 61 PUSH2 0x021f 02EA 91 SWAP2 02EB 90 SWAP1 02EC 61 PUSH2 0x2621 02EF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02EA stack[-1] = 0x021f // @02EB stack[1] = memory[0x40:0x60] // @02EB stack[0] = stack[-1] // } // Block ends with call to 0x2621, returns to 0x021F label_02F0: // Incoming jump from 0x01C7, if 0x23b872dd == stack[-1] // Inputs[1] { @02F1 msg.value } 02F0 5B JUMPDEST 02F1 34 CALLVALUE 02F2 80 DUP1 02F3 15 ISZERO 02F4 61 PUSH2 0x02fc 02F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F1 stack[0] = msg.value } // Block ends with conditional jump to 0x02fc, if !msg.value label_02F8: // Incoming jump from 0x02F7, if not !msg.value // Inputs[1] { @02FB memory[0x00:0x00] } 02F8 60 PUSH1 0x00 02FA 80 DUP1 02FB FD *REVERT // Stack delta = +0 // Outputs[1] { @02FB revert(memory[0x00:0x00]); } // Block terminates label_02FC: // Incoming jump from 0x02F7, if !msg.value // Inputs[1] { @0304 msg.data.length } 02FC 5B JUMPDEST 02FD 50 POP 02FE 61 PUSH2 0x02b7 0301 61 PUSH2 0x030b 0304 36 CALLDATASIZE 0305 60 PUSH1 0x04 0307 61 PUSH2 0x1cd0 030A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02FE stack[-1] = 0x02b7 // @0301 stack[0] = 0x030b // @0304 stack[1] = msg.data.length // @0305 stack[2] = 0x04 // } // Block ends with call to 0x1cd0, returns to 0x030B label_030B: // Incoming return from call to 0x1CD0 at 0x030A 030B 5B JUMPDEST 030C 61 PUSH2 0x07da 030F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07da label_0310: // Incoming jump from 0x016A, if 0x2e280e32 == stack[-1] // Inputs[1] { @0311 msg.value } 0310 5B JUMPDEST 0311 34 CALLVALUE 0312 80 DUP1 0313 15 ISZERO 0314 61 PUSH2 0x031c 0317 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0311 stack[0] = msg.value } // Block ends with conditional jump to 0x031c, if !msg.value label_0318: // Incoming jump from 0x0317, if not !msg.value // Inputs[1] { @031B memory[0x00:0x00] } 0318 60 PUSH1 0x00 031A 80 DUP1 031B FD *REVERT // Stack delta = +0 // Outputs[1] { @031B revert(memory[0x00:0x00]); } // Block terminates label_031C: // Incoming jump from 0x0317, if !msg.value 031C 5B JUMPDEST 031D 50 POP 031E 61 PUSH2 0x0212 0321 61 PUSH2 0x0812 0324 56 *JUMP // Stack delta = +0 // Outputs[1] { @031E stack[-1] = 0x0212 } // Block ends with call to 0x0812, returns to 0x0212 label_0325: // Incoming jump from 0x0175, if 0x2f745c59 == stack[-1] // Inputs[1] { @0326 msg.value } 0325 5B JUMPDEST 0326 34 CALLVALUE 0327 80 DUP1 0328 15 ISZERO 0329 61 PUSH2 0x0331 032C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0326 stack[0] = msg.value } // Block ends with conditional jump to 0x0331, if !msg.value label_032D: // Incoming jump from 0x032C, if not !msg.value // Inputs[1] { @0330 memory[0x00:0x00] } 032D 60 PUSH1 0x00 032F 80 DUP1 0330 FD *REVERT // Stack delta = +0 // Outputs[1] { @0330 revert(memory[0x00:0x00]); } // Block terminates label_0331: // Incoming jump from 0x032C, if !msg.value // Inputs[1] { @0339 msg.data.length } 0331 5B JUMPDEST 0332 50 POP 0333 61 PUSH2 0x02e3 0336 61 PUSH2 0x0340 0339 36 CALLDATASIZE 033A 60 PUSH1 0x04 033C 61 PUSH2 0x1dbe 033F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0333 stack[-1] = 0x02e3 // @0336 stack[0] = 0x0340 // @0339 stack[1] = msg.data.length // @033A stack[2] = 0x04 // } // Block ends with call to 0x1dbe, returns to 0x0340 label_0340: // Incoming return from call to 0x1DBE at 0x033F 0340 5B JUMPDEST 0341 61 PUSH2 0x0820 0344 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0820 label_0345: // Incoming jump from 0x0180, if 0x32cb6b0c == stack[-1] // Inputs[1] { @0346 msg.value } 0345 5B JUMPDEST 0346 34 CALLVALUE 0347 80 DUP1 0348 15 ISZERO 0349 61 PUSH2 0x0351 034C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0346 stack[0] = msg.value } // Block ends with conditional jump to 0x0351, if !msg.value label_034D: // Incoming jump from 0x034C, if not !msg.value // Inputs[1] { @0350 memory[0x00:0x00] } 034D 60 PUSH1 0x00 034F 80 DUP1 0350 FD *REVERT // Stack delta = +0 // Outputs[1] { @0350 revert(memory[0x00:0x00]); } // Block terminates label_0351: // Incoming jump from 0x034C, if !msg.value 0351 5B JUMPDEST 0352 50 POP 0353 61 PUSH2 0x02e3 0356 61 PUSH2 0x0872 0359 56 *JUMP // Stack delta = +0 // Outputs[1] { @0353 stack[-1] = 0x02e3 } // Block ends with call to 0x0872, returns to 0x02E3 label_035A: // Incoming jump from 0x018B, if 0x3ccfd60b == stack[-1] // Inputs[1] { @035B msg.value } 035A 5B JUMPDEST 035B 34 CALLVALUE 035C 80 DUP1 035D 15 ISZERO 035E 61 PUSH2 0x0366 0361 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035B stack[0] = msg.value } // Block ends with conditional jump to 0x0366, if !msg.value label_0362: // Incoming jump from 0x0361, if not !msg.value // Inputs[1] { @0365 memory[0x00:0x00] } 0362 60 PUSH1 0x00 0364 80 DUP1 0365 FD *REVERT // Stack delta = +0 // Outputs[1] { @0365 revert(memory[0x00:0x00]); } // Block terminates label_0366: // Incoming jump from 0x0361, if !msg.value 0366 5B JUMPDEST 0367 50 POP 0368 61 PUSH2 0x02b7 036B 61 PUSH2 0x0878 036E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0368 stack[-1] = 0x02b7 } // Block ends with call to 0x0878, returns to 0x02B7 label_036F: // Incoming jump from 0x012E, if 0x42842e0e == stack[-1] // Inputs[1] { @0370 msg.value } 036F 5B JUMPDEST 0370 34 CALLVALUE 0371 80 DUP1 0372 15 ISZERO 0373 61 PUSH2 0x037b 0376 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0370 stack[0] = msg.value } // Block ends with conditional jump to 0x037b, if !msg.value label_0377: // Incoming jump from 0x0376, if not !msg.value // Inputs[1] { @037A memory[0x00:0x00] } 0377 60 PUSH1 0x00 0379 80 DUP1 037A FD *REVERT // Stack delta = +0 // Outputs[1] { @037A revert(memory[0x00:0x00]); } // Block terminates label_037B: // Incoming jump from 0x0376, if !msg.value // Inputs[1] { @0383 msg.data.length } 037B 5B JUMPDEST 037C 50 POP 037D 61 PUSH2 0x02b7 0380 61 PUSH2 0x038a 0383 36 CALLDATASIZE 0384 60 PUSH1 0x04 0386 61 PUSH2 0x1cd0 0389 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @037D stack[-1] = 0x02b7 // @0380 stack[0] = 0x038a // @0383 stack[1] = msg.data.length // @0384 stack[2] = 0x04 // } // Block ends with call to 0x1cd0, returns to 0x038A label_038A: // Incoming return from call to 0x1CD0 at 0x0389 038A 5B JUMPDEST 038B 61 PUSH2 0x093d 038E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x093d label_038F: // Incoming jump from 0x0139, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @0390 msg.value } 038F 5B JUMPDEST 0390 34 CALLVALUE 0391 80 DUP1 0392 15 ISZERO 0393 61 PUSH2 0x039b 0396 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0390 stack[0] = msg.value } // Block ends with conditional jump to 0x039b, if !msg.value label_0397: // Incoming jump from 0x0396, if not !msg.value // Inputs[1] { @039A memory[0x00:0x00] } 0397 60 PUSH1 0x00 0399 80 DUP1 039A FD *REVERT // Stack delta = +0 // Outputs[1] { @039A revert(memory[0x00:0x00]); } // Block terminates label_039B: // Incoming jump from 0x0396, if !msg.value // Inputs[1] { @03A3 msg.data.length } 039B 5B JUMPDEST 039C 50 POP 039D 61 PUSH2 0x02e3 03A0 61 PUSH2 0x03aa 03A3 36 CALLDATASIZE 03A4 60 PUSH1 0x04 03A6 61 PUSH2 0x1e65 03A9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @039D stack[-1] = 0x02e3 // @03A0 stack[0] = 0x03aa // @03A3 stack[1] = msg.data.length // @03A4 stack[2] = 0x04 // } // Block ends with call to 0x1e65, returns to 0x03AA label_03AA: // Incoming return from call to 0x1E65 at 0x03A9 03AA 5B JUMPDEST 03AB 61 PUSH2 0x0958 03AE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0958 label_03AF: // Incoming jump from 0x0144, if 0x55f804b3 == stack[-1] // Inputs[1] { @03B0 msg.value } 03AF 5B JUMPDEST 03B0 34 CALLVALUE 03B1 80 DUP1 03B2 15 ISZERO 03B3 61 PUSH2 0x03bb 03B6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B0 stack[0] = msg.value } // Block ends with conditional jump to 0x03bb, if !msg.value label_03B7: // Incoming jump from 0x03B6, if not !msg.value // Inputs[1] { @03BA memory[0x00:0x00] } 03B7 60 PUSH1 0x00 03B9 80 DUP1 03BA FD *REVERT // Stack delta = +0 // Outputs[1] { @03BA revert(memory[0x00:0x00]); } // Block terminates label_03BB: // Incoming jump from 0x03B6, if !msg.value // Inputs[1] { @03C3 msg.data.length } 03BB 5B JUMPDEST 03BC 50 POP 03BD 61 PUSH2 0x02b7 03C0 61 PUSH2 0x03ca 03C3 36 CALLDATASIZE 03C4 60 PUSH1 0x04 03C6 61 PUSH2 0x1e1f 03C9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03BD stack[-1] = 0x02b7 // @03C0 stack[0] = 0x03ca // @03C3 stack[1] = msg.data.length // @03C4 stack[2] = 0x04 // } // Block ends with call to 0x1e1f, returns to 0x03CA label_03CA: // Incoming return from call to 0x1E1F at 0x03C9 03CA 5B JUMPDEST 03CB 61 PUSH2 0x09b3 03CE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09b3 label_03CF: // Incoming jump from 0x014F, if 0x6352211e == stack[-1] // Inputs[1] { @03D0 msg.value } 03CF 5B JUMPDEST 03D0 34 CALLVALUE 03D1 80 DUP1 03D2 15 ISZERO 03D3 61 PUSH2 0x03db 03D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D0 stack[0] = msg.value } // Block ends with conditional jump to 0x03db, if !msg.value label_03D7: // Incoming jump from 0x03D6, if not !msg.value // Inputs[1] { @03DA memory[0x00:0x00] } 03D7 60 PUSH1 0x00 03D9 80 DUP1 03DA FD *REVERT // Stack delta = +0 // Outputs[1] { @03DA revert(memory[0x00:0x00]); } // Block terminates label_03DB: // Incoming jump from 0x03D6, if !msg.value // Inputs[1] { @03E3 msg.data.length } 03DB 5B JUMPDEST 03DC 50 POP 03DD 61 PUSH2 0x028a 03E0 61 PUSH2 0x03ea 03E3 36 CALLDATASIZE 03E4 60 PUSH1 0x04 03E6 61 PUSH2 0x1e65 03E9 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03DD stack[-1] = 0x028a // @03E0 stack[0] = 0x03ea // @03E3 stack[1] = msg.data.length // @03E4 stack[2] = 0x04 // } // Block ends with call to 0x1e65, returns to 0x03EA label_03EA: // Incoming return from call to 0x1E65 at 0x03E9 03EA 5B JUMPDEST 03EB 61 PUSH2 0x0a09 03EE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a09 label_03EF: // Incoming jump from 0x015A, if 0x6b8dc355 == stack[-1] // Inputs[1] { @03F0 msg.value } 03EF 5B JUMPDEST 03F0 34 CALLVALUE 03F1 80 DUP1 03F2 15 ISZERO 03F3 61 PUSH2 0x03fb 03F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F0 stack[0] = msg.value } // Block ends with conditional jump to 0x03fb, if !msg.value label_03F7: // Incoming jump from 0x03F6, if not !msg.value // Inputs[1] { @03FA memory[0x00:0x00] } 03F7 60 PUSH1 0x00 03F9 80 DUP1 03FA FD *REVERT // Stack delta = +0 // Outputs[1] { @03FA revert(memory[0x00:0x00]); } // Block terminates label_03FB: // Incoming jump from 0x03F6, if !msg.value 03FB 5B JUMPDEST 03FC 50 POP 03FD 61 PUSH2 0x02e3 0400 61 PUSH2 0x0a3e 0403 56 *JUMP // Stack delta = +0 // Outputs[1] { @03FD stack[-1] = 0x02e3 } // Block ends with call to 0x0a3e, returns to 0x02E3 label_0404: // Incoming jump from 0x00E7, if 0x70a08231 == stack[-1] // Inputs[1] { @0405 msg.value } 0404 5B JUMPDEST 0405 34 CALLVALUE 0406 80 DUP1 0407 15 ISZERO 0408 61 PUSH2 0x0410 040B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0405 stack[0] = msg.value } // Block ends with conditional jump to 0x0410, if !msg.value label_040C: // Incoming jump from 0x040B, if not !msg.value // Inputs[1] { @040F memory[0x00:0x00] } 040C 60 PUSH1 0x00 040E 80 DUP1 040F FD *REVERT // Stack delta = +0 // Outputs[1] { @040F revert(memory[0x00:0x00]); } // Block terminates label_0410: // Incoming jump from 0x040B, if !msg.value // Inputs[1] { @0418 msg.data.length } 0410 5B JUMPDEST 0411 50 POP 0412 61 PUSH2 0x02e3 0415 61 PUSH2 0x041f 0418 36 CALLDATASIZE 0419 60 PUSH1 0x04 041B 61 PUSH2 0x1c84 041E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0412 stack[-1] = 0x02e3 // @0415 stack[0] = 0x041f // @0418 stack[1] = msg.data.length // @0419 stack[2] = 0x04 // } // Block ends with call to 0x1c84, returns to 0x041F label_041F: // Incoming return from call to 0x1C84 at 0x041E 041F 5B JUMPDEST 0420 61 PUSH2 0x0a44 0423 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a44 label_0424: // Incoming jump from 0x00F2, if 0x743976a0 == stack[-1] // Inputs[1] { @0425 msg.value } 0424 5B JUMPDEST 0425 34 CALLVALUE 0426 80 DUP1 0427 15 ISZERO 0428 61 PUSH2 0x0430 042B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0425 stack[0] = msg.value } // Block ends with conditional jump to 0x0430, if !msg.value label_042C: // Incoming jump from 0x042B, if not !msg.value // Inputs[1] { @042F memory[0x00:0x00] } 042C 60 PUSH1 0x00 042E 80 DUP1 042F FD *REVERT // Stack delta = +0 // Outputs[1] { @042F revert(memory[0x00:0x00]); } // Block terminates label_0430: // Incoming jump from 0x042B, if !msg.value 0430 5B JUMPDEST 0431 50 POP 0432 61 PUSH2 0x025d 0435 61 PUSH2 0x0a88 0438 56 *JUMP // Stack delta = +0 // Outputs[1] { @0432 stack[-1] = 0x025d } // Block ends with call to 0x0a88, returns to 0x025D label_0439: // Incoming jump from 0x00FD, if 0x7835c635 == stack[-1] // Inputs[1] { @0440 msg.data.length } 0439 5B JUMPDEST 043A 61 PUSH2 0x02b7 043D 61 PUSH2 0x0447 0440 36 CALLDATASIZE 0441 60 PUSH1 0x04 0443 61 PUSH2 0x1e65 0446 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @043A stack[0] = 0x02b7 // @043D stack[1] = 0x0447 // @0440 stack[2] = msg.data.length // @0441 stack[3] = 0x04 // } // Block ends with call to 0x1e65, returns to 0x0447 label_0447: // Incoming return from call to 0x1E65 at 0x0446 0447 5B JUMPDEST 0448 61 PUSH2 0x0b16 044B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b16 label_044C: // Incoming jump from 0x0108, if 0x8462151c == stack[-1] // Inputs[1] { @044D msg.value } 044C 5B JUMPDEST 044D 34 CALLVALUE 044E 80 DUP1 044F 15 ISZERO 0450 61 PUSH2 0x0458 0453 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044D stack[0] = msg.value } // Block ends with conditional jump to 0x0458, if !msg.value label_0454: // Incoming jump from 0x0453, if not !msg.value // Inputs[1] { @0457 memory[0x00:0x00] } 0454 60 PUSH1 0x00 0456 80 DUP1 0457 FD *REVERT // Stack delta = +0 // Outputs[1] { @0457 revert(memory[0x00:0x00]); } // Block terminates label_0458: // Incoming jump from 0x0453, if !msg.value // Inputs[1] { @0460 msg.data.length } 0458 5B JUMPDEST 0459 50 POP 045A 61 PUSH2 0x046c 045D 61 PUSH2 0x0467 0460 36 CALLDATASIZE 0461 60 PUSH1 0x04 0463 61 PUSH2 0x1c84 0466 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @045A stack[-1] = 0x046c // @045D stack[0] = 0x0467 // @0460 stack[1] = msg.data.length // @0461 stack[2] = 0x04 // } // Block ends with call to 0x1c84, returns to 0x0467 label_0467: // Incoming return from call to 0x1C84 at 0x0466 0467 5B JUMPDEST 0468 61 PUSH2 0x0c9c 046B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c9c label_046C: // Incoming return from call to 0x0467 at 0x0466 // Inputs[2] // { // @046F memory[0x40:0x60] // @0473 stack[-1] // } 046C 5B JUMPDEST 046D 60 PUSH1 0x40 046F 51 MLOAD 0470 61 PUSH2 0x021f 0473 91 SWAP2 0474 90 SWAP1 0475 61 PUSH2 0x1f2c 0478 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0473 stack[-1] = 0x021f // @0474 stack[1] = memory[0x40:0x60] // @0474 stack[0] = stack[-1] // } // Block ends with call to 0x1f2c, returns to 0x021F label_0479: // Incoming jump from 0x00B6, if 0x8b78e8f7 == stack[-1] // Inputs[1] { @047A msg.value } 0479 5B JUMPDEST 047A 34 CALLVALUE 047B 80 DUP1 047C 15 ISZERO 047D 61 PUSH2 0x0485 0480 57 *JUMPI // Stack delta = +1 // Outputs[1] { @047A stack[0] = msg.value } // Block ends with conditional jump to 0x0485, if !msg.value label_0481: // Incoming jump from 0x0480, if not !msg.value // Inputs[1] { @0484 memory[0x00:0x00] } 0481 60 PUSH1 0x00 0483 80 DUP1 0484 FD *REVERT // Stack delta = +0 // Outputs[1] { @0484 revert(memory[0x00:0x00]); } // Block terminates label_0485: // Incoming jump from 0x0480, if !msg.value 0485 5B JUMPDEST 0486 50 POP 0487 61 PUSH2 0x02b7 048A 61 PUSH2 0x0d5a 048D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0487 stack[-1] = 0x02b7 } // Block ends with call to 0x0d5a, returns to 0x02B7 label_048E: // Incoming jump from 0x00C1, if 0x8da5cb5b == stack[-1] // Inputs[1] { @048F msg.value } 048E 5B JUMPDEST 048F 34 CALLVALUE 0490 80 DUP1 0491 15 ISZERO 0492 61 PUSH2 0x049a 0495 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048F stack[0] = msg.value } // Block ends with conditional jump to 0x049a, if !msg.value label_0496: // Incoming jump from 0x0495, if not !msg.value // Inputs[1] { @0499 memory[0x00:0x00] } 0496 60 PUSH1 0x00 0498 80 DUP1 0499 FD *REVERT // Stack delta = +0 // Outputs[1] { @0499 revert(memory[0x00:0x00]); } // Block terminates label_049A: // Incoming jump from 0x0495, if !msg.value 049A 5B JUMPDEST 049B 50 POP 049C 61 PUSH2 0x028a 049F 61 PUSH2 0x0db6 04A2 56 *JUMP // Stack delta = +0 // Outputs[1] { @049C stack[-1] = 0x028a } // Block ends with call to 0x0db6, returns to 0x028A label_04A3: // Incoming jump from 0x00CC, if 0x95d89b41 == stack[-1] // Inputs[1] { @04A4 msg.value } 04A3 5B JUMPDEST 04A4 34 CALLVALUE 04A5 80 DUP1 04A6 15 ISZERO 04A7 61 PUSH2 0x04af 04AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A4 stack[0] = msg.value } // Block ends with conditional jump to 0x04af, if !msg.value label_04AB: // Incoming jump from 0x04AA, if not !msg.value // Inputs[1] { @04AE memory[0x00:0x00] } 04AB 60 PUSH1 0x00 04AD 80 DUP1 04AE FD *REVERT // Stack delta = +0 // Outputs[1] { @04AE revert(memory[0x00:0x00]); } // Block terminates label_04AF: // Incoming jump from 0x04AA, if !msg.value 04AF 5B JUMPDEST 04B0 50 POP 04B1 61 PUSH2 0x025d 04B4 61 PUSH2 0x0dc5 04B7 56 *JUMP // Stack delta = +0 // Outputs[1] { @04B1 stack[-1] = 0x025d } // Block ends with call to 0x0dc5, returns to 0x025D label_04B8: // Incoming jump from 0x00D7, if 0xa0712d68 == stack[-1] // Inputs[1] { @04BF msg.data.length } 04B8 5B JUMPDEST 04B9 61 PUSH2 0x02b7 04BC 61 PUSH2 0x04c6 04BF 36 CALLDATASIZE 04C0 60 PUSH1 0x04 04C2 61 PUSH2 0x1e65 04C5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04B9 stack[0] = 0x02b7 // @04BC stack[1] = 0x04c6 // @04BF stack[2] = msg.data.length // @04C0 stack[3] = 0x04 // } // Block ends with call to 0x1e65, returns to 0x04C6 label_04C6: // Incoming return from call to 0x1E65 at 0x04C5 04C6 5B JUMPDEST 04C7 61 PUSH2 0x0dd4 04CA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dd4 label_04CB: // Incoming jump from 0x007A, if 0xa22cb465 == stack[-1] // Inputs[1] { @04CC msg.value } 04CB 5B JUMPDEST 04CC 34 CALLVALUE 04CD 80 DUP1 04CE 15 ISZERO 04CF 61 PUSH2 0x04d7 04D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CC stack[0] = msg.value } // Block ends with conditional jump to 0x04d7, if !msg.value label_04D3: // Incoming jump from 0x04D2, if not !msg.value // Inputs[1] { @04D6 memory[0x00:0x00] } 04D3 60 PUSH1 0x00 04D5 80 DUP1 04D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D6 revert(memory[0x00:0x00]); } // Block terminates label_04D7: // Incoming jump from 0x04D2, if !msg.value // Inputs[1] { @04DF msg.data.length } 04D7 5B JUMPDEST 04D8 50 POP 04D9 61 PUSH2 0x02b7 04DC 61 PUSH2 0x04e6 04DF 36 CALLDATASIZE 04E0 60 PUSH1 0x04 04E2 61 PUSH2 0x1d84 04E5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04D9 stack[-1] = 0x02b7 // @04DC stack[0] = 0x04e6 // @04DF stack[1] = msg.data.length // @04E0 stack[2] = 0x04 // } // Block ends with call to 0x1d84, returns to 0x04E6 label_04E6: // Incoming return from call to 0x1D84 at 0x04E5 04E6 5B JUMPDEST 04E7 61 PUSH2 0x0eb1 04EA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eb1 label_04EB: // Incoming jump from 0x0085, if 0xa4fe0ecc == stack[-1] // Inputs[1] { @04EC msg.value } 04EB 5B JUMPDEST 04EC 34 CALLVALUE 04ED 80 DUP1 04EE 15 ISZERO 04EF 61 PUSH2 0x04f7 04F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04EC stack[0] = msg.value } // Block ends with conditional jump to 0x04f7, if !msg.value label_04F3: // Incoming jump from 0x04F2, if not !msg.value // Inputs[1] { @04F6 memory[0x00:0x00] } 04F3 60 PUSH1 0x00 04F5 80 DUP1 04F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F6 revert(memory[0x00:0x00]); } // Block terminates label_04F7: // Incoming jump from 0x04F2, if !msg.value // Inputs[1] { @04FF msg.data.length } 04F7 5B JUMPDEST 04F8 50 POP 04F9 61 PUSH2 0x02e3 04FC 61 PUSH2 0x0506 04FF 36 CALLDATASIZE 0500 60 PUSH1 0x04 0502 61 PUSH2 0x1c84 0505 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F9 stack[-1] = 0x02e3 // @04FC stack[0] = 0x0506 // @04FF stack[1] = msg.data.length // @0500 stack[2] = 0x04 // } // Block ends with call to 0x1c84, returns to 0x0506 label_0506: // Incoming return from call to 0x1C84 at 0x0505 0506 5B JUMPDEST 0507 61 PUSH2 0x0f7f 050A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f7f label_050B: // Incoming jump from 0x0090, if 0xaa66797b == stack[-1] // Inputs[1] { @050C msg.value } 050B 5B JUMPDEST 050C 34 CALLVALUE 050D 80 DUP1 050E 15 ISZERO 050F 61 PUSH2 0x0517 0512 57 *JUMPI // Stack delta = +1 // Outputs[1] { @050C stack[0] = msg.value } // Block ends with conditional jump to 0x0517, if !msg.value label_0513: // Incoming jump from 0x0512, if not !msg.value // Inputs[1] { @0516 memory[0x00:0x00] } 0513 60 PUSH1 0x00 0515 80 DUP1 0516 FD *REVERT // Stack delta = +0 // Outputs[1] { @0516 revert(memory[0x00:0x00]); } // Block terminates label_0517: // Incoming jump from 0x0512, if !msg.value 0517 5B JUMPDEST 0518 50 POP 0519 61 PUSH2 0x02e3 051C 61 PUSH2 0x0f91 051F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0519 stack[-1] = 0x02e3 } // Block ends with call to 0x0f91, returns to 0x02E3 label_0520: // Incoming jump from 0x009B, if 0xb66a0e5d == stack[-1] // Inputs[1] { @0521 msg.value } 0520 5B JUMPDEST 0521 34 CALLVALUE 0522 80 DUP1 0523 15 ISZERO 0524 61 PUSH2 0x052c 0527 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0521 stack[0] = msg.value } // Block ends with conditional jump to 0x052c, if !msg.value label_0528: // Incoming jump from 0x0527, if not !msg.value // Inputs[1] { @052B memory[0x00:0x00] } 0528 60 PUSH1 0x00 052A 80 DUP1 052B FD *REVERT // Stack delta = +0 // Outputs[1] { @052B revert(memory[0x00:0x00]); } // Block terminates label_052C: // Incoming jump from 0x0527, if !msg.value 052C 5B JUMPDEST 052D 50 POP 052E 61 PUSH2 0x02b7 0531 61 PUSH2 0x0f97 0534 56 *JUMP // Stack delta = +0 // Outputs[1] { @052E stack[-1] = 0x02b7 } // Block ends with call to 0x0f97, returns to 0x02B7 label_0535: // Incoming jump from 0x003E, if 0xb88d4fde == stack[-1] // Inputs[1] { @0536 msg.value } 0535 5B JUMPDEST 0536 34 CALLVALUE 0537 80 DUP1 0538 15 ISZERO 0539 61 PUSH2 0x0541 053C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0536 stack[0] = msg.value } // Block ends with conditional jump to 0x0541, if !msg.value label_053D: // Incoming jump from 0x053C, if not !msg.value // Inputs[1] { @0540 memory[0x00:0x00] } 053D 60 PUSH1 0x00 053F 80 DUP1 0540 FD *REVERT // Stack delta = +0 // Outputs[1] { @0540 revert(memory[0x00:0x00]); } // Block terminates label_0541: // Incoming jump from 0x053C, if !msg.value // Inputs[1] { @0549 msg.data.length } 0541 5B JUMPDEST 0542 50 POP 0543 61 PUSH2 0x02b7 0546 61 PUSH2 0x0550 0549 36 CALLDATASIZE 054A 60 PUSH1 0x04 054C 61 PUSH2 0x1d0b 054F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0543 stack[-1] = 0x02b7 // @0546 stack[0] = 0x0550 // @0549 stack[1] = msg.data.length // @054A stack[2] = 0x04 // } // Block ends with call to 0x1d0b, returns to 0x0550 label_0550: // Incoming return from call to 0x1D0B at 0x054F 0550 5B JUMPDEST 0551 61 PUSH2 0x0fed 0554 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fed label_0555: // Incoming jump from 0x0049, if 0xc87b56dd == stack[-1] // Inputs[1] { @0556 msg.value } 0555 5B JUMPDEST 0556 34 CALLVALUE 0557 80 DUP1 0558 15 ISZERO 0559 61 PUSH2 0x0561 055C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0556 stack[0] = msg.value } // Block ends with conditional jump to 0x0561, if !msg.value label_055D: // Incoming jump from 0x055C, if not !msg.value // Inputs[1] { @0560 memory[0x00:0x00] } 055D 60 PUSH1 0x00 055F 80 DUP1 0560 FD *REVERT // Stack delta = +0 // Outputs[1] { @0560 revert(memory[0x00:0x00]); } // Block terminates label_0561: // Incoming jump from 0x055C, if !msg.value // Inputs[1] { @0569 msg.data.length } 0561 5B JUMPDEST 0562 50 POP 0563 61 PUSH2 0x025d 0566 61 PUSH2 0x0570 0569 36 CALLDATASIZE 056A 60 PUSH1 0x04 056C 61 PUSH2 0x1e65 056F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0563 stack[-1] = 0x025d // @0566 stack[0] = 0x0570 // @0569 stack[1] = msg.data.length // @056A stack[2] = 0x04 // } // Block ends with call to 0x1e65, returns to 0x0570 label_0570: // Incoming return from call to 0x1E65 at 0x056F 0570 5B JUMPDEST 0571 61 PUSH2 0x102c 0574 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x102c label_0575: // Incoming jump from 0x0054, if 0xd031370b == stack[-1] // Inputs[1] { @0576 msg.value } 0575 5B JUMPDEST 0576 34 CALLVALUE 0577 80 DUP1 0578 15 ISZERO 0579 61 PUSH2 0x0581 057C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0576 stack[0] = msg.value } // Block ends with conditional jump to 0x0581, if !msg.value label_057D: // Incoming jump from 0x057C, if not !msg.value // Inputs[1] { @0580 memory[0x00:0x00] } 057D 60 PUSH1 0x00 057F 80 DUP1 0580 FD *REVERT // Stack delta = +0 // Outputs[1] { @0580 revert(memory[0x00:0x00]); } // Block terminates label_0581: // Incoming jump from 0x057C, if !msg.value // Inputs[1] { @0589 msg.data.length } 0581 5B JUMPDEST 0582 50 POP 0583 61 PUSH2 0x02b7 0586 61 PUSH2 0x0590 0589 36 CALLDATASIZE 058A 60 PUSH1 0x04 058C 61 PUSH2 0x1e65 058F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0583 stack[-1] = 0x02b7 // @0586 stack[0] = 0x0590 // @0589 stack[1] = msg.data.length // @058A stack[2] = 0x04 // } // Block ends with call to 0x1e65, returns to 0x0590 label_0590: // Incoming return from call to 0x1E65 at 0x058F 0590 5B JUMPDEST 0591 61 PUSH2 0x10af 0594 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10af label_0595: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0596 msg.value } 0595 5B JUMPDEST 0596 34 CALLVALUE 0597 80 DUP1 0598 15 ISZERO 0599 61 PUSH2 0x05a1 059C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0596 stack[0] = msg.value } // Block ends with conditional jump to 0x05a1, if !msg.value label_059D: // Incoming jump from 0x059C, if not !msg.value // Inputs[1] { @05A0 memory[0x00:0x00] } 059D 60 PUSH1 0x00 059F 80 DUP1 05A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A0 revert(memory[0x00:0x00]); } // Block terminates label_05A1: // Incoming jump from 0x059C, if !msg.value // Inputs[1] { @05A9 msg.data.length } 05A1 5B JUMPDEST 05A2 50 POP 05A3 61 PUSH2 0x0212 05A6 61 PUSH2 0x05b0 05A9 36 CALLDATASIZE 05AA 60 PUSH1 0x04 05AC 61 PUSH2 0x1c9e 05AF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05A3 stack[-1] = 0x0212 // @05A6 stack[0] = 0x05b0 // @05A9 stack[1] = msg.data.length // @05AA stack[2] = 0x04 // } // Block ends with call to 0x1c9e, returns to 0x05B0 label_05B0: // Incoming return from call to 0x1C9E at 0x05AF 05B0 5B JUMPDEST 05B1 61 PUSH2 0x1193 05B4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1193 label_05B5: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @05B6 msg.value } 05B5 5B JUMPDEST 05B6 34 CALLVALUE 05B7 80 DUP1 05B8 15 ISZERO 05B9 61 PUSH2 0x05c1 05BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B6 stack[0] = msg.value } // Block ends with conditional jump to 0x05c1, if !msg.value label_05BD: // Incoming jump from 0x05BC, if not !msg.value // Inputs[1] { @05C0 memory[0x00:0x00] } 05BD 60 PUSH1 0x00 05BF 80 DUP1 05C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C0 revert(memory[0x00:0x00]); } // Block terminates label_05C1: // Incoming jump from 0x05BC, if !msg.value // Inputs[1] { @05C9 msg.data.length } 05C1 5B JUMPDEST 05C2 50 POP 05C3 61 PUSH2 0x02b7 05C6 61 PUSH2 0x05d0 05C9 36 CALLDATASIZE 05CA 60 PUSH1 0x04 05CC 61 PUSH2 0x1c84 05CF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05C3 stack[-1] = 0x02b7 // @05C6 stack[0] = 0x05d0 // @05C9 stack[1] = msg.data.length // @05CA stack[2] = 0x04 // } // Block ends with call to 0x1c84, returns to 0x05D0 label_05D0: // Incoming return from call to 0x1C84 at 0x05CF 05D0 5B JUMPDEST 05D1 61 PUSH2 0x11c1 05D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11c1 label_05D5: // Incoming call from 0x0211, returns to 0x0212 // Inputs[2] // { // @05D8 storage[0x13] // @05DC stack[-1] // } 05D5 5B JUMPDEST 05D6 60 PUSH1 0x13 05D8 54 SLOAD 05D9 60 PUSH1 0xff 05DB 16 AND 05DC 81 DUP2 05DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @05DB stack[0] = 0xff & storage[0x13] } // Block ends with unconditional jump to stack[-1] label_05DE: // Incoming jump from 0x0247 // Inputs[1] { @05EA stack[-1] } 05DE 5B JUMPDEST 05DF 60 PUSH1 0x00 05E1 60 PUSH1 0x01 05E3 60 PUSH1 0x01 05E5 60 PUSH1 0xe0 05E7 1B SHL 05E8 03 SUB 05E9 19 NOT 05EA 82 DUP3 05EB 16 AND 05EC 63 PUSH4 0x780e9d63 05F1 60 PUSH1 0xe0 05F3 1B SHL 05F4 14 EQ 05F5 80 DUP1 05F6 61 PUSH2 0x0603 05F9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @05DF stack[0] = 0x00 // @05F4 stack[1] = 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0603, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_05FA: // Incoming jump from 0x05F9, if not 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @05FE stack[-3] } 05FA 50 POP 05FB 61 PUSH2 0x0603 05FE 82 DUP3 05FF 61 PUSH2 0x122f 0602 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05FB stack[-1] = 0x0603 // @05FE stack[0] = stack[-3] // } // Block ends with unconditional jump to 0x122f label_0603: // Incoming jump from 0x1265, if stack[-1] // Incoming jump from 0x0A26, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1265, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x05F9, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1691 at 0x126E // Inputs[2] // { // @0604 stack[-2] // @0604 stack[-1] // } 0603 5B JUMPDEST 0604 90 SWAP1 0605 50 POP // Stack delta = -1 // Outputs[1] { @0604 stack[-2] = stack[-1] } // Block continues label_0606: // Incoming jump from 0x1C7F, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x0605 // Inputs[3] // { // @0607 stack[-3] // @0607 stack[-1] // @0608 stack[-2] // } 0606 5B JUMPDEST 0607 91 SWAP2 0608 90 SWAP1 0609 50 POP 060A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0607 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_060B: // Incoming call from 0x025C, returns to 0x025D // Inputs[1] { @0611 storage[0x00] } 060B 5B JUMPDEST 060C 60 PUSH1 0x60 060E 60 PUSH1 0x00 0610 80 DUP1 0611 54 SLOAD 0612 61 PUSH2 0x061a 0615 90 SWAP1 0616 61 PUSH2 0x26b8 0619 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @060C stack[0] = 0x60 // @060E stack[1] = 0x00 // @0615 stack[2] = 0x061a // @0615 stack[3] = storage[0x00] // } // Block ends with call to 0x26b8, returns to 0x061A label_061A: // Incoming return from call to 0x26B8 at 0x0619 // Incoming return from call to 0x26B8 at 0x1523 // Incoming return from call to 0x26B8 at 0x0DD3 // Inputs[4] // { // @061B stack[-1] // @062A memory[0x40:0x60] // @0632 stack[-2] // @063D storage[stack[-2]] // } 061A 5B JUMPDEST 061B 80 DUP1 061C 60 PUSH1 0x1f 061E 01 ADD 061F 60 PUSH1 0x20 0621 80 DUP1 0622 91 SWAP2 0623 04 DIV 0624 02 MUL 0625 60 PUSH1 0x20 0627 01 ADD 0628 60 PUSH1 0x40 062A 51 MLOAD 062B 90 SWAP1 062C 81 DUP2 062D 01 ADD 062E 60 PUSH1 0x40 0630 52 MSTORE 0631 80 DUP1 0632 92 SWAP3 0633 91 SWAP2 0634 90 SWAP1 0635 81 DUP2 0636 81 DUP2 0637 52 MSTORE 0638 60 PUSH1 0x20 063A 01 ADD 063B 82 DUP3 063C 80 DUP1 063D 54 SLOAD 063E 61 PUSH2 0x0646 0641 90 SWAP1 0642 61 PUSH2 0x26b8 0645 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0630 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0632 stack[-2] = memory[0x40:0x60] // @0633 stack[-1] = stack[-2] // @0634 stack[0] = stack[-1] // @0637 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @063A stack[1] = 0x20 + memory[0x40:0x60] // @063B stack[2] = stack[-2] // @0641 stack[4] = storage[stack[-2]] // @0641 stack[3] = 0x0646 // } // Block ends with call to 0x26b8, returns to 0x0646 label_0646: // Incoming return from call to 0x26B8 at 0x0645 // Inputs[1] { @0647 stack[-1] } 0646 5B JUMPDEST 0647 80 DUP1 0648 15 ISZERO 0649 61 PUSH2 0x0693 064C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0693, if !stack[-1] label_064D: // Incoming jump from 0x064C, if not !stack[-1] // Inputs[1] { @064D stack[-1] } 064D 80 DUP1 064E 60 PUSH1 0x1f 0650 10 LT 0651 61 PUSH2 0x0668 0654 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0668, if 0x1f < stack[-1] label_0655: // Incoming jump from 0x0654, if not 0x1f < stack[-1] // Inputs[4] // { // @0659 stack[-2] // @065A storage[stack[-2]] // @065D stack[-3] // @065F stack[-1] // } 0655 61 PUSH2 0x0100 0658 80 DUP1 0659 83 DUP4 065A 54 SLOAD 065B 04 DIV 065C 02 MUL 065D 83 DUP4 065E 52 MSTORE 065F 91 SWAP2 0660 60 PUSH1 0x20 0662 01 ADD 0663 91 SWAP2 0664 61 PUSH2 0x0693 0667 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @065E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0663 stack[-1] = stack[-1] // @0663 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0693 label_0668: // Incoming jump from 0x0654, if 0x1f < stack[-1] // Inputs[5] // { // @0669 stack[-3] // @066A stack[-1] // @066C stack[-2] // @0674 memory[0x00:0x20] // @0678 storage[keccak256(memory[0x00:0x20])] // } 0668 5B JUMPDEST 0669 82 DUP3 066A 01 ADD 066B 91 SWAP2 066C 90 SWAP1 066D 60 PUSH1 0x00 066F 52 MSTORE 0670 60 PUSH1 0x20 0672 60 PUSH1 0x00 0674 20 SHA3 0675 90 SWAP1 0676 5B JUMPDEST 0677 81 DUP2 0678 54 SLOAD 0679 81 DUP2 067A 52 MSTORE 067B 90 SWAP1 067C 60 PUSH1 0x01 067E 01 ADD 067F 90 SWAP1 0680 60 PUSH1 0x20 0682 01 ADD 0683 80 DUP1 0684 83 DUP4 0685 11 GT 0686 61 PUSH2 0x0676 0689 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @066B stack[-3] = stack[-3] + stack[-1] // @066F memory[0x00:0x20] = stack[-2] // @067A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @067F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0682 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0676, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_068A: // Incoming jump from 0x0689, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0689, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @068A stack[-3] // @068B stack[-1] // } 068A 82 DUP3 068B 90 SWAP1 068C 03 SUB 068D 60 PUSH1 0x1f 068F 16 AND 0690 82 DUP3 0691 01 ADD 0692 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0692 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0692 stack[-1] = stack[-3] // } // Block continues label_0693: // Incoming jump from 0x0667 // Incoming jump from 0x064C, if !stack[-1] // Incoming jump from 0x0692 // Inputs[3] // { // @0699 stack[-7] // @0699 stack[-6] // @069B stack[-8] // } 0693 5B JUMPDEST 0694 50 POP 0695 50 POP 0696 50 POP 0697 50 POP 0698 50 POP 0699 90 SWAP1 069A 50 POP 069B 90 SWAP1 069C 56 *JUMP // Stack delta = -7 // Outputs[1] { @069B stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_069D: // Incoming jump from 0x0289 // Inputs[1] { @06A3 stack[-1] } 069D 5B JUMPDEST 069E 60 PUSH1 0x00 06A0 61 PUSH2 0x06a8 06A3 82 DUP3 06A4 61 PUSH2 0x126f 06A7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @069E stack[0] = 0x00 // @06A0 stack[1] = 0x06a8 // @06A3 stack[2] = stack[-1] // } // Block ends with call to 0x126f, returns to 0x06A8 label_06A8: // Incoming return from call to 0x126F at 0x06A7 // Inputs[1] { @06AC stack[-1] } 06A8 5B JUMPDEST 06A9 61 PUSH2 0x06cd 06AC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06cd, if stack[-1] label_06AD: // Incoming jump from 0x06AC, if not stack[-1] // Inputs[1] { @06AF memory[0x40:0x60] } 06AD 60 PUSH1 0x40 06AF 51 MLOAD 06B0 62 PUSH3 0x461bcd 06B4 60 PUSH1 0xe5 06B6 1B SHL 06B7 81 DUP2 06B8 52 MSTORE 06B9 60 PUSH1 0x04 06BB 01 ADD 06BC 61 PUSH2 0x06c4 06BF 90 SWAP1 06C0 61 PUSH2 0x2382 06C3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @06B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06BF stack[0] = 0x06c4 // @06BF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2382, returns to 0x06C4 label_06C4: // Incoming return from call to 0x252D at 0x097F // Incoming return from call to 0x25D5 at 0x110F // Incoming return from call to 0x244C at 0x1052 // Incoming return from call to 0x22BA at 0x0A6B // Incoming return from call to 0x1F8E at 0x0B3D // Incoming return from call to 0x21C3 at 0x0DF6 // Incoming return from call to 0x2382 at 0x06C3 // Incoming return from call to 0x25B0 at 0x0939 // Incoming return from call to 0x2211 at 0x1324 // Incoming return from call to 0x23CE at 0x0D98 // Incoming return from call to 0x23CE at 0x0FD5 // Incoming return from call to 0x2304 at 0x0A3D // Incoming return from call to 0x23CE at 0x11FF // Incoming return from call to 0x23CE at 0x09F1 // Incoming return from call to 0x23CE at 0x08B6 // Incoming return from call to 0x20A5 at 0x1225 // Incoming return from call to 0x23CE at 0x07BF // Incoming return from call to 0x23CE at 0x10ED // Incoming return from call to 0x2008 at 0x0848 // Incoming return from call to 0x218C at 0x0EE9 // Inputs[3] // { // @06C7 memory[0x40:0x60] // @06C9 stack[-1] // @06CC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 06C4 5B JUMPDEST 06C5 60 PUSH1 0x40 06C7 51 MLOAD 06C8 80 DUP1 06C9 91 SWAP2 06CA 03 SUB 06CB 90 SWAP1 06CC FD *REVERT // Stack delta = -1 // Outputs[1] { @06CC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_06CD: // Incoming jump from 0x06AC, if stack[-1] // Inputs[4] // { // @06D1 stack[-2] // @06DC memory[0x00:0x40] // @06DD storage[keccak256(memory[0x00:0x40])] // @06E7 stack[-3] // } 06CD 5B JUMPDEST 06CE 50 POP 06CF 60 PUSH1 0x00 06D1 90 SWAP1 06D2 81 DUP2 06D3 52 MSTORE 06D4 60 PUSH1 0x04 06D6 60 PUSH1 0x20 06D8 52 MSTORE 06D9 60 PUSH1 0x40 06DB 90 SWAP1 06DC 20 SHA3 06DD 54 SLOAD 06DE 60 PUSH1 0x01 06E0 60 PUSH1 0x01 06E2 60 PUSH1 0xa0 06E4 1B SHL 06E5 03 SUB 06E6 16 AND 06E7 90 SWAP1 06E8 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @06D3 memory[0x00:0x20] = stack[-2] // @06D8 memory[0x20:0x40] = 0x04 // @06E7 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_06E9: // Incoming jump from 0x02B6 // Inputs[1] { @06EF stack[-1] } 06E9 5B JUMPDEST 06EA 60 PUSH1 0x00 06EC 61 PUSH2 0x06f4 06EF 82 DUP3 06F0 61 PUSH2 0x0a09 06F3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06EA stack[0] = 0x00 // @06EC stack[1] = 0x06f4 // @06EF stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x0a09 06F4 5B JUMPDEST 06F5 90 SWAP1 06F6 50 POP 06F7 80 DUP1 06F8 60 PUSH1 0x01 06FA 60 PUSH1 0x01 06FC 60 PUSH1 0xa0 06FE 1B SHL 06FF 03 SUB 0700 16 AND 0701 83 DUP4 0702 60 PUSH1 0x01 0704 60 PUSH1 0x01 0706 60 PUSH1 0xa0 0708 1B SHL 0709 03 SUB 070A 16 AND 070B 14 EQ 070C 15 ISZERO 070D 61 PUSH2 0x0728 0710 57 *JUMPI 0711 60 PUSH1 0x40 0713 51 MLOAD 0714 62 PUSH3 0x461bcd 0718 60 PUSH1 0xe5 071A 1B SHL 071B 81 DUP2 071C 52 MSTORE 071D 60 PUSH1 0x04 071F 01 ADD 0720 61 PUSH2 0x06c4 0723 90 SWAP1 0724 61 PUSH2 0x249b 0727 56 *JUMP 0728 5B JUMPDEST 0729 80 DUP1 072A 60 PUSH1 0x01 072C 60 PUSH1 0x01 072E 60 PUSH1 0xa0 0730 1B SHL 0731 03 SUB 0732 16 AND 0733 61 PUSH2 0x073a 0736 61 PUSH2 0x128c 0739 56 *JUMP 073A 5B JUMPDEST 073B 60 PUSH1 0x01 073D 60 PUSH1 0x01 073F 60 PUSH1 0xa0 0741 1B SHL 0742 03 SUB 0743 16 AND 0744 14 EQ 0745 80 DUP1 0746 61 PUSH2 0x0756 0749 57 *JUMPI 074A 50 POP 074B 61 PUSH2 0x0756 074E 81 DUP2 074F 61 PUSH2 0x05b0 0752 61 PUSH2 0x128c 0755 56 *JUMP 0756 5B JUMPDEST 0757 61 PUSH2 0x0772 075A 57 *JUMPI 075B 60 PUSH1 0x40 075D 51 MLOAD 075E 62 PUSH3 0x461bcd 0762 60 PUSH1 0xe5 0764 1B SHL 0765 81 DUP2 0766 52 MSTORE 0767 60 PUSH1 0x04 0769 01 ADD 076A 61 PUSH2 0x06c4 076D 90 SWAP1 076E 61 PUSH2 0x225d 0771 56 *JUMP 0772 5B JUMPDEST 0773 61 PUSH2 0x077c 0776 83 DUP4 0777 83 DUP4 0778 61 PUSH2 0x1290 077B 56 *JUMP 077C 5B JUMPDEST 077D 50 POP 077E 50 POP 077F 50 POP 0780 56 *JUMP label_0781: // Incoming call from 0x02CD, returns to 0x02B7 0781 5B JUMPDEST 0782 61 PUSH2 0x0789 0785 61 PUSH2 0x128c 0788 56 *JUMP // Stack delta = +1 // Outputs[1] { @0782 stack[0] = 0x0789 } // Block ends with call to 0x128c, returns to 0x0789 label_0789: // Incoming return from call to 0x128C at 0x0788 // Inputs[1] { @0792 stack[-1] } 0789 5B JUMPDEST 078A 60 PUSH1 0x01 078C 60 PUSH1 0x01 078E 60 PUSH1 0xa0 0790 1B SHL 0791 03 SUB 0792 16 AND 0793 61 PUSH2 0x079a 0796 61 PUSH2 0x0db6 0799 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0792 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0793 stack[0] = 0x079a // } // Block ends with call to 0x0db6, returns to 0x079A label_079A: // Incoming return from call to 0x0DB6 at 0x0799 // Inputs[2] // { // @07A3 stack[-1] // @07A4 stack[-2] // } 079A 5B JUMPDEST 079B 60 PUSH1 0x01 079D 60 PUSH1 0x01 079F 60 PUSH1 0xa0 07A1 1B SHL 07A2 03 SUB 07A3 16 AND 07A4 14 EQ 07A5 61 PUSH2 0x07c0 07A8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x07c0, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_07A9: // Incoming jump from 0x07A8, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @07AB memory[0x40:0x60] } 07A9 60 PUSH1 0x40 07AB 51 MLOAD 07AC 62 PUSH3 0x461bcd 07B0 60 PUSH1 0xe5 07B2 1B SHL 07B3 81 DUP2 07B4 52 MSTORE 07B5 60 PUSH1 0x04 07B7 01 ADD 07B8 61 PUSH2 0x06c4 07BB 90 SWAP1 07BC 61 PUSH2 0x23ce 07BF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @07B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07BB stack[0] = 0x06c4 // @07BB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23ce, returns to 0x06C4 label_07C0: // Incoming jump from 0x07A8, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @07C4 storage[0x13] // @07D3 stack[-1] // } 07C0 5B JUMPDEST 07C1 60 PUSH1 0x13 07C3 80 DUP1 07C4 54 SLOAD 07C5 60 PUSH1 0xff 07C7 19 NOT 07C8 81 DUP2 07C9 16 AND 07CA 60 PUSH1 0xff 07CC 90 SWAP1 07CD 91 SWAP2 07CE 16 AND 07CF 15 ISZERO 07D0 17 OR 07D1 90 SWAP1 07D2 55 SSTORE 07D3 56 *JUMP // Stack delta = -1 // Outputs[1] { @07D2 storage[0x13] = !(storage[0x13] & 0xff) | (storage[0x13] & ~0xff) } // Block ends with unconditional jump to stack[-1] label_07D4: // Incoming call from 0x111E, returns to 0x0B4D // Incoming call from 0x0B4C, returns to 0x0B4D // Incoming call from 0x02E2, returns to 0x02E3 // Incoming call from 0x0E05, returns to 0x0B4D // Incoming call from 0x0961, returns to 0x0962 // Inputs[2] // { // @07D7 storage[0x09] // @07D8 stack[-1] // } 07D4 5B JUMPDEST 07D5 60 PUSH1 0x09 07D7 54 SLOAD 07D8 90 SWAP1 07D9 56 *JUMP // Stack delta = +0 // Outputs[1] { @07D8 stack[-1] = storage[0x09] } // Block ends with unconditional jump to stack[-1] label_07DA: // Incoming jump from 0x030F 07DA 5B JUMPDEST 07DB 61 PUSH2 0x07eb 07DE 61 PUSH2 0x07e5 07E1 61 PUSH2 0x128c 07E4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07DB stack[0] = 0x07eb // @07DE stack[1] = 0x07e5 // } // Block ends with call to 0x128c, returns to 0x07E5 label_07E5: // Incoming return from call to 0x128C at 0x07E4 // Inputs[1] { @07E6 stack[-3] } 07E5 5B JUMPDEST 07E6 82 DUP3 07E7 61 PUSH2 0x12fe 07EA 56 *JUMP // Stack delta = +1 // Outputs[1] { @07E6 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x12fe 07EB 5B JUMPDEST 07EC 61 PUSH2 0x0807 07EF 57 *JUMPI 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 0x06c4 0802 90 SWAP1 0803 61 PUSH2 0x24dc 0806 56 *JUMP 0807 5B JUMPDEST 0808 61 PUSH2 0x077c 080B 83 DUP4 080C 83 DUP4 080D 83 DUP4 080E 61 PUSH2 0x1383 0811 56 *JUMP label_0812: // Incoming call from 0x0324, returns to 0x0212 // Inputs[2] // { // @0815 storage[0x13] // @081E stack[-1] // } 0812 5B JUMPDEST 0813 60 PUSH1 0x13 0815 54 SLOAD 0816 61 PUSH2 0x0100 0819 90 SWAP1 081A 04 DIV 081B 60 PUSH1 0xff 081D 16 AND 081E 81 DUP2 081F 56 *JUMP // Stack delta = +1 // Outputs[1] { @081D stack[0] = 0xff & storage[0x13] / 0x0100 } // Block ends with unconditional jump to stack[-1] label_0820: // Incoming call from 0x0D14, returns to 0x0D15 // Incoming jump from 0x0344 // Inputs[1] { @0826 stack[-2] } 0820 5B JUMPDEST 0821 60 PUSH1 0x00 0823 61 PUSH2 0x082b 0826 83 DUP4 0827 61 PUSH2 0x0a44 082A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0821 stack[0] = 0x00 // @0823 stack[1] = 0x082b // @0826 stack[2] = stack[-2] // } // Block ends with call to 0x0a44, returns to 0x082B label_082B: // Incoming return from call to 0x0A44 at 0x082A // Inputs[2] // { // @082C stack[-3] // @082D stack[-1] // } 082B 5B JUMPDEST 082C 82 DUP3 082D 10 LT 082E 61 PUSH2 0x0849 0831 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0849, if stack[-3] < stack[-1] label_0832: // Incoming jump from 0x0831, if not stack[-3] < stack[-1] // Inputs[1] { @0834 memory[0x40:0x60] } 0832 60 PUSH1 0x40 0834 51 MLOAD 0835 62 PUSH3 0x461bcd 0839 60 PUSH1 0xe5 083B 1B SHL 083C 81 DUP2 083D 52 MSTORE 083E 60 PUSH1 0x04 0840 01 ADD 0841 61 PUSH2 0x06c4 0844 90 SWAP1 0845 61 PUSH2 0x2008 0848 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @083D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0844 stack[0] = 0x06c4 // @0844 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2008, returns to 0x06C4 label_0849: // Incoming jump from 0x0831, if stack[-3] < stack[-1] // Inputs[6] // { // @0853 stack[-3] // @0854 stack[-2] // @0867 memory[0x00:0x40] // @086E memory[0x00:0x40] // @086F storage[keccak256(memory[0x00:0x40])] // @0870 stack[-4] // } 0849 5B JUMPDEST 084A 50 POP 084B 60 PUSH1 0x01 084D 60 PUSH1 0x01 084F 60 PUSH1 0xa0 0851 1B SHL 0852 03 SUB 0853 91 SWAP2 0854 90 SWAP1 0855 91 SWAP2 0856 16 AND 0857 60 PUSH1 0x00 0859 90 SWAP1 085A 81 DUP2 085B 52 MSTORE 085C 60 PUSH1 0x07 085E 60 PUSH1 0x20 0860 90 SWAP1 0861 81 DUP2 0862 52 MSTORE 0863 60 PUSH1 0x40 0865 80 DUP1 0866 83 DUP4 0867 20 SHA3 0868 93 SWAP4 0869 83 DUP4 086A 52 MSTORE 086B 92 SWAP3 086C 90 SWAP1 086D 52 MSTORE 086E 20 SHA3 086F 54 SLOAD 0870 90 SWAP1 0871 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @085B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0862 memory[0x20:0x40] = 0x07 // @086A memory[0x00:0x20] = stack[-2] // @086D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0870 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0872: // Incoming call from 0x0359, returns to 0x02E3 // Inputs[2] // { // @0875 storage[0x0e] // @0876 stack[-1] // } 0872 5B JUMPDEST 0873 60 PUSH1 0x0e 0875 54 SLOAD 0876 81 DUP2 0877 56 *JUMP // Stack delta = +1 // Outputs[1] { @0875 stack[0] = storage[0x0e] } // Block ends with unconditional jump to stack[-1] label_0878: // Incoming call from 0x036E, returns to 0x02B7 0878 5B JUMPDEST 0879 61 PUSH2 0x0880 087C 61 PUSH2 0x128c 087F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0879 stack[0] = 0x0880 } // Block ends with call to 0x128c, returns to 0x0880 label_0880: // Incoming return from call to 0x128C at 0x087F // Inputs[1] { @0889 stack[-1] } 0880 5B JUMPDEST 0881 60 PUSH1 0x01 0883 60 PUSH1 0x01 0885 60 PUSH1 0xa0 0887 1B SHL 0888 03 SUB 0889 16 AND 088A 61 PUSH2 0x0891 088D 61 PUSH2 0x0db6 0890 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0889 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @088A stack[0] = 0x0891 // } // Block ends with call to 0x0db6, returns to 0x0891 label_0891: // Incoming return from call to 0x0DB6 at 0x0890 // Inputs[2] // { // @089A stack[-1] // @089B stack[-2] // } 0891 5B JUMPDEST 0892 60 PUSH1 0x01 0894 60 PUSH1 0x01 0896 60 PUSH1 0xa0 0898 1B SHL 0899 03 SUB 089A 16 AND 089B 14 EQ 089C 61 PUSH2 0x08b7 089F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x08b7, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_08A0: // Incoming jump from 0x089F, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @08A2 memory[0x40:0x60] } 08A0 60 PUSH1 0x40 08A2 51 MLOAD 08A3 62 PUSH3 0x461bcd 08A7 60 PUSH1 0xe5 08A9 1B SHL 08AA 81 DUP2 08AB 52 MSTORE 08AC 60 PUSH1 0x04 08AE 01 ADD 08AF 61 PUSH2 0x06c4 08B2 90 SWAP1 08B3 61 PUSH2 0x23ce 08B6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08B2 stack[0] = 0x06c4 // @08B2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23ce, returns to 0x06C4 label_08B7: // Incoming jump from 0x089F, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 08B7 5B JUMPDEST 08B8 60 PUSH1 0x00 08BA 61 PUSH2 0x08c1 08BD 61 PUSH2 0x0db6 08C0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @08B8 stack[0] = 0x00 // @08BA stack[1] = 0x08c1 // } // Block ends with call to 0x0db6, returns to 0x08C1 label_08C1: // Incoming return from call to 0x0DB6 at 0x08C0 // Inputs[4] // { // @08CA stack[-1] // @08CB address(this) // @08CB address(this).balance // @08CE memory[0x40:0x60] // } 08C1 5B JUMPDEST 08C2 60 PUSH1 0x01 08C4 60 PUSH1 0x01 08C6 60 PUSH1 0xa0 08C8 1B SHL 08C9 03 SUB 08CA 16 AND 08CB 47 SELFBALANCE 08CC 60 PUSH1 0x40 08CE 51 MLOAD 08CF 61 PUSH2 0x08d7 08D2 90 SWAP1 08D3 61 PUSH2 0x1ed8 08D6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @08CA stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @08CB stack[0] = address(this).balance // @08D2 stack[2] = memory[0x40:0x60] // @08D2 stack[1] = 0x08d7 // } // Block ends with call to 0x1ed8, returns to 0x08D7 label_08D7: // Incoming return from call to 0x1ED8 at 0x08D6 // Inputs[8] // { // @08DC memory[0x40:0x60] // @08DE stack[-1] // @08E1 stack[-2] // @08E2 stack[-3] // @08E3 msg.gas // @08E4 address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @08E9 returndata.length // } 08D7 5B JUMPDEST 08D8 60 PUSH1 0x00 08DA 60 PUSH1 0x40 08DC 51 MLOAD 08DD 80 DUP1 08DE 83 DUP4 08DF 03 SUB 08E0 81 DUP2 08E1 85 DUP6 08E2 87 DUP8 08E3 5A GAS 08E4 F1 CALL 08E5 92 SWAP3 08E6 50 POP 08E7 50 POP 08E8 50 POP 08E9 3D RETURNDATASIZE 08EA 80 DUP1 08EB 60 PUSH1 0x00 08ED 81 DUP2 08EE 14 EQ 08EF 61 PUSH2 0x0914 08F2 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @08E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08E5 stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @08E9 stack[-2] = returndata.length // @08EA stack[-1] = returndata.length // } // Block ends with conditional jump to 0x0914, if returndata.length == 0x00 label_08F3: // Incoming jump from 0x08F2, if not returndata.length == 0x00 // Inputs[6] // { // @08F5 memory[0x40:0x60] // @08F6 stack[-2] // @08FD returndata.length // @0905 returndata.length // @0908 returndata.length // @090F returndata[0x00:0x00 + returndata.length] // } 08F3 60 PUSH1 0x40 08F5 51 MLOAD 08F6 91 SWAP2 08F7 50 POP 08F8 60 PUSH1 0x1f 08FA 19 NOT 08FB 60 PUSH1 0x3f 08FD 3D RETURNDATASIZE 08FE 01 ADD 08FF 16 AND 0900 82 DUP3 0901 01 ADD 0902 60 PUSH1 0x40 0904 52 MSTORE 0905 3D RETURNDATASIZE 0906 82 DUP3 0907 52 MSTORE 0908 3D RETURNDATASIZE 0909 60 PUSH1 0x00 090B 60 PUSH1 0x20 090D 84 DUP5 090E 01 ADD 090F 3E RETURNDATACOPY 0910 61 PUSH2 0x0919 0913 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @08F6 stack[-2] = memory[0x40:0x60] // @0904 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0907 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @090F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0919 label_0914: // Incoming jump from 0x08F2, if returndata.length == 0x00 // Inputs[3] // { // @0917 stack[-2] // @091C stack[-4] // @091C stack[-3] // } 0914 5B JUMPDEST 0915 60 PUSH1 0x60 0917 91 SWAP2 0918 50 POP 0919 5B JUMPDEST 091A 50 POP 091B 50 POP 091C 90 SWAP1 091D 50 POP 091E 80 DUP1 091F 61 PUSH2 0x093a 0922 57 *JUMPI // Stack delta = -3 // Outputs[1] { @091C stack[-4] = stack[-3] } // Block ends with conditional jump to 0x093a, if stack[-3] label_0923: // Incoming jump from 0x0922, if not stack[-3] // Incoming jump from 0x0922, if not stack[-3] // Inputs[1] { @0925 memory[0x40:0x60] } 0923 60 PUSH1 0x40 0925 51 MLOAD 0926 62 PUSH3 0x461bcd 092A 60 PUSH1 0xe5 092C 1B SHL 092D 81 DUP2 092E 52 MSTORE 092F 60 PUSH1 0x04 0931 01 ADD 0932 61 PUSH2 0x06c4 0935 90 SWAP1 0936 61 PUSH2 0x25b0 0939 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @092E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0935 stack[0] = 0x06c4 // @0935 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25b0, returns to 0x06C4 label_093A: // Incoming return from call to 0x163F at 0x122E // Incoming jump from 0x0922, if stack[-3] // Incoming jump from 0x2775, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0922, if stack[-3] // Inputs[1] { @093C stack[-2] } 093A 5B JUMPDEST 093B 50 POP 093C 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_093D: // Incoming jump from 0x038E // Inputs[4] // { // @0941 stack[-3] // @0942 stack[-2] // @0943 stack[-1] // @0946 memory[0x40:0x60] // } 093D 5B JUMPDEST 093E 61 PUSH2 0x077c 0941 83 DUP4 0942 83 DUP4 0943 83 DUP4 0944 60 PUSH1 0x40 0946 51 MLOAD 0947 80 DUP1 0948 60 PUSH1 0x20 094A 01 ADD 094B 60 PUSH1 0x40 094D 52 MSTORE 094E 80 DUP1 094F 60 PUSH1 0x00 0951 81 DUP2 0952 52 MSTORE 0953 50 POP 0954 61 PUSH2 0x0fed 0957 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @093E stack[0] = 0x077c // @0941 stack[1] = stack[-3] // @0942 stack[2] = stack[-2] // @0943 stack[3] = stack[-1] // @0946 stack[4] = memory[0x40:0x60] // @094D memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0952 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0fed label_0958: // Incoming jump from 0x03AE 0958 5B JUMPDEST 0959 60 PUSH1 0x00 095B 61 PUSH2 0x0962 095E 61 PUSH2 0x07d4 0961 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0959 stack[0] = 0x00 // @095B stack[1] = 0x0962 // } // Block ends with call to 0x07d4, returns to 0x0962 label_0962: // Incoming return from call to 0x07D4 at 0x0961 // Inputs[2] // { // @0963 stack[-3] // @0964 stack[-1] // } 0962 5B JUMPDEST 0963 82 DUP3 0964 10 LT 0965 61 PUSH2 0x0980 0968 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0980, if stack[-3] < stack[-1] label_0969: // Incoming jump from 0x0968, if not stack[-3] < stack[-1] // Inputs[1] { @096B memory[0x40:0x60] } 0969 60 PUSH1 0x40 096B 51 MLOAD 096C 62 PUSH3 0x461bcd 0970 60 PUSH1 0xe5 0972 1B SHL 0973 81 DUP2 0974 52 MSTORE 0975 60 PUSH1 0x04 0977 01 ADD 0978 61 PUSH2 0x06c4 097B 90 SWAP1 097C 61 PUSH2 0x252d 097F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0974 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @097B stack[0] = 0x06c4 // @097B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x252d, returns to 0x06C4 label_0980: // Incoming jump from 0x0968, if stack[-3] < stack[-1] // Inputs[2] // { // @0983 stack[-2] // @0985 storage[0x09] // } 0980 5B JUMPDEST 0981 60 PUSH1 0x09 0983 82 DUP3 0984 81 DUP2 0985 54 SLOAD 0986 81 DUP2 0987 10 LT 0988 61 PUSH2 0x09a1 098B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0981 stack[0] = 0x09 // @0983 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x09a1, if stack[-2] < storage[0x09] label_098C: // Incoming jump from 0x098B, if not stack[-2] < storage[0x09] // Inputs[1] { @09A0 memory[0x00:0x24] } 098C 63 PUSH4 0x4e487b71 0991 60 PUSH1 0xe0 0993 1B SHL 0994 60 PUSH1 0x00 0996 52 MSTORE 0997 60 PUSH1 0x32 0999 60 PUSH1 0x04 099B 52 MSTORE 099C 60 PUSH1 0x24 099E 60 PUSH1 0x00 09A0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0996 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @099B memory[0x04:0x24] = 0x32 // @09A0 revert(memory[0x00:0x24]); // } // Block terminates label_09A1: // Incoming jump from 0x098B, if stack[-2] < storage[0x09] // Inputs[7] // { // @09A2 stack[-1] // @09A2 stack[-2] // @09AA memory[0x00:0x20] // @09AC storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @09AD stack[-3] // @09AF stack[-5] // @09B0 stack[-4] // } 09A1 5B JUMPDEST 09A2 90 SWAP1 09A3 60 PUSH1 0x00 09A5 52 MSTORE 09A6 60 PUSH1 0x20 09A8 60 PUSH1 0x00 09AA 20 SHA3 09AB 01 ADD 09AC 54 SLOAD 09AD 90 SWAP1 09AE 50 POP 09AF 91 SWAP2 09B0 90 SWAP1 09B1 50 POP 09B2 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @09A5 memory[0x00:0x20] = stack[-2] // @09AF stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_09B3: // Incoming jump from 0x03CE 09B3 5B JUMPDEST 09B4 61 PUSH2 0x09bb 09B7 61 PUSH2 0x128c 09BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @09B4 stack[0] = 0x09bb } // Block ends with call to 0x128c, returns to 0x09BB label_09BB: // Incoming return from call to 0x128C at 0x09BA // Inputs[1] { @09C4 stack[-1] } 09BB 5B JUMPDEST 09BC 60 PUSH1 0x01 09BE 60 PUSH1 0x01 09C0 60 PUSH1 0xa0 09C2 1B SHL 09C3 03 SUB 09C4 16 AND 09C5 61 PUSH2 0x09cc 09C8 61 PUSH2 0x0db6 09CB 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @09C4 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @09C5 stack[0] = 0x09cc // } // Block ends with call to 0x0db6, returns to 0x09CC label_09CC: // Incoming return from call to 0x0DB6 at 0x09CB // Inputs[2] // { // @09D5 stack[-1] // @09D6 stack[-2] // } 09CC 5B JUMPDEST 09CD 60 PUSH1 0x01 09CF 60 PUSH1 0x01 09D1 60 PUSH1 0xa0 09D3 1B SHL 09D4 03 SUB 09D5 16 AND 09D6 14 EQ 09D7 61 PUSH2 0x09f2 09DA 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x09f2, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_09DB: // Incoming jump from 0x09DA, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @09DD memory[0x40:0x60] } 09DB 60 PUSH1 0x40 09DD 51 MLOAD 09DE 62 PUSH3 0x461bcd 09E2 60 PUSH1 0xe5 09E4 1B SHL 09E5 81 DUP2 09E6 52 MSTORE 09E7 60 PUSH1 0x04 09E9 01 ADD 09EA 61 PUSH2 0x06c4 09ED 90 SWAP1 09EE 61 PUSH2 0x23ce 09F1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09ED stack[0] = 0x06c4 // @09ED stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23ce, returns to 0x06C4 label_09F2: // Incoming jump from 0x09DA, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @09F3 stack[-1] // @09F4 memory[stack[-1]:stack[-1] + 0x20] // } 09F2 5B JUMPDEST 09F3 80 DUP1 09F4 51 MLOAD 09F5 61 PUSH2 0x0a05 09F8 90 SWAP1 09F9 60 PUSH1 0x06 09FB 90 SWAP1 09FC 60 PUSH1 0x20 09FE 84 DUP5 09FF 01 ADD 0A00 90 SWAP1 0A01 61 PUSH2 0x1b64 0A04 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09F8 stack[0] = 0x0a05 // @09FB stack[1] = 0x06 // @0A00 stack[2] = stack[-1] + 0x20 // @0A00 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1b64 0A05 5B JUMPDEST 0A06 50 POP 0A07 50 POP 0A08 56 *JUMP label_0A09: // Incoming jump from 0x132F // Incoming jump from 0x03EE // Incoming jump from 0x06F3 // Inputs[3] // { // @0A0C stack[-1] // @0A17 memory[0x00:0x40] // @0A18 storage[keccak256(memory[0x00:0x40])] // } 0A09 5B JUMPDEST 0A0A 60 PUSH1 0x00 0A0C 81 DUP2 0A0D 81 DUP2 0A0E 52 MSTORE 0A0F 60 PUSH1 0x02 0A11 60 PUSH1 0x20 0A13 52 MSTORE 0A14 60 PUSH1 0x40 0A16 81 DUP2 0A17 20 SHA3 0A18 54 SLOAD 0A19 60 PUSH1 0x01 0A1B 60 PUSH1 0x01 0A1D 60 PUSH1 0xa0 0A1F 1B SHL 0A20 03 SUB 0A21 16 AND 0A22 80 DUP1 0A23 61 PUSH2 0x0603 0A26 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0A0A stack[0] = 0x00 // @0A0E memory[0x00:0x20] = stack[-1] // @0A13 memory[0x20:0x40] = 0x02 // @0A21 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0603, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0A27: // Incoming jump from 0x0A26, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0A29 memory[0x40:0x60] } 0A27 60 PUSH1 0x40 0A29 51 MLOAD 0A2A 62 PUSH3 0x461bcd 0A2E 60 PUSH1 0xe5 0A30 1B SHL 0A31 81 DUP2 0A32 52 MSTORE 0A33 60 PUSH1 0x04 0A35 01 ADD 0A36 61 PUSH2 0x06c4 0A39 90 SWAP1 0A3A 61 PUSH2 0x2304 0A3D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A32 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A39 stack[0] = 0x06c4 // @0A39 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2304, returns to 0x06C4 label_0A3E: // Incoming call from 0x0403, returns to 0x02E3 // Inputs[2] // { // @0A41 storage[0x0c] // @0A42 stack[-1] // } 0A3E 5B JUMPDEST 0A3F 60 PUSH1 0x0c 0A41 54 SLOAD 0A42 81 DUP2 0A43 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A41 stack[0] = storage[0x0c] } // Block ends with unconditional jump to stack[-1] label_0A44: // Incoming call from 0x0CA8, returns to 0x0CA9 // Incoming call from 0x082A, returns to 0x082B // Incoming jump from 0x0423 // Inputs[1] { @0A4F stack[-1] } 0A44 5B JUMPDEST 0A45 60 PUSH1 0x00 0A47 60 PUSH1 0x01 0A49 60 PUSH1 0x01 0A4B 60 PUSH1 0xa0 0A4D 1B SHL 0A4E 03 SUB 0A4F 82 DUP3 0A50 16 AND 0A51 61 PUSH2 0x0a6c 0A54 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A45 stack[0] = 0x00 } // Block ends with conditional jump to 0x0a6c, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0A55: // Incoming jump from 0x0A54, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A57 memory[0x40:0x60] } 0A55 60 PUSH1 0x40 0A57 51 MLOAD 0A58 62 PUSH3 0x461bcd 0A5C 60 PUSH1 0xe5 0A5E 1B SHL 0A5F 81 DUP2 0A60 52 MSTORE 0A61 60 PUSH1 0x04 0A63 01 ADD 0A64 61 PUSH2 0x06c4 0A67 90 SWAP1 0A68 61 PUSH2 0x22ba 0A6B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A67 stack[0] = 0x06c4 // @0A67 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x22ba, returns to 0x06C4 label_0A6C: // Incoming jump from 0x0A54, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0A76 stack[-2] // @0A84 memory[0x00:0x40] // @0A85 storage[keccak256(memory[0x00:0x40])] // @0A86 stack[-3] // } 0A6C 5B JUMPDEST 0A6D 50 POP 0A6E 60 PUSH1 0x01 0A70 60 PUSH1 0x01 0A72 60 PUSH1 0xa0 0A74 1B SHL 0A75 03 SUB 0A76 16 AND 0A77 60 PUSH1 0x00 0A79 90 SWAP1 0A7A 81 DUP2 0A7B 52 MSTORE 0A7C 60 PUSH1 0x03 0A7E 60 PUSH1 0x20 0A80 52 MSTORE 0A81 60 PUSH1 0x40 0A83 90 SWAP1 0A84 20 SHA3 0A85 54 SLOAD 0A86 90 SWAP1 0A87 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0A7B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0A80 memory[0x20:0x40] = 0x03 // @0A86 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0A88: // Incoming call from 0x0438, returns to 0x025D // Inputs[1] { @0A8C storage[0x06] } 0A88 5B JUMPDEST 0A89 60 PUSH1 0x06 0A8B 80 DUP1 0A8C 54 SLOAD 0A8D 61 PUSH2 0x0a95 0A90 90 SWAP1 0A91 61 PUSH2 0x26b8 0A94 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A89 stack[0] = 0x06 // @0A90 stack[1] = 0x0a95 // @0A90 stack[2] = storage[0x06] // } // Block ends with call to 0x26b8, returns to 0x0A95 label_0A95: // Incoming return from call to 0x26B8 at 0x0A94 // Inputs[4] // { // @0A96 stack[-1] // @0AA5 memory[0x40:0x60] // @0AAD stack[-2] // @0AB8 storage[stack[-2]] // } 0A95 5B JUMPDEST 0A96 80 DUP1 0A97 60 PUSH1 0x1f 0A99 01 ADD 0A9A 60 PUSH1 0x20 0A9C 80 DUP1 0A9D 91 SWAP2 0A9E 04 DIV 0A9F 02 MUL 0AA0 60 PUSH1 0x20 0AA2 01 ADD 0AA3 60 PUSH1 0x40 0AA5 51 MLOAD 0AA6 90 SWAP1 0AA7 81 DUP2 0AA8 01 ADD 0AA9 60 PUSH1 0x40 0AAB 52 MSTORE 0AAC 80 DUP1 0AAD 92 SWAP3 0AAE 91 SWAP2 0AAF 90 SWAP1 0AB0 81 DUP2 0AB1 81 DUP2 0AB2 52 MSTORE 0AB3 60 PUSH1 0x20 0AB5 01 ADD 0AB6 82 DUP3 0AB7 80 DUP1 0AB8 54 SLOAD 0AB9 61 PUSH2 0x0ac1 0ABC 90 SWAP1 0ABD 61 PUSH2 0x26b8 0AC0 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0AAB memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0AAD stack[-2] = memory[0x40:0x60] // @0AAE stack[-1] = stack[-2] // @0AAF stack[0] = stack[-1] // @0AB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0AB5 stack[1] = 0x20 + memory[0x40:0x60] // @0AB6 stack[2] = stack[-2] // @0ABC stack[4] = storage[stack[-2]] // @0ABC stack[3] = 0x0ac1 // } // Block ends with call to 0x26b8, returns to 0x0AC1 label_0AC1: // Incoming return from call to 0x26B8 at 0x0AC0 // Inputs[1] { @0AC2 stack[-1] } 0AC1 5B JUMPDEST 0AC2 80 DUP1 0AC3 15 ISZERO 0AC4 61 PUSH2 0x0b0e 0AC7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b0e, if !stack[-1] label_0AC8: // Incoming jump from 0x0AC7, if not !stack[-1] // Inputs[1] { @0AC8 stack[-1] } 0AC8 80 DUP1 0AC9 60 PUSH1 0x1f 0ACB 10 LT 0ACC 61 PUSH2 0x0ae3 0ACF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ae3, if 0x1f < stack[-1] label_0AD0: // Incoming jump from 0x0ACF, if not 0x1f < stack[-1] // Inputs[4] // { // @0AD4 stack[-2] // @0AD5 storage[stack[-2]] // @0AD8 stack[-3] // @0ADA stack[-1] // } 0AD0 61 PUSH2 0x0100 0AD3 80 DUP1 0AD4 83 DUP4 0AD5 54 SLOAD 0AD6 04 DIV 0AD7 02 MUL 0AD8 83 DUP4 0AD9 52 MSTORE 0ADA 91 SWAP2 0ADB 60 PUSH1 0x20 0ADD 01 ADD 0ADE 91 SWAP2 0ADF 61 PUSH2 0x0b0e 0AE2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0AD9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0ADE stack[-1] = stack[-1] // @0ADE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0b0e label_0AE3: // Incoming jump from 0x0ACF, if 0x1f < stack[-1] // Inputs[5] // { // @0AE4 stack[-3] // @0AE5 stack[-1] // @0AE7 stack[-2] // @0AEF memory[0x00:0x20] // @0AF3 storage[keccak256(memory[0x00:0x20])] // } 0AE3 5B JUMPDEST 0AE4 82 DUP3 0AE5 01 ADD 0AE6 91 SWAP2 0AE7 90 SWAP1 0AE8 60 PUSH1 0x00 0AEA 52 MSTORE 0AEB 60 PUSH1 0x20 0AED 60 PUSH1 0x00 0AEF 20 SHA3 0AF0 90 SWAP1 0AF1 5B JUMPDEST 0AF2 81 DUP2 0AF3 54 SLOAD 0AF4 81 DUP2 0AF5 52 MSTORE 0AF6 90 SWAP1 0AF7 60 PUSH1 0x01 0AF9 01 ADD 0AFA 90 SWAP1 0AFB 60 PUSH1 0x20 0AFD 01 ADD 0AFE 80 DUP1 0AFF 83 DUP4 0B00 11 GT 0B01 61 PUSH2 0x0af1 0B04 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0AE6 stack[-3] = stack[-3] + stack[-1] // @0AEA memory[0x00:0x20] = stack[-2] // @0AF5 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0AFA stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0AFD stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0af1, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0B05: // Incoming jump from 0x0B04, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0B04, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0B05 stack[-3] // @0B06 stack[-1] // } 0B05 82 DUP3 0B06 90 SWAP1 0B07 03 SUB 0B08 60 PUSH1 0x1f 0B0A 16 AND 0B0B 82 DUP3 0B0C 01 ADD 0B0D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0B0D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0B0D stack[-1] = stack[-3] // } // Block continues label_0B0E: // Incoming jump from 0x0AE2 // Incoming jump from 0x0AC7, if !stack[-1] // Incoming jump from 0x0B0D // Inputs[1] { @0B14 stack[-7] } 0B0E 5B JUMPDEST 0B0F 50 POP 0B10 50 POP 0B11 50 POP 0B12 50 POP 0B13 50 POP 0B14 81 DUP2 0B15 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0B16: // Incoming jump from 0x044B // Inputs[1] { @0B19 storage[0x13] } 0B16 5B JUMPDEST 0B17 60 PUSH1 0x13 0B19 54 SLOAD 0B1A 61 PUSH2 0x0100 0B1D 90 SWAP1 0B1E 04 DIV 0B1F 60 PUSH1 0xff 0B21 16 AND 0B22 15 ISZERO 0B23 61 PUSH2 0x0b3e 0B26 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b3e, if !(0xff & storage[0x13] / 0x0100) label_0B27: // Incoming jump from 0x0B26, if not !(0xff & storage[0x13] / 0x0100) // Inputs[1] { @0B29 memory[0x40:0x60] } 0B27 60 PUSH1 0x40 0B29 51 MLOAD 0B2A 62 PUSH3 0x461bcd 0B2E 60 PUSH1 0xe5 0B30 1B SHL 0B31 81 DUP2 0B32 52 MSTORE 0B33 60 PUSH1 0x04 0B35 01 ADD 0B36 61 PUSH2 0x06c4 0B39 90 SWAP1 0B3A 61 PUSH2 0x1f8e 0B3D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B32 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B39 stack[0] = 0x06c4 // @0B39 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1f8e, returns to 0x06C4 label_0B3E: // Incoming jump from 0x0B26, if !(0xff & storage[0x13] / 0x0100) // Inputs[2] // { // @0B41 storage[0x0c] // @0B45 stack[-1] // } 0B3E 5B JUMPDEST 0B3F 60 PUSH1 0x0c 0B41 54 SLOAD 0B42 61 PUSH2 0x0b53 0B45 82 DUP3 0B46 61 PUSH2 0x0b4d 0B49 61 PUSH2 0x07d4 0B4C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B41 stack[0] = storage[0x0c] // @0B42 stack[1] = 0x0b53 // @0B45 stack[2] = stack[-1] // @0B46 stack[3] = 0x0b4d // } // Block ends with call to 0x07d4, returns to 0x0B4D label_0B4D: // Incoming return from call to 0x07D4 at 0x0B4C // Incoming return from call to 0x07D4 at 0x111E // Incoming return from call to 0x07D4 at 0x0E05 // Inputs[2] // { // @0B4E stack[-2] // @0B4E stack[-1] // } 0B4D 5B JUMPDEST 0B4E 90 SWAP1 0B4F 61 PUSH2 0x14b0 0B52 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0B4E stack[-1] = stack[-2] // @0B4E stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x14b0 0B53 5B JUMPDEST 0B54 11 GT 0B55 15 ISZERO 0B56 61 PUSH2 0x0b71 0B59 57 *JUMPI 0B5A 60 PUSH1 0x40 0B5C 51 MLOAD 0B5D 62 PUSH3 0x461bcd 0B61 60 PUSH1 0xe5 0B63 1B SHL 0B64 81 DUP2 0B65 52 MSTORE 0B66 60 PUSH1 0x04 0B68 01 ADD 0B69 61 PUSH2 0x06c4 0B6C 90 SWAP1 0B6D 61 PUSH2 0x1fb6 0B70 56 *JUMP 0B71 5B JUMPDEST 0B72 60 PUSH1 0x10 0B74 54 SLOAD 0B75 81 DUP2 0B76 11 GT 0B77 15 ISZERO 0B78 61 PUSH2 0x0b93 0B7B 57 *JUMPI 0B7C 60 PUSH1 0x40 0B7E 51 MLOAD 0B7F 62 PUSH3 0x461bcd 0B83 60 PUSH1 0xe5 0B85 1B SHL 0B86 81 DUP2 0B87 52 MSTORE 0B88 60 PUSH1 0x04 0B8A 01 ADD 0B8B 61 PUSH2 0x06c4 0B8E 90 SWAP1 0B8F 61 PUSH2 0x21e8 0B92 56 *JUMP 0B93 5B JUMPDEST 0B94 60 PUSH1 0x11 0B96 54 SLOAD 0B97 34 CALLVALUE 0B98 90 SWAP1 0B99 61 PUSH2 0x0ba2 0B9C 90 SWAP1 0B9D 83 DUP4 0B9E 61 PUSH2 0x14bc 0BA1 56 *JUMP 0BA2 5B JUMPDEST 0BA3 11 GT 0BA4 15 ISZERO 0BA5 61 PUSH2 0x0bc0 0BA8 57 *JUMPI 0BA9 60 PUSH1 0x40 0BAB 51 MLOAD 0BAC 62 PUSH3 0x461bcd 0BB0 60 PUSH1 0xe5 0BB2 1B SHL 0BB3 81 DUP2 0BB4 52 MSTORE 0BB5 60 PUSH1 0x04 0BB7 01 ADD 0BB8 61 PUSH2 0x06c4 0BBB 90 SWAP1 0BBC 61 PUSH2 0x1fde 0BBF 56 *JUMP 0BC0 5B JUMPDEST 0BC1 60 PUSH1 0x0f 0BC3 54 SLOAD 0BC4 61 PUSH2 0x0bf3 0BC7 82 DUP3 0BC8 60 PUSH1 0x15 0BCA 60 PUSH1 0x00 0BCC 61 PUSH2 0x0bd3 0BCF 61 PUSH2 0x128c 0BD2 56 *JUMP 0BD3 5B JUMPDEST 0BD4 60 PUSH1 0x01 0BD6 60 PUSH1 0x01 0BD8 60 PUSH1 0xa0 0BDA 1B SHL 0BDB 03 SUB 0BDC 16 AND 0BDD 81 DUP2 0BDE 52 MSTORE 0BDF 60 PUSH1 0x20 0BE1 81 DUP2 0BE2 01 ADD 0BE3 91 SWAP2 0BE4 90 SWAP1 0BE5 91 SWAP2 0BE6 52 MSTORE 0BE7 60 PUSH1 0x40 0BE9 01 ADD 0BEA 60 PUSH1 0x00 0BEC 20 SHA3 0BED 54 SLOAD 0BEE 90 SWAP1 0BEF 61 PUSH2 0x14b0 0BF2 56 *JUMP 0BF3 5B JUMPDEST 0BF4 11 GT 0BF5 15 ISZERO 0BF6 61 PUSH2 0x0c11 0BF9 57 *JUMPI 0BFA 60 PUSH1 0x40 0BFC 51 MLOAD 0BFD 62 PUSH3 0x461bcd 0C01 60 PUSH1 0xe5 0C03 1B SHL 0C04 81 DUP2 0C05 52 MSTORE 0C06 60 PUSH1 0x04 0C08 01 ADD 0C09 61 PUSH2 0x06c4 0C0C 90 SWAP1 0C0D 61 PUSH2 0x2579 0C10 56 *JUMP 0C11 5B JUMPDEST 0C12 60 PUSH1 0x00 0C14 5B JUMPDEST 0C15 81 DUP2 0C16 81 DUP2 0C17 10 LT 0C18 15 ISZERO 0C19 61 PUSH2 0x0c57 0C1C 57 *JUMPI 0C1D 61 PUSH2 0x0c2f 0C20 61 PUSH2 0x0c27 0C23 61 PUSH2 0x128c 0C26 56 *JUMP 0C27 5B JUMPDEST 0C28 60 PUSH1 0x14 0C2A 54 SLOAD 0C2B 61 PUSH2 0x14c8 0C2E 56 *JUMP 0C2F 5B JUMPDEST 0C30 60 PUSH1 0x14 0C32 80 DUP1 0C33 54 SLOAD 0C34 90 SWAP1 0C35 60 PUSH1 0x00 0C37 61 PUSH2 0x0c3f 0C3A 83 DUP4 0C3B 61 PUSH2 0x26f3 0C3E 56 *JUMP 0C3F 5B JUMPDEST 0C40 91 SWAP2 0C41 90 SWAP1 0C42 50 POP 0C43 55 SSTORE 0C44 50 POP 0C45 80 DUP1 0C46 80 DUP1 0C47 61 PUSH2 0x0c4f 0C4A 90 SWAP1 0C4B 61 PUSH2 0x26f3 0C4E 56 *JUMP 0C4F 5B JUMPDEST 0C50 91 SWAP2 0C51 50 POP 0C52 50 POP 0C53 61 PUSH2 0x0c14 0C56 56 *JUMP 0C57 5B JUMPDEST 0C58 50 POP 0C59 80 DUP1 0C5A 60 PUSH1 0x15 0C5C 60 PUSH1 0x00 0C5E 61 PUSH2 0x0c65 0C61 61 PUSH2 0x128c 0C64 56 *JUMP 0C65 5B JUMPDEST 0C66 60 PUSH1 0x01 0C68 60 PUSH1 0x01 0C6A 60 PUSH1 0xa0 0C6C 1B SHL 0C6D 03 SUB 0C6E 16 AND 0C6F 60 PUSH1 0x01 0C71 60 PUSH1 0x01 0C73 60 PUSH1 0xa0 0C75 1B SHL 0C76 03 SUB 0C77 16 AND 0C78 81 DUP2 0C79 52 MSTORE 0C7A 60 PUSH1 0x20 0C7C 01 ADD 0C7D 90 SWAP1 0C7E 81 DUP2 0C7F 52 MSTORE 0C80 60 PUSH1 0x20 0C82 01 ADD 0C83 60 PUSH1 0x00 0C85 20 SHA3 0C86 60 PUSH1 0x00 0C88 82 DUP3 0C89 82 DUP3 0C8A 54 SLOAD 0C8B 61 PUSH2 0x0c94 0C8E 91 SWAP2 0C8F 90 SWAP1 0C90 61 PUSH2 0x262a 0C93 56 *JUMP 0C94 5B JUMPDEST 0C95 90 SWAP1 0C96 91 SWAP2 0C97 55 SSTORE 0C98 50 POP 0C99 50 POP 0C9A 50 POP 0C9B 56 *JUMP label_0C9C: // Incoming jump from 0x046B // Inputs[1] { @0CA4 stack[-1] } 0C9C 5B JUMPDEST 0C9D 60 PUSH1 0x60 0C9F 60 PUSH1 0x00 0CA1 61 PUSH2 0x0ca9 0CA4 83 DUP4 0CA5 61 PUSH2 0x0a44 0CA8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C9D stack[0] = 0x60 // @0C9F stack[1] = 0x00 // @0CA1 stack[2] = 0x0ca9 // @0CA4 stack[3] = stack[-1] // } // Block ends with call to 0x0a44, returns to 0x0CA9 label_0CA9: // Incoming return from call to 0x0A44 at 0x0CA8 // Inputs[2] // { // @0CAA stack[-2] // @0CAA stack[-1] // } 0CA9 5B JUMPDEST 0CAA 90 SWAP1 0CAB 50 POP 0CAC 60 PUSH1 0x00 0CAE 81 DUP2 0CAF 67 PUSH8 0xffffffffffffffff 0CB8 81 DUP2 0CB9 11 GT 0CBA 15 ISZERO 0CBB 61 PUSH2 0x0cd4 0CBE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0CAA stack[-2] = stack[-1] // @0CAC stack[-1] = 0x00 // @0CAE stack[0] = stack[-1] // } // Block ends with conditional jump to 0x0cd4, if !(stack[-1] > 0xffffffffffffffff) label_0CBF: // Incoming jump from 0x0CBE, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @0CD3 memory[0x00:0x24] } 0CBF 63 PUSH4 0x4e487b71 0CC4 60 PUSH1 0xe0 0CC6 1B SHL 0CC7 60 PUSH1 0x00 0CC9 52 MSTORE 0CCA 60 PUSH1 0x41 0CCC 60 PUSH1 0x04 0CCE 52 MSTORE 0CCF 60 PUSH1 0x24 0CD1 60 PUSH1 0x00 0CD3 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0CC9 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0CCE memory[0x04:0x24] = 0x41 // @0CD3 revert(memory[0x00:0x24]); // } // Block terminates label_0CD4: // Incoming jump from 0x0CBE, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0CD7 memory[0x40:0x60] // @0CD8 stack[-1] // } 0CD4 5B JUMPDEST 0CD5 60 PUSH1 0x40 0CD7 51 MLOAD 0CD8 90 SWAP1 0CD9 80 DUP1 0CDA 82 DUP3 0CDB 52 MSTORE 0CDC 80 DUP1 0CDD 60 PUSH1 0x20 0CDF 02 MUL 0CE0 60 PUSH1 0x20 0CE2 01 ADD 0CE3 82 DUP3 0CE4 01 ADD 0CE5 60 PUSH1 0x40 0CE7 52 MSTORE 0CE8 80 DUP1 0CE9 15 ISZERO 0CEA 61 PUSH2 0x0cfd 0CED 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0CD8 stack[-1] = memory[0x40:0x60] // @0CD8 stack[0] = stack[-1] // @0CDB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0CE7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0cfd, if !stack[-1] label_0CEE: // Incoming jump from 0x0CED, if not !stack[-1] // Inputs[6] // { // @0CEE stack[-2] // @0CF4 stack[-1] // @0CF7 msg.data.length // @0CF9 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0CFF stack[-3] // @0D04 stack[-4] // } 0CEE 81 DUP2 0CEF 60 PUSH1 0x20 0CF1 01 ADD 0CF2 60 PUSH1 0x20 0CF4 82 DUP3 0CF5 02 MUL 0CF6 80 DUP1 0CF7 36 CALLDATASIZE 0CF8 83 DUP4 0CF9 37 CALLDATACOPY 0CFA 01 ADD 0CFB 90 SWAP1 0CFC 50 POP 0CFD 5B JUMPDEST 0CFE 50 POP 0CFF 90 SWAP1 0D00 50 POP 0D01 60 PUSH1 0x00 0D03 5B JUMPDEST 0D04 82 DUP3 0D05 81 DUP2 0D06 10 LT 0D07 15 ISZERO 0D08 61 PUSH2 0x0d52 0D0B 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0CF9 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0CFF stack[-3] = stack[-2] // @0D01 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0d52, if !(0x00 < stack[-4]) label_0D0C: // Incoming jump from 0x0D0B, if not !(0x00 < stack[-4]) // Incoming jump from 0x0D0B, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x0D0B, if not !(0x00 < stack[-4]) // Inputs[2] // { // @0D0F stack[-5] // @0D10 stack[-1] // } 0D0C 61 PUSH2 0x0d15 0D0F 85 DUP6 0D10 82 DUP3 0D11 61 PUSH2 0x0820 0D14 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D0C stack[0] = 0x0d15 // @0D0F stack[1] = stack[-5] // @0D10 stack[2] = stack[-1] // } // Block ends with call to 0x0820, returns to 0x0D15 label_0D15: // Incoming return from call to 0x0820 at 0x0D14 // Inputs[3] // { // @0D16 stack[-3] // @0D17 stack[-2] // @0D19 memory[stack[-3]:stack[-3] + 0x20] // } 0D15 5B JUMPDEST 0D16 82 DUP3 0D17 82 DUP3 0D18 81 DUP2 0D19 51 MLOAD 0D1A 81 DUP2 0D1B 10 LT 0D1C 61 PUSH2 0x0d35 0D1F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0D16 stack[0] = stack[-3] // @0D17 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0d35, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_0D20: // Incoming jump from 0x0D1F, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[1] { @0D34 memory[0x00:0x24] } 0D20 63 PUSH4 0x4e487b71 0D25 60 PUSH1 0xe0 0D27 1B SHL 0D28 60 PUSH1 0x00 0D2A 52 MSTORE 0D2B 60 PUSH1 0x32 0D2D 60 PUSH1 0x04 0D2F 52 MSTORE 0D30 60 PUSH1 0x24 0D32 60 PUSH1 0x00 0D34 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0D2A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0D2F memory[0x04:0x24] = 0x32 // @0D34 revert(memory[0x00:0x24]); // } // Block terminates label_0D35: // Incoming jump from 0x0D1F, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0D38 stack[-1] // @0D3B stack[-2] // @0D40 stack[-3] // @0D41 stack[-4] // } 0D35 5B JUMPDEST 0D36 60 PUSH1 0x20 0D38 90 SWAP1 0D39 81 DUP2 0D3A 02 MUL 0D3B 91 SWAP2 0D3C 90 SWAP1 0D3D 91 SWAP2 0D3E 01 ADD 0D3F 01 ADD 0D40 52 MSTORE 0D41 80 DUP1 0D42 61 PUSH2 0x0d4a 0D45 81 DUP2 0D46 61 PUSH2 0x26f3 0D49 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0D40 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0D41 stack[-3] = stack[-4] // @0D42 stack[-2] = 0x0d4a // @0D45 stack[-1] = stack[-4] // } // Block ends with call to 0x26f3, returns to 0x0D4A label_0D4A: // Incoming return from call to 0x26F3 at 0x0D49 // Inputs[2] // { // @0D4B stack[-1] // @0D4B stack[-3] // } 0D4A 5B JUMPDEST 0D4B 91 SWAP2 0D4C 50 POP 0D4D 50 POP 0D4E 61 PUSH2 0x0d03 0D51 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D4B stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0d03 label_0D52: // Incoming jump from 0x0D0B, if !(0x00 < stack[-4]) // Incoming jump from 0x0D0B, if !(stack[-1] < stack[-3]) // Incoming jump from 0x0D0B, if !(0x00 < stack[-4]) // Inputs[3] // { // @0D54 stack[-6] // @0D54 stack[-2] // @0D55 stack[-5] // } 0D52 5B JUMPDEST 0D53 50 POP 0D54 93 SWAP4 0D55 92 SWAP3 0D56 50 POP 0D57 50 POP 0D58 50 POP 0D59 56 *JUMP // Stack delta = -5 // Outputs[1] { @0D54 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0D5A: // Incoming call from 0x048D, returns to 0x02B7 0D5A 5B JUMPDEST 0D5B 61 PUSH2 0x0d62 0D5E 61 PUSH2 0x128c 0D61 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D5B stack[0] = 0x0d62 } // Block ends with call to 0x128c, returns to 0x0D62 label_0D62: // Incoming return from call to 0x128C at 0x0D61 // Inputs[1] { @0D6B stack[-1] } 0D62 5B JUMPDEST 0D63 60 PUSH1 0x01 0D65 60 PUSH1 0x01 0D67 60 PUSH1 0xa0 0D69 1B SHL 0D6A 03 SUB 0D6B 16 AND 0D6C 61 PUSH2 0x0d73 0D6F 61 PUSH2 0x0db6 0D72 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0D6B stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0D6C stack[0] = 0x0d73 // } // Block ends with call to 0x0db6, returns to 0x0D73 label_0D73: // Incoming return from call to 0x0DB6 at 0x0D72 // Inputs[2] // { // @0D7C stack[-1] // @0D7D stack[-2] // } 0D73 5B JUMPDEST 0D74 60 PUSH1 0x01 0D76 60 PUSH1 0x01 0D78 60 PUSH1 0xa0 0D7A 1B SHL 0D7B 03 SUB 0D7C 16 AND 0D7D 14 EQ 0D7E 61 PUSH2 0x0d99 0D81 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0d99, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0D82: // Incoming jump from 0x0D81, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0D84 memory[0x40:0x60] } 0D82 60 PUSH1 0x40 0D84 51 MLOAD 0D85 62 PUSH3 0x461bcd 0D89 60 PUSH1 0xe5 0D8B 1B SHL 0D8C 81 DUP2 0D8D 52 MSTORE 0D8E 60 PUSH1 0x04 0D90 01 ADD 0D91 61 PUSH2 0x06c4 0D94 90 SWAP1 0D95 61 PUSH2 0x23ce 0D98 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D8D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D94 stack[0] = 0x06c4 // @0D94 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23ce, returns to 0x06C4 label_0D99: // Incoming jump from 0x0D81, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @0D9D storage[0x13] // @0DB5 stack[-1] // } 0D99 5B JUMPDEST 0D9A 60 PUSH1 0x13 0D9C 80 DUP1 0D9D 54 SLOAD 0D9E 61 PUSH2 0xff00 0DA1 19 NOT 0DA2 81 DUP2 0DA3 16 AND 0DA4 61 PUSH2 0x0100 0DA7 91 SWAP2 0DA8 82 DUP3 0DA9 90 SWAP1 0DAA 04 DIV 0DAB 60 PUSH1 0xff 0DAD 16 AND 0DAE 15 ISZERO 0DAF 90 SWAP1 0DB0 91 SWAP2 0DB1 02 MUL 0DB2 17 OR 0DB3 90 SWAP1 0DB4 55 SSTORE 0DB5 56 *JUMP // Stack delta = -1 // Outputs[1] { @0DB4 storage[0x13] = 0x0100 * !(0xff & storage[0x13] / 0x0100) | (storage[0x13] & ~0xff00) } // Block ends with unconditional jump to stack[-1] label_0DB6: // Incoming call from 0x0FAF, returns to 0x0FB0 // Incoming call from 0x0799, returns to 0x079A // Incoming call from 0x04A2, returns to 0x028A // Incoming call from 0x0D72, returns to 0x0D73 // Incoming call from 0x09CB, returns to 0x09CC // Incoming call from 0x0890, returns to 0x0891 // Incoming call from 0x08C0, returns to 0x08C1 // Incoming call from 0x11D9, returns to 0x11DA // Incoming call from 0x10C7, returns to 0x10C8 // Inputs[2] // { // @0DB9 storage[0x0b] // @0DC3 stack[-1] // } 0DB6 5B JUMPDEST 0DB7 60 PUSH1 0x0b 0DB9 54 SLOAD 0DBA 60 PUSH1 0x01 0DBC 60 PUSH1 0x01 0DBE 60 PUSH1 0xa0 0DC0 1B SHL 0DC1 03 SUB 0DC2 16 AND 0DC3 90 SWAP1 0DC4 56 *JUMP // Stack delta = +0 // Outputs[1] { @0DC3 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0b] } // Block ends with unconditional jump to stack[-1] label_0DC5: // Incoming call from 0x04B7, returns to 0x025D // Inputs[1] { @0DCB storage[0x01] } 0DC5 5B JUMPDEST 0DC6 60 PUSH1 0x60 0DC8 60 PUSH1 0x01 0DCA 80 DUP1 0DCB 54 SLOAD 0DCC 61 PUSH2 0x061a 0DCF 90 SWAP1 0DD0 61 PUSH2 0x26b8 0DD3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DC6 stack[0] = 0x60 // @0DC8 stack[1] = 0x01 // @0DCF stack[2] = 0x061a // @0DCF stack[3] = storage[0x01] // } // Block ends with call to 0x26b8, returns to 0x061A label_0DD4: // Incoming jump from 0x04CA // Inputs[1] { @0DD7 storage[0x13] } 0DD4 5B JUMPDEST 0DD5 60 PUSH1 0x13 0DD7 54 SLOAD 0DD8 60 PUSH1 0xff 0DDA 16 AND 0DDB 15 ISZERO 0DDC 61 PUSH2 0x0df7 0DDF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0df7, if !(0xff & storage[0x13]) label_0DE0: // Incoming jump from 0x0DDF, if not !(0xff & storage[0x13]) // Inputs[1] { @0DE2 memory[0x40:0x60] } 0DE0 60 PUSH1 0x40 0DE2 51 MLOAD 0DE3 62 PUSH3 0x461bcd 0DE7 60 PUSH1 0xe5 0DE9 1B SHL 0DEA 81 DUP2 0DEB 52 MSTORE 0DEC 60 PUSH1 0x04 0DEE 01 ADD 0DEF 61 PUSH2 0x06c4 0DF2 90 SWAP1 0DF3 61 PUSH2 0x21c3 0DF6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DEB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DF2 stack[0] = 0x06c4 // @0DF2 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x21c3, returns to 0x06C4 label_0DF7: // Incoming jump from 0x0DDF, if !(0xff & storage[0x13]) // Inputs[2] // { // @0DFA storage[0x0e] // @0DFE stack[-1] // } 0DF7 5B JUMPDEST 0DF8 60 PUSH1 0x0e 0DFA 54 SLOAD 0DFB 61 PUSH2 0x0e06 0DFE 82 DUP3 0DFF 61 PUSH2 0x0b4d 0E02 61 PUSH2 0x07d4 0E05 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DFA stack[0] = storage[0x0e] // @0DFB stack[1] = 0x0e06 // @0DFE stack[2] = stack[-1] // @0DFF stack[3] = 0x0b4d // } // Block ends with call to 0x07d4, returns to 0x0B4D 0E06 5B JUMPDEST 0E07 11 GT 0E08 15 ISZERO 0E09 61 PUSH2 0x0e24 0E0C 57 *JUMPI 0E0D 60 PUSH1 0x40 0E0F 51 MLOAD 0E10 62 PUSH3 0x461bcd 0E14 60 PUSH1 0xe5 0E16 1B SHL 0E17 81 DUP2 0E18 52 MSTORE 0E19 60 PUSH1 0x04 0E1B 01 ADD 0E1C 61 PUSH2 0x06c4 0E1F 90 SWAP1 0E20 61 PUSH2 0x25fd 0E23 56 *JUMP 0E24 5B JUMPDEST 0E25 60 PUSH1 0x10 0E27 54 SLOAD 0E28 81 DUP2 0E29 11 GT 0E2A 15 ISZERO 0E2B 61 PUSH2 0x0e46 0E2E 57 *JUMPI 0E2F 60 PUSH1 0x40 0E31 51 MLOAD 0E32 62 PUSH3 0x461bcd 0E36 60 PUSH1 0xe5 0E38 1B SHL 0E39 81 DUP2 0E3A 52 MSTORE 0E3B 60 PUSH1 0x04 0E3D 01 ADD 0E3E 61 PUSH2 0x06c4 0E41 90 SWAP1 0E42 61 PUSH2 0x21e8 0E45 56 *JUMP 0E46 5B JUMPDEST 0E47 60 PUSH1 0x12 0E49 54 SLOAD 0E4A 34 CALLVALUE 0E4B 90 SWAP1 0E4C 61 PUSH2 0x0e55 0E4F 90 SWAP1 0E50 83 DUP4 0E51 61 PUSH2 0x14bc 0E54 56 *JUMP 0E55 5B JUMPDEST 0E56 11 GT 0E57 15 ISZERO 0E58 61 PUSH2 0x0e73 0E5B 57 *JUMPI 0E5C 60 PUSH1 0x40 0E5E 51 MLOAD 0E5F 62 PUSH3 0x461bcd 0E63 60 PUSH1 0xe5 0E65 1B SHL 0E66 81 DUP2 0E67 52 MSTORE 0E68 60 PUSH1 0x04 0E6A 01 ADD 0E6B 61 PUSH2 0x06c4 0E6E 90 SWAP1 0E6F 61 PUSH2 0x1fde 0E72 56 *JUMP 0E73 5B JUMPDEST 0E74 60 PUSH1 0x00 0E76 5B JUMPDEST 0E77 81 DUP2 0E78 81 DUP2 0E79 10 LT 0E7A 15 ISZERO 0E7B 61 PUSH2 0x0a05 0E7E 57 *JUMPI 0E7F 61 PUSH2 0x0e89 0E82 61 PUSH2 0x0c27 0E85 61 PUSH2 0x128c 0E88 56 *JUMP 0E89 5B JUMPDEST 0E8A 60 PUSH1 0x14 0E8C 80 DUP1 0E8D 54 SLOAD 0E8E 90 SWAP1 0E8F 60 PUSH1 0x00 0E91 61 PUSH2 0x0e99 0E94 83 DUP4 0E95 61 PUSH2 0x26f3 0E98 56 *JUMP 0E99 5B JUMPDEST 0E9A 91 SWAP2 0E9B 90 SWAP1 0E9C 50 POP 0E9D 55 SSTORE 0E9E 50 POP 0E9F 80 DUP1 0EA0 80 DUP1 0EA1 61 PUSH2 0x0ea9 0EA4 90 SWAP1 0EA5 61 PUSH2 0x26f3 0EA8 56 *JUMP 0EA9 5B JUMPDEST 0EAA 91 SWAP2 0EAB 50 POP 0EAC 50 POP 0EAD 61 PUSH2 0x0e76 0EB0 56 *JUMP label_0EB1: // Incoming jump from 0x04EA 0EB1 5B JUMPDEST 0EB2 61 PUSH2 0x0eb9 0EB5 61 PUSH2 0x128c 0EB8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EB2 stack[0] = 0x0eb9 } // Block ends with call to 0x128c, returns to 0x0EB9 label_0EB9: // Incoming return from call to 0x128C at 0x0EB8 // Inputs[2] // { // @0EC2 stack[-1] // @0EC3 stack[-3] // } 0EB9 5B JUMPDEST 0EBA 60 PUSH1 0x01 0EBC 60 PUSH1 0x01 0EBE 60 PUSH1 0xa0 0EC0 1B SHL 0EC1 03 SUB 0EC2 16 AND 0EC3 82 DUP3 0EC4 60 PUSH1 0x01 0EC6 60 PUSH1 0x01 0EC8 60 PUSH1 0xa0 0ECA 1B SHL 0ECB 03 SUB 0ECC 16 AND 0ECD 14 EQ 0ECE 15 ISZERO 0ECF 61 PUSH2 0x0eea 0ED2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0eea, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0ED3: // Incoming jump from 0x0ED2, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0ED5 memory[0x40:0x60] } 0ED3 60 PUSH1 0x40 0ED5 51 MLOAD 0ED6 62 PUSH3 0x461bcd 0EDA 60 PUSH1 0xe5 0EDC 1B SHL 0EDD 81 DUP2 0EDE 52 MSTORE 0EDF 60 PUSH1 0x04 0EE1 01 ADD 0EE2 61 PUSH2 0x06c4 0EE5 90 SWAP1 0EE6 61 PUSH2 0x218c 0EE9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EDE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EE5 stack[0] = 0x06c4 // @0EE5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x218c, returns to 0x06C4 label_0EEA: // Incoming jump from 0x0ED2, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0EEB stack[-1] } 0EEA 5B JUMPDEST 0EEB 80 DUP1 0EEC 60 PUSH1 0x05 0EEE 60 PUSH1 0x00 0EF0 61 PUSH2 0x0ef7 0EF3 61 PUSH2 0x128c 0EF6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EEB stack[0] = stack[-1] // @0EEC stack[1] = 0x05 // @0EEE stack[2] = 0x00 // @0EF0 stack[3] = 0x0ef7 // } // Block ends with call to 0x128c, returns to 0x0EF7 label_0EF7: // Incoming return from call to 0x128C at 0x0EF6 // Inputs[8] // { // @0F00 stack[-1] // @0F03 stack[-2] // @0F0A stack[-3] // @0F17 memory[0x00:0x00 + 0x40 + stack[-2]] // @0F19 stack[-6] // @0F23 memory[0x00:0x40] // @0F25 storage[keccak256(memory[0x00:0x40])] // @0F2A stack[-4] // } 0EF7 5B JUMPDEST 0EF8 60 PUSH1 0x01 0EFA 60 PUSH1 0x01 0EFC 60 PUSH1 0xa0 0EFE 1B SHL 0EFF 03 SUB 0F00 90 SWAP1 0F01 81 DUP2 0F02 16 AND 0F03 82 DUP3 0F04 52 MSTORE 0F05 60 PUSH1 0x20 0F07 80 DUP1 0F08 83 DUP4 0F09 01 ADD 0F0A 93 SWAP4 0F0B 90 SWAP1 0F0C 93 SWAP4 0F0D 52 MSTORE 0F0E 60 PUSH1 0x40 0F10 91 SWAP2 0F11 82 DUP3 0F12 01 ADD 0F13 60 PUSH1 0x00 0F15 90 SWAP1 0F16 81 DUP2 0F17 20 SHA3 0F18 91 SWAP2 0F19 87 DUP8 0F1A 16 AND 0F1B 80 DUP1 0F1C 82 DUP3 0F1D 52 MSTORE 0F1E 91 SWAP2 0F1F 90 SWAP1 0F20 93 SWAP4 0F21 52 MSTORE 0F22 91 SWAP2 0F23 20 SHA3 0F24 80 DUP1 0F25 54 SLOAD 0F26 60 PUSH1 0xff 0F28 19 NOT 0F29 16 AND 0F2A 92 SWAP3 0F2B 15 ISZERO 0F2C 15 ISZERO 0F2D 92 SWAP3 0F2E 90 SWAP1 0F2F 92 SWAP3 0F30 17 OR 0F31 90 SWAP1 0F32 91 SWAP2 0F33 55 SSTORE 0F34 61 PUSH2 0x0f3b 0F37 61 PUSH2 0x128c 0F3A 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @0F04 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0F0D memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @0F1D memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0F21 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @0F32 stack[-4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0F33 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0F34 stack[-3] = 0x0f3b // } // Block ends with call to 0x128c, returns to 0x0F3B label_0F3B: // Incoming return from call to 0x128C at 0x0F3A // Inputs[3] // { // @0F44 stack[-1] // @0F66 stack[-3] // @0F69 memory[0x40:0x60] // } 0F3B 5B JUMPDEST 0F3C 60 PUSH1 0x01 0F3E 60 PUSH1 0x01 0F40 60 PUSH1 0xa0 0F42 1B SHL 0F43 03 SUB 0F44 16 AND 0F45 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0F66 83 DUP4 0F67 60 PUSH1 0x40 0F69 51 MLOAD 0F6A 61 PUSH2 0x0f73 0F6D 91 SWAP2 0F6E 90 SWAP1 0F6F 61 PUSH2 0x1f70 0F72 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0F44 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0F45 stack[0] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @0F6D stack[1] = 0x0f73 // @0F6E stack[3] = memory[0x40:0x60] // @0F6E stack[2] = stack[-3] // } // Block ends with call to 0x1f70, returns to 0x0F73 label_0F73: // Incoming return from call to 0x1F70 at 0x0F72 // Inputs[7] // { // @0F76 memory[0x40:0x60] // @0F78 stack[-1] // @0F7B stack[-2] // @0F7B stack[-3] // @0F7B stack[-4] // @0F7B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0F7E stack[-7] // } 0F73 5B JUMPDEST 0F74 60 PUSH1 0x40 0F76 51 MLOAD 0F77 80 DUP1 0F78 91 SWAP2 0F79 03 SUB 0F7A 90 SWAP1 0F7B A3 LOG3 0F7C 50 POP 0F7D 50 POP 0F7E 56 *JUMP // Stack delta = -7 // Outputs[1] { @0F7B 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[-7] label_0F7F: // Incoming jump from 0x050A // Inputs[4] // { // @0F87 stack[-1] // @0F8D memory[0x00:0x40] // @0F8E storage[keccak256(memory[0x00:0x40])] // @0F8F stack[-2] // } 0F7F 5B JUMPDEST 0F80 60 PUSH1 0x15 0F82 60 PUSH1 0x20 0F84 52 MSTORE 0F85 60 PUSH1 0x00 0F87 90 SWAP1 0F88 81 DUP2 0F89 52 MSTORE 0F8A 60 PUSH1 0x40 0F8C 90 SWAP1 0F8D 20 SHA3 0F8E 54 SLOAD 0F8F 81 DUP2 0F90 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0F84 memory[0x20:0x40] = 0x15 // @0F89 memory[0x00:0x20] = stack[-1] // @0F8E stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0F91: // Incoming call from 0x051F, returns to 0x02E3 // Inputs[2] // { // @0F94 storage[0x0d] // @0F95 stack[-1] // } 0F91 5B JUMPDEST 0F92 60 PUSH1 0x0d 0F94 54 SLOAD 0F95 81 DUP2 0F96 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F94 stack[0] = storage[0x0d] } // Block ends with unconditional jump to stack[-1] label_0F97: // Incoming call from 0x0534, returns to 0x02B7 0F97 5B JUMPDEST 0F98 61 PUSH2 0x0f9f 0F9B 61 PUSH2 0x128c 0F9E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F98 stack[0] = 0x0f9f } // Block ends with call to 0x128c, returns to 0x0F9F label_0F9F: // Incoming return from call to 0x128C at 0x0F9E // Inputs[1] { @0FA8 stack[-1] } 0F9F 5B JUMPDEST 0FA0 60 PUSH1 0x01 0FA2 60 PUSH1 0x01 0FA4 60 PUSH1 0xa0 0FA6 1B SHL 0FA7 03 SUB 0FA8 16 AND 0FA9 61 PUSH2 0x0fb0 0FAC 61 PUSH2 0x0db6 0FAF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0FA8 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0FA9 stack[0] = 0x0fb0 // } // Block ends with call to 0x0db6, returns to 0x0FB0 label_0FB0: // Incoming return from call to 0x0DB6 at 0x0FAF // Inputs[2] // { // @0FB9 stack[-1] // @0FBA stack[-2] // } 0FB0 5B JUMPDEST 0FB1 60 PUSH1 0x01 0FB3 60 PUSH1 0x01 0FB5 60 PUSH1 0xa0 0FB7 1B SHL 0FB8 03 SUB 0FB9 16 AND 0FBA 14 EQ 0FBB 61 PUSH2 0x0fd6 0FBE 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0fd6, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0FBF: // Incoming jump from 0x0FBE, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0FC1 memory[0x40:0x60] } 0FBF 60 PUSH1 0x40 0FC1 51 MLOAD 0FC2 62 PUSH3 0x461bcd 0FC6 60 PUSH1 0xe5 0FC8 1B SHL 0FC9 81 DUP2 0FCA 52 MSTORE 0FCB 60 PUSH1 0x04 0FCD 01 ADD 0FCE 61 PUSH2 0x06c4 0FD1 90 SWAP1 0FD2 61 PUSH2 0x23ce 0FD5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FCA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FD1 stack[0] = 0x06c4 // @0FD1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23ce, returns to 0x06C4 label_0FD6: // Incoming jump from 0x0FBE, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @0FDA storage[0x13] // @0FEC stack[-1] // } 0FD6 5B JUMPDEST 0FD7 60 PUSH1 0x13 0FD9 80 DUP1 0FDA 54 SLOAD 0FDB 60 PUSH1 0xff 0FDD 19 NOT 0FDE 61 PUSH2 0xff00 0FE1 19 NOT 0FE2 90 SWAP1 0FE3 91 SWAP2 0FE4 16 AND 0FE5 61 PUSH2 0x0100 0FE8 17 OR 0FE9 16 AND 0FEA 90 SWAP1 0FEB 55 SSTORE 0FEC 56 *JUMP // Stack delta = -1 // Outputs[1] { @0FEB storage[0x13] = (0x0100 | (storage[0x13] & ~0xff00)) & ~0xff } // Block ends with unconditional jump to stack[-1] label_0FED: // Incoming jump from 0x0957 // Incoming jump from 0x0554 0FED 5B JUMPDEST 0FEE 61 PUSH2 0x0ffe 0FF1 61 PUSH2 0x0ff8 0FF4 61 PUSH2 0x128c 0FF7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FEE stack[0] = 0x0ffe // @0FF1 stack[1] = 0x0ff8 // } // Block ends with call to 0x128c, returns to 0x0FF8 label_0FF8: // Incoming return from call to 0x128C at 0x0FF7 // Inputs[1] { @0FF9 stack[-4] } 0FF8 5B JUMPDEST 0FF9 83 DUP4 0FFA 61 PUSH2 0x12fe 0FFD 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FF9 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x12fe 0FFE 5B JUMPDEST 0FFF 61 PUSH2 0x101a 1002 57 *JUMPI 1003 60 PUSH1 0x40 1005 51 MLOAD 1006 62 PUSH3 0x461bcd 100A 60 PUSH1 0xe5 100C 1B SHL 100D 81 DUP2 100E 52 MSTORE 100F 60 PUSH1 0x04 1011 01 ADD 1012 61 PUSH2 0x06c4 1015 90 SWAP1 1016 61 PUSH2 0x24dc 1019 56 *JUMP 101A 5B JUMPDEST 101B 61 PUSH2 0x1026 101E 84 DUP5 101F 84 DUP5 1020 84 DUP5 1021 84 DUP5 1022 61 PUSH2 0x14e2 1025 56 *JUMP label_1026: // Incoming jump from 0x26AF, if !(stack[-1] > stack[-4]) // Inputs[1] { @102B stack[-5] } 1026 5B JUMPDEST 1027 50 POP 1028 50 POP 1029 50 POP 102A 50 POP 102B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_102C: // Incoming jump from 0x0574 // Inputs[1] { @1032 stack[-1] } 102C 5B JUMPDEST 102D 60 PUSH1 0x60 102F 61 PUSH2 0x1037 1032 82 DUP3 1033 61 PUSH2 0x126f 1036 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @102D stack[0] = 0x60 // @102F stack[1] = 0x1037 // @1032 stack[2] = stack[-1] // } // Block ends with call to 0x126f, returns to 0x1037 label_1037: // Incoming return from call to 0x126F at 0x1036 // Inputs[1] { @103B stack[-1] } 1037 5B JUMPDEST 1038 61 PUSH2 0x1053 103B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1053, if stack[-1] label_103C: // Incoming jump from 0x103B, if not stack[-1] // Inputs[1] { @103E memory[0x40:0x60] } 103C 60 PUSH1 0x40 103E 51 MLOAD 103F 62 PUSH3 0x461bcd 1043 60 PUSH1 0xe5 1045 1B SHL 1046 81 DUP2 1047 52 MSTORE 1048 60 PUSH1 0x04 104A 01 ADD 104B 61 PUSH2 0x06c4 104E 90 SWAP1 104F 61 PUSH2 0x244c 1052 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1047 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @104E stack[0] = 0x06c4 // @104E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x244c, returns to 0x06C4 label_1053: // Incoming jump from 0x103B, if stack[-1] 1053 5B JUMPDEST 1054 60 PUSH1 0x00 1056 61 PUSH2 0x105d 1059 61 PUSH2 0x1515 105C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1054 stack[0] = 0x00 // @1056 stack[1] = 0x105d // } // Block ends with unconditional jump to 0x1515 105D 5B JUMPDEST 105E 90 SWAP1 105F 50 POP 1060 60 PUSH1 0x00 1062 81 DUP2 1063 51 MLOAD 1064 11 GT 1065 61 PUSH2 0x107d 1068 57 *JUMPI 1069 60 PUSH1 0x40 106B 51 MLOAD 106C 80 DUP1 106D 60 PUSH1 0x20 106F 01 ADD 1070 60 PUSH1 0x40 1072 52 MSTORE 1073 80 DUP1 1074 60 PUSH1 0x00 1076 81 DUP2 1077 52 MSTORE 1078 50 POP 1079 61 PUSH2 0x10a8 107C 56 *JUMP 107D 5B JUMPDEST 107E 80 DUP1 107F 61 PUSH2 0x1087 1082 84 DUP5 1083 61 PUSH2 0x1524 1086 56 *JUMP 1087 5B JUMPDEST 1088 60 PUSH1 0x40 108A 51 MLOAD 108B 60 PUSH1 0x20 108D 01 ADD 108E 61 PUSH2 0x1098 1091 92 SWAP3 1092 91 SWAP2 1093 90 SWAP1 1094 61 PUSH2 0x1ea9 1097 56 *JUMP 1098 5B JUMPDEST 1099 60 PUSH1 0x40 109B 51 MLOAD 109C 60 PUSH1 0x20 109E 81 DUP2 109F 83 DUP4 10A0 03 SUB 10A1 03 SUB 10A2 81 DUP2 10A3 52 MSTORE 10A4 90 SWAP1 10A5 60 PUSH1 0x40 10A7 52 MSTORE label_10A8: // Incoming return from call to 0x1E7D at 0x1F8D // Incoming return from call to 0x1C6D at 0x1C9D // Incoming return from call to 0x2764 at 0x1E02 // Incoming return from call to 0x262A at 0x14BB // Inputs[3] // { // @10A9 stack[-1] // @10A9 stack[-5] // @10AA stack[-4] // } 10A8 5B JUMPDEST 10A9 93 SWAP4 10AA 92 SWAP3 10AB 50 POP 10AC 50 POP 10AD 50 POP 10AE 56 *JUMP // Stack delta = -4 // Outputs[1] { @10A9 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_10AF: // Incoming jump from 0x0594 10AF 5B JUMPDEST 10B0 61 PUSH2 0x10b7 10B3 61 PUSH2 0x128c 10B6 56 *JUMP // Stack delta = +1 // Outputs[1] { @10B0 stack[0] = 0x10b7 } // Block ends with call to 0x128c, returns to 0x10B7 label_10B7: // Incoming return from call to 0x128C at 0x10B6 // Inputs[1] { @10C0 stack[-1] } 10B7 5B JUMPDEST 10B8 60 PUSH1 0x01 10BA 60 PUSH1 0x01 10BC 60 PUSH1 0xa0 10BE 1B SHL 10BF 03 SUB 10C0 16 AND 10C1 61 PUSH2 0x10c8 10C4 61 PUSH2 0x0db6 10C7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @10C0 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @10C1 stack[0] = 0x10c8 // } // Block ends with call to 0x0db6, returns to 0x10C8 label_10C8: // Incoming return from call to 0x0DB6 at 0x10C7 // Inputs[2] // { // @10D1 stack[-1] // @10D2 stack[-2] // } 10C8 5B JUMPDEST 10C9 60 PUSH1 0x01 10CB 60 PUSH1 0x01 10CD 60 PUSH1 0xa0 10CF 1B SHL 10D0 03 SUB 10D1 16 AND 10D2 14 EQ 10D3 61 PUSH2 0x10ee 10D6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x10ee, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_10D7: // Incoming jump from 0x10D6, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @10D9 memory[0x40:0x60] } 10D7 60 PUSH1 0x40 10D9 51 MLOAD 10DA 62 PUSH3 0x461bcd 10DE 60 PUSH1 0xe5 10E0 1B SHL 10E1 81 DUP2 10E2 52 MSTORE 10E3 60 PUSH1 0x04 10E5 01 ADD 10E6 61 PUSH2 0x06c4 10E9 90 SWAP1 10EA 61 PUSH2 0x23ce 10ED 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @10E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10E9 stack[0] = 0x06c4 // @10E9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23ce, returns to 0x06C4 label_10EE: // Incoming jump from 0x10D6, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @10F1 storage[0x0d] // @10F2 stack[-1] // } 10EE 5B JUMPDEST 10EF 60 PUSH1 0x0d 10F1 54 SLOAD 10F2 81 DUP2 10F3 11 GT 10F4 15 ISZERO 10F5 61 PUSH2 0x1110 10F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1110, if !(stack[-1] > storage[0x0d]) label_10F9: // Incoming jump from 0x10F8, if not !(stack[-1] > storage[0x0d]) // Inputs[1] { @10FB memory[0x40:0x60] } 10F9 60 PUSH1 0x40 10FB 51 MLOAD 10FC 62 PUSH3 0x461bcd 1100 60 PUSH1 0xe5 1102 1B SHL 1103 81 DUP2 1104 52 MSTORE 1105 60 PUSH1 0x04 1107 01 ADD 1108 61 PUSH2 0x06c4 110B 90 SWAP1 110C 61 PUSH2 0x25d5 110F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1104 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @110B stack[0] = 0x06c4 // @110B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x25d5, returns to 0x06C4 label_1110: // Incoming jump from 0x10F8, if !(stack[-1] > storage[0x0d]) // Inputs[2] // { // @1113 storage[0x0e] // @1117 stack[-1] // } 1110 5B JUMPDEST 1111 60 PUSH1 0x0e 1113 54 SLOAD 1114 61 PUSH2 0x111f 1117 82 DUP3 1118 61 PUSH2 0x0b4d 111B 61 PUSH2 0x07d4 111E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1113 stack[0] = storage[0x0e] // @1114 stack[1] = 0x111f // @1117 stack[2] = stack[-1] // @1118 stack[3] = 0x0b4d // } // Block ends with call to 0x07d4, returns to 0x0B4D 111F 5B JUMPDEST 1120 11 GT 1121 15 ISZERO 1122 61 PUSH2 0x113d 1125 57 *JUMPI 1126 60 PUSH1 0x40 1128 51 MLOAD 1129 62 PUSH3 0x461bcd 112D 60 PUSH1 0xe5 112F 1B SHL 1130 81 DUP2 1131 52 MSTORE 1132 60 PUSH1 0x04 1134 01 ADD 1135 61 PUSH2 0x06c4 1138 90 SWAP1 1139 61 PUSH2 0x2122 113C 56 *JUMP 113D 5B JUMPDEST 113E 80 DUP1 113F 60 PUSH1 0x0d 1141 60 PUSH1 0x00 1143 82 DUP3 1144 82 DUP3 1145 54 SLOAD 1146 61 PUSH2 0x114f 1149 91 SWAP2 114A 90 SWAP1 114B 61 PUSH2 0x2675 114E 56 *JUMP 114F 5B JUMPDEST 1150 90 SWAP1 1151 91 SWAP2 1152 55 SSTORE 1153 50 POP 1154 60 PUSH1 0x00 1156 90 SWAP1 1157 50 POP 1158 5B JUMPDEST 1159 81 DUP2 115A 81 DUP2 115B 10 LT 115C 15 ISZERO 115D 61 PUSH2 0x0a05 1160 57 *JUMPI 1161 61 PUSH2 0x116b 1164 61 PUSH2 0x0c27 1167 61 PUSH2 0x128c 116A 56 *JUMP 116B 5B JUMPDEST 116C 60 PUSH1 0x14 116E 80 DUP1 116F 54 SLOAD 1170 90 SWAP1 1171 60 PUSH1 0x00 1173 61 PUSH2 0x117b 1176 83 DUP4 1177 61 PUSH2 0x26f3 117A 56 *JUMP 117B 5B JUMPDEST 117C 91 SWAP2 117D 90 SWAP1 117E 50 POP 117F 55 SSTORE 1180 50 POP 1181 80 DUP1 1182 80 DUP1 1183 61 PUSH2 0x118b 1186 90 SWAP1 1187 61 PUSH2 0x26f3 118A 56 *JUMP 118B 5B JUMPDEST 118C 91 SWAP2 118D 50 POP 118E 50 POP 118F 61 PUSH2 0x1158 1192 56 *JUMP label_1193: // Incoming jump from 0x05B4 // Inputs[6] // { // @119C stack[-2] // @11AF memory[0x00:0x40] // @11B0 stack[-1] // @11BA memory[0x00:0x40] // @11BB storage[keccak256(memory[0x00:0x40])] // @11BF stack[-3] // } 1193 5B JUMPDEST 1194 60 PUSH1 0x01 1196 60 PUSH1 0x01 1198 60 PUSH1 0xa0 119A 1B SHL 119B 03 SUB 119C 91 SWAP2 119D 82 DUP3 119E 16 AND 119F 60 PUSH1 0x00 11A1 90 SWAP1 11A2 81 DUP2 11A3 52 MSTORE 11A4 60 PUSH1 0x05 11A6 60 PUSH1 0x20 11A8 90 SWAP1 11A9 81 DUP2 11AA 52 MSTORE 11AB 60 PUSH1 0x40 11AD 80 DUP1 11AE 83 DUP4 11AF 20 SHA3 11B0 93 SWAP4 11B1 90 SWAP1 11B2 94 SWAP5 11B3 16 AND 11B4 82 DUP3 11B5 52 MSTORE 11B6 91 SWAP2 11B7 90 SWAP1 11B8 91 SWAP2 11B9 52 MSTORE 11BA 20 SHA3 11BB 54 SLOAD 11BC 60 PUSH1 0xff 11BE 16 AND 11BF 90 SWAP1 11C0 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @11A3 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @11AA memory[0x20:0x40] = 0x05 // @11B5 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @11B9 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @11BF stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_11C1: // Incoming jump from 0x05D4 11C1 5B JUMPDEST 11C2 61 PUSH2 0x11c9 11C5 61 PUSH2 0x128c 11C8 56 *JUMP // Stack delta = +1 // Outputs[1] { @11C2 stack[0] = 0x11c9 } // Block ends with call to 0x128c, returns to 0x11C9 label_11C9: // Incoming return from call to 0x128C at 0x11C8 // Inputs[1] { @11D2 stack[-1] } 11C9 5B JUMPDEST 11CA 60 PUSH1 0x01 11CC 60 PUSH1 0x01 11CE 60 PUSH1 0xa0 11D0 1B SHL 11D1 03 SUB 11D2 16 AND 11D3 61 PUSH2 0x11da 11D6 61 PUSH2 0x0db6 11D9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @11D2 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @11D3 stack[0] = 0x11da // } // Block ends with call to 0x0db6, returns to 0x11DA label_11DA: // Incoming return from call to 0x0DB6 at 0x11D9 // Inputs[2] // { // @11E3 stack[-1] // @11E4 stack[-2] // } 11DA 5B JUMPDEST 11DB 60 PUSH1 0x01 11DD 60 PUSH1 0x01 11DF 60 PUSH1 0xa0 11E1 1B SHL 11E2 03 SUB 11E3 16 AND 11E4 14 EQ 11E5 61 PUSH2 0x1200 11E8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1200, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_11E9: // Incoming jump from 0x11E8, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @11EB memory[0x40:0x60] } 11E9 60 PUSH1 0x40 11EB 51 MLOAD 11EC 62 PUSH3 0x461bcd 11F0 60 PUSH1 0xe5 11F2 1B SHL 11F3 81 DUP2 11F4 52 MSTORE 11F5 60 PUSH1 0x04 11F7 01 ADD 11F8 61 PUSH2 0x06c4 11FB 90 SWAP1 11FC 61 PUSH2 0x23ce 11FF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @11F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11FB stack[0] = 0x06c4 // @11FB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23ce, returns to 0x06C4 label_1200: // Incoming jump from 0x11E8, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1209 stack[-1] } 1200 5B JUMPDEST 1201 60 PUSH1 0x01 1203 60 PUSH1 0x01 1205 60 PUSH1 0xa0 1207 1B SHL 1208 03 SUB 1209 81 DUP2 120A 16 AND 120B 61 PUSH2 0x1226 120E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1226, if stack[-1] & (0x01 << 0xa0) - 0x01 label_120F: // Incoming jump from 0x120E, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1211 memory[0x40:0x60] } 120F 60 PUSH1 0x40 1211 51 MLOAD 1212 62 PUSH3 0x461bcd 1216 60 PUSH1 0xe5 1218 1B SHL 1219 81 DUP2 121A 52 MSTORE 121B 60 PUSH1 0x04 121D 01 ADD 121E 61 PUSH2 0x06c4 1221 90 SWAP1 1222 61 PUSH2 0x20a5 1225 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @121A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1221 stack[0] = 0x06c4 // @1221 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x20a5, returns to 0x06C4 label_1226: // Incoming jump from 0x120E, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @122A stack[-1] } 1226 5B JUMPDEST 1227 61 PUSH2 0x093a 122A 81 DUP2 122B 61 PUSH2 0x163f 122E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1227 stack[0] = 0x093a // @122A stack[1] = stack[-1] // } // Block ends with call to 0x163f, returns to 0x093A label_122F: // Incoming jump from 0x0602 // Inputs[1] { @123B stack[-1] } 122F 5B JUMPDEST 1230 60 PUSH1 0x00 1232 60 PUSH1 0x01 1234 60 PUSH1 0x01 1236 60 PUSH1 0xe0 1238 1B SHL 1239 03 SUB 123A 19 NOT 123B 82 DUP3 123C 16 AND 123D 63 PUSH4 0x80ac58cd 1242 60 PUSH1 0xe0 1244 1B SHL 1245 14 EQ 1246 80 DUP1 1247 61 PUSH2 0x1260 124A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1230 stack[0] = 0x00 // @1245 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x1260, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_124B: // Incoming jump from 0x124A, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1255 stack[-3] } 124B 50 POP 124C 60 PUSH1 0x01 124E 60 PUSH1 0x01 1250 60 PUSH1 0xe0 1252 1B SHL 1253 03 SUB 1254 19 NOT 1255 82 DUP3 1256 16 AND 1257 63 PUSH4 0x5b5e139f 125C 60 PUSH1 0xe0 125E 1B SHL 125F 14 EQ 1260 5B JUMPDEST 1261 80 DUP1 1262 61 PUSH2 0x0603 1265 57 *JUMPI // Stack delta = +0 // Outputs[1] { @125F stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0603, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_1266: // Incoming jump from 0x1265, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1265, if not stack[-1] // Inputs[1] { @126A stack[-3] } 1266 50 POP 1267 61 PUSH2 0x0603 126A 82 DUP3 126B 61 PUSH2 0x1691 126E 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1267 stack[-1] = 0x0603 // @126A stack[0] = stack[-3] // } // Block ends with call to 0x1691, returns to 0x0603 label_126F: // Incoming call from 0x06A7, returns to 0x06A8 // Incoming call from 0x1308, returns to 0x1309 // Incoming call from 0x1036, returns to 0x1037 // Inputs[4] // { // @1272 stack[-1] // @127D memory[0x00:0x40] // @127E storage[keccak256(memory[0x00:0x40])] // @128A stack[-2] // } 126F 5B JUMPDEST 1270 60 PUSH1 0x00 1272 90 SWAP1 1273 81 DUP2 1274 52 MSTORE 1275 60 PUSH1 0x02 1277 60 PUSH1 0x20 1279 52 MSTORE 127A 60 PUSH1 0x40 127C 90 SWAP1 127D 20 SHA3 127E 54 SLOAD 127F 60 PUSH1 0x01 1281 60 PUSH1 0x01 1283 60 PUSH1 0xa0 1285 1B SHL 1286 03 SUB 1287 16 AND 1288 15 ISZERO 1289 15 ISZERO 128A 90 SWAP1 128B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1274 memory[0x00:0x20] = stack[-1] // @1279 memory[0x20:0x40] = 0x02 // @128A stack[-2] = !!((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-2] label_128C: // Incoming call from 0x0F3A, returns to 0x0F3B // Incoming call from 0x087F, returns to 0x0880 // Incoming call from 0x10B6, returns to 0x10B7 // Incoming call from 0x09BA, returns to 0x09BB // Incoming call from 0x11C8, returns to 0x11C9 // Incoming call from 0x0F9E, returns to 0x0F9F // Incoming call from 0x07E4, returns to 0x07E5 // Incoming call from 0x0EB8, returns to 0x0EB9 // Incoming call from 0x0EF6, returns to 0x0EF7 // Incoming call from 0x0D61, returns to 0x0D62 // Incoming call from 0x0788, returns to 0x0789 // Incoming call from 0x0FF7, returns to 0x0FF8 // Inputs[2] // { // @128D msg.sender // @128E stack[-1] // } 128C 5B JUMPDEST 128D 33 CALLER 128E 90 SWAP1 128F 56 *JUMP // Stack delta = +0 // Outputs[1] { @128E stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] 1290 5B JUMPDEST 1291 60 PUSH1 0x00 1293 81 DUP2 1294 81 DUP2 1295 52 MSTORE 1296 60 PUSH1 0x04 1298 60 PUSH1 0x20 129A 52 MSTORE 129B 60 PUSH1 0x40 129D 90 SWAP1 129E 20 SHA3 129F 80 DUP1 12A0 54 SLOAD 12A1 60 PUSH1 0x01 12A3 60 PUSH1 0x01 12A5 60 PUSH1 0xa0 12A7 1B SHL 12A8 03 SUB 12A9 19 NOT 12AA 16 AND 12AB 60 PUSH1 0x01 12AD 60 PUSH1 0x01 12AF 60 PUSH1 0xa0 12B1 1B SHL 12B2 03 SUB 12B3 84 DUP5 12B4 16 AND 12B5 90 SWAP1 12B6 81 DUP2 12B7 17 OR 12B8 90 SWAP1 12B9 91 SWAP2 12BA 55 SSTORE 12BB 81 DUP2 12BC 90 SWAP1 12BD 61 PUSH2 0x12c5 12C0 82 DUP3 12C1 61 PUSH2 0x0a09 12C4 56 *JUMP 12C5 5B JUMPDEST 12C6 60 PUSH1 0x01 12C8 60 PUSH1 0x01 12CA 60 PUSH1 0xa0 12CC 1B SHL 12CD 03 SUB 12CE 16 AND 12CF 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 12F0 60 PUSH1 0x40 12F2 51 MLOAD 12F3 60 PUSH1 0x40 12F5 51 MLOAD 12F6 80 DUP1 12F7 91 SWAP2 12F8 03 SUB 12F9 90 SWAP1 12FA A4 LOG4 12FB 50 POP 12FC 50 POP 12FD 56 *JUMP label_12FE: // Incoming jump from 0x07EA // Incoming jump from 0x0FFD // Inputs[1] { @1304 stack[-1] } 12FE 5B JUMPDEST 12FF 60 PUSH1 0x00 1301 61 PUSH2 0x1309 1304 82 DUP3 1305 61 PUSH2 0x126f 1308 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12FF stack[0] = 0x00 // @1301 stack[1] = 0x1309 // @1304 stack[2] = stack[-1] // } // Block ends with call to 0x126f, returns to 0x1309 label_1309: // Incoming return from call to 0x126F at 0x1308 // Inputs[1] { @130D stack[-1] } 1309 5B JUMPDEST 130A 61 PUSH2 0x1325 130D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1325, if stack[-1] label_130E: // Incoming jump from 0x130D, if not stack[-1] // Inputs[1] { @1310 memory[0x40:0x60] } 130E 60 PUSH1 0x40 1310 51 MLOAD 1311 62 PUSH3 0x461bcd 1315 60 PUSH1 0xe5 1317 1B SHL 1318 81 DUP2 1319 52 MSTORE 131A 60 PUSH1 0x04 131C 01 ADD 131D 61 PUSH2 0x06c4 1320 90 SWAP1 1321 61 PUSH2 0x2211 1324 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1319 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1320 stack[0] = 0x06c4 // @1320 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2211, returns to 0x06C4 label_1325: // Incoming jump from 0x130D, if stack[-1] // Inputs[1] { @132B stack[-2] } 1325 5B JUMPDEST 1326 60 PUSH1 0x00 1328 61 PUSH2 0x1330 132B 83 DUP4 132C 61 PUSH2 0x0a09 132F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1326 stack[0] = 0x00 // @1328 stack[1] = 0x1330 // @132B stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x0a09 1330 5B JUMPDEST 1331 90 SWAP1 1332 50 POP 1333 80 DUP1 1334 60 PUSH1 0x01 1336 60 PUSH1 0x01 1338 60 PUSH1 0xa0 133A 1B SHL 133B 03 SUB 133C 16 AND 133D 84 DUP5 133E 60 PUSH1 0x01 1340 60 PUSH1 0x01 1342 60 PUSH1 0xa0 1344 1B SHL 1345 03 SUB 1346 16 AND 1347 14 EQ 1348 80 DUP1 1349 61 PUSH2 0x136b 134C 57 *JUMPI 134D 50 POP 134E 83 DUP4 134F 60 PUSH1 0x01 1351 60 PUSH1 0x01 1353 60 PUSH1 0xa0 1355 1B SHL 1356 03 SUB 1357 16 AND 1358 61 PUSH2 0x1360 135B 84 DUP5 135C 61 PUSH2 0x069d 135F 56 *JUMP 1360 5B JUMPDEST 1361 60 PUSH1 0x01 1363 60 PUSH1 0x01 1365 60 PUSH1 0xa0 1367 1B SHL 1368 03 SUB 1369 16 AND 136A 14 EQ 136B 5B JUMPDEST 136C 80 DUP1 136D 61 PUSH2 0x137b 1370 57 *JUMPI 1371 50 POP 1372 61 PUSH2 0x137b 1375 81 DUP2 1376 85 DUP6 1377 61 PUSH2 0x1193 137A 56 *JUMP label_137B: // Incoming return from call to 0x1BFD at 0x1E64 // Inputs[3] // { // @137C stack[-1] // @137C stack[-6] // @137D stack[-5] // } 137B 5B JUMPDEST 137C 94 SWAP5 137D 93 SWAP4 137E 50 POP 137F 50 POP 1380 50 POP 1381 50 POP 1382 56 *JUMP // Stack delta = -5 // Outputs[1] { @137C stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 1383 5B JUMPDEST 1384 82 DUP3 1385 60 PUSH1 0x01 1387 60 PUSH1 0x01 1389 60 PUSH1 0xa0 138B 1B SHL 138C 03 SUB 138D 16 AND 138E 61 PUSH2 0x1396 1391 82 DUP3 1392 61 PUSH2 0x0a09 1395 56 *JUMP 1396 5B JUMPDEST 1397 60 PUSH1 0x01 1399 60 PUSH1 0x01 139B 60 PUSH1 0xa0 139D 1B SHL 139E 03 SUB 139F 16 AND 13A0 14 EQ 13A1 61 PUSH2 0x13bc 13A4 57 *JUMPI 13A5 60 PUSH1 0x40 13A7 51 MLOAD 13A8 62 PUSH3 0x461bcd 13AC 60 PUSH1 0xe5 13AE 1B SHL 13AF 81 DUP2 13B0 52 MSTORE 13B1 60 PUSH1 0x04 13B3 01 ADD 13B4 61 PUSH2 0x06c4 13B7 90 SWAP1 13B8 61 PUSH2 0x2403 13BB 56 *JUMP 13BC 5B JUMPDEST 13BD 60 PUSH1 0x01 13BF 60 PUSH1 0x01 13C1 60 PUSH1 0xa0 13C3 1B SHL 13C4 03 SUB 13C5 82 DUP3 13C6 16 AND 13C7 61 PUSH2 0x13e2 13CA 57 *JUMPI 13CB 60 PUSH1 0x40 13CD 51 MLOAD 13CE 62 PUSH3 0x461bcd 13D2 60 PUSH1 0xe5 13D4 1B SHL 13D5 81 DUP2 13D6 52 MSTORE 13D7 60 PUSH1 0x04 13D9 01 ADD 13DA 61 PUSH2 0x06c4 13DD 90 SWAP1 13DE 61 PUSH2 0x2148 13E1 56 *JUMP 13E2 5B JUMPDEST 13E3 61 PUSH2 0x13ed 13E6 83 DUP4 13E7 83 DUP4 13E8 83 DUP4 13E9 61 PUSH2 0x16aa 13EC 56 *JUMP 13ED 5B JUMPDEST 13EE 61 PUSH2 0x13f8 13F1 60 PUSH1 0x00 13F3 82 DUP3 13F4 61 PUSH2 0x1290 13F7 56 *JUMP 13F8 5B JUMPDEST 13F9 60 PUSH1 0x01 13FB 60 PUSH1 0x01 13FD 60 PUSH1 0xa0 13FF 1B SHL 1400 03 SUB 1401 83 DUP4 1402 16 AND 1403 60 PUSH1 0x00 1405 90 SWAP1 1406 81 DUP2 1407 52 MSTORE 1408 60 PUSH1 0x03 140A 60 PUSH1 0x20 140C 52 MSTORE 140D 60 PUSH1 0x40 140F 81 DUP2 1410 20 SHA3 1411 80 DUP1 1412 54 SLOAD 1413 60 PUSH1 0x01 1415 92 SWAP3 1416 90 SWAP1 1417 61 PUSH2 0x1421 141A 90 SWAP1 141B 84 DUP5 141C 90 SWAP1 141D 61 PUSH2 0x2675 1420 56 *JUMP 1421 5B JUMPDEST 1422 90 SWAP1 1423 91 SWAP2 1424 55 SSTORE 1425 50 POP 1426 50 POP 1427 60 PUSH1 0x01 1429 60 PUSH1 0x01 142B 60 PUSH1 0xa0 142D 1B SHL 142E 03 SUB 142F 82 DUP3 1430 16 AND 1431 60 PUSH1 0x00 1433 90 SWAP1 1434 81 DUP2 1435 52 MSTORE 1436 60 PUSH1 0x03 1438 60 PUSH1 0x20 143A 52 MSTORE 143B 60 PUSH1 0x40 143D 81 DUP2 143E 20 SHA3 143F 80 DUP1 1440 54 SLOAD 1441 60 PUSH1 0x01 1443 92 SWAP3 1444 90 SWAP1 1445 61 PUSH2 0x144f 1448 90 SWAP1 1449 84 DUP5 144A 90 SWAP1 144B 61 PUSH2 0x262a 144E 56 *JUMP 144F 5B JUMPDEST 1450 90 SWAP1 1451 91 SWAP2 1452 55 SSTORE 1453 50 POP 1454 50 POP 1455 60 PUSH1 0x00 1457 81 DUP2 1458 81 DUP2 1459 52 MSTORE 145A 60 PUSH1 0x02 145C 60 PUSH1 0x20 145E 52 MSTORE 145F 60 PUSH1 0x40 1461 80 DUP1 1462 82 DUP3 1463 20 SHA3 1464 80 DUP1 1465 54 SLOAD 1466 60 PUSH1 0x01 1468 60 PUSH1 0x01 146A 60 PUSH1 0xa0 146C 1B SHL 146D 03 SUB 146E 19 NOT 146F 16 AND 1470 60 PUSH1 0x01 1472 60 PUSH1 0x01 1474 60 PUSH1 0xa0 1476 1B SHL 1477 03 SUB 1478 86 DUP7 1479 81 DUP2 147A 16 AND 147B 91 SWAP2 147C 82 DUP3 147D 17 OR 147E 90 SWAP1 147F 92 SWAP3 1480 55 SSTORE 1481 91 SWAP2 1482 51 MLOAD 1483 84 DUP5 1484 93 SWAP4 1485 91 SWAP2 1486 87 DUP8 1487 16 AND 1488 91 SWAP2 1489 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 14AA 91 SWAP2 14AB A4 LOG4 14AC 50 POP 14AD 50 POP 14AE 50 POP 14AF 56 *JUMP label_14B0: // Incoming jump from 0x0B52 // Inputs[2] // { // @14B6 stack[-1] // @14B7 stack[-2] // } 14B0 5B JUMPDEST 14B1 60 PUSH1 0x00 14B3 61 PUSH2 0x10a8 14B6 82 DUP3 14B7 84 DUP5 14B8 61 PUSH2 0x262a 14BB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @14B1 stack[0] = 0x00 // @14B3 stack[1] = 0x10a8 // @14B6 stack[2] = stack[-1] // @14B7 stack[3] = stack[-2] // } // Block ends with call to 0x262a, returns to 0x10A8 14BC 5B JUMPDEST 14BD 60 PUSH1 0x00 14BF 61 PUSH2 0x10a8 14C2 82 DUP3 14C3 84 DUP5 14C4 61 PUSH2 0x2656 14C7 56 *JUMP 14C8 5B JUMPDEST 14C9 61 PUSH2 0x0a05 14CC 82 DUP3 14CD 82 DUP3 14CE 60 PUSH1 0x40 14D0 51 MLOAD 14D1 80 DUP1 14D2 60 PUSH1 0x20 14D4 01 ADD 14D5 60 PUSH1 0x40 14D7 52 MSTORE 14D8 80 DUP1 14D9 60 PUSH1 0x00 14DB 81 DUP2 14DC 52 MSTORE 14DD 50 POP 14DE 61 PUSH2 0x1733 14E1 56 *JUMP 14E2 5B JUMPDEST 14E3 61 PUSH2 0x14ed 14E6 84 DUP5 14E7 84 DUP5 14E8 84 DUP5 14E9 61 PUSH2 0x1383 14EC 56 *JUMP 14ED 5B JUMPDEST 14EE 61 PUSH2 0x14f9 14F1 84 DUP5 14F2 84 DUP5 14F3 84 DUP5 14F4 84 DUP5 14F5 61 PUSH2 0x1766 14F8 56 *JUMP 14F9 5B JUMPDEST 14FA 61 PUSH2 0x1026 14FD 57 *JUMPI 14FE 60 PUSH1 0x40 1500 51 MLOAD 1501 62 PUSH3 0x461bcd 1505 60 PUSH1 0xe5 1507 1B SHL 1508 81 DUP2 1509 52 MSTORE 150A 60 PUSH1 0x04 150C 01 ADD 150D 61 PUSH2 0x06c4 1510 90 SWAP1 1511 61 PUSH2 0x2053 1514 56 *JUMP label_1515: // Incoming jump from 0x105C // Inputs[1] { @151B storage[0x06] } 1515 5B JUMPDEST 1516 60 PUSH1 0x60 1518 60 PUSH1 0x06 151A 80 DUP1 151B 54 SLOAD 151C 61 PUSH2 0x061a 151F 90 SWAP1 1520 61 PUSH2 0x26b8 1523 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1516 stack[0] = 0x60 // @1518 stack[1] = 0x06 // @151F stack[2] = 0x061a // @151F stack[3] = storage[0x06] // } // Block ends with call to 0x26b8, returns to 0x061A 1524 5B JUMPDEST 1525 60 PUSH1 0x60 1527 81 DUP2 1528 61 PUSH2 0x1549 152B 57 *JUMPI 152C 50 POP 152D 60 PUSH1 0x40 152F 80 DUP1 1530 51 MLOAD 1531 80 DUP1 1532 82 DUP3 1533 01 ADD 1534 90 SWAP1 1535 91 SWAP2 1536 52 MSTORE 1537 60 PUSH1 0x01 1539 81 DUP2 153A 52 MSTORE 153B 60 PUSH1 0x03 153D 60 PUSH1 0xfc 153F 1B SHL 1540 60 PUSH1 0x20 1542 82 DUP3 1543 01 ADD 1544 52 MSTORE 1545 61 PUSH2 0x0606 1548 56 *JUMP 1549 5B JUMPDEST 154A 81 DUP2 154B 60 PUSH1 0x00 154D 5B JUMPDEST 154E 81 DUP2 154F 15 ISZERO 1550 61 PUSH2 0x1573 1553 57 *JUMPI 1554 80 DUP1 1555 61 PUSH2 0x155d 1558 81 DUP2 1559 61 PUSH2 0x26f3 155C 56 *JUMP 155D 5B JUMPDEST 155E 91 SWAP2 155F 50 POP 1560 61 PUSH2 0x156c 1563 90 SWAP1 1564 50 POP 1565 60 PUSH1 0x0a 1567 83 DUP4 1568 61 PUSH2 0x2642 156B 56 *JUMP 156C 5B JUMPDEST 156D 91 SWAP2 156E 50 POP 156F 61 PUSH2 0x154d 1572 56 *JUMP 1573 5B JUMPDEST 1574 60 PUSH1 0x00 1576 81 DUP2 1577 67 PUSH8 0xffffffffffffffff 1580 81 DUP2 1581 11 GT 1582 15 ISZERO 1583 61 PUSH2 0x159c 1586 57 *JUMPI 1587 63 PUSH4 0x4e487b71 158C 60 PUSH1 0xe0 158E 1B SHL 158F 60 PUSH1 0x00 1591 52 MSTORE 1592 60 PUSH1 0x41 1594 60 PUSH1 0x04 1596 52 MSTORE 1597 60 PUSH1 0x24 1599 60 PUSH1 0x00 159B FD *REVERT 159C 5B JUMPDEST 159D 60 PUSH1 0x40 159F 51 MLOAD 15A0 90 SWAP1 15A1 80 DUP1 15A2 82 DUP3 15A3 52 MSTORE 15A4 80 DUP1 15A5 60 PUSH1 0x1f 15A7 01 ADD 15A8 60 PUSH1 0x1f 15AA 19 NOT 15AB 16 AND 15AC 60 PUSH1 0x20 15AE 01 ADD 15AF 82 DUP3 15B0 01 ADD 15B1 60 PUSH1 0x40 15B3 52 MSTORE 15B4 80 DUP1 15B5 15 ISZERO 15B6 61 PUSH2 0x15c6 15B9 57 *JUMPI 15BA 60 PUSH1 0x20 15BC 82 DUP3 15BD 01 ADD 15BE 81 DUP2 15BF 80 DUP1 15C0 36 CALLDATASIZE 15C1 83 DUP4 15C2 37 CALLDATACOPY 15C3 01 ADD 15C4 90 SWAP1 15C5 50 POP 15C6 5B JUMPDEST 15C7 50 POP 15C8 90 SWAP1 15C9 50 POP 15CA 5B JUMPDEST 15CB 84 DUP5 15CC 15 ISZERO 15CD 61 PUSH2 0x137b 15D0 57 *JUMPI 15D1 61 PUSH2 0x15db 15D4 60 PUSH1 0x01 15D6 83 DUP4 15D7 61 PUSH2 0x2675 15DA 56 *JUMP 15DB 5B JUMPDEST 15DC 91 SWAP2 15DD 50 POP 15DE 61 PUSH2 0x15e8 15E1 60 PUSH1 0x0a 15E3 86 DUP7 15E4 61 PUSH2 0x270e 15E7 56 *JUMP 15E8 5B JUMPDEST 15E9 61 PUSH2 0x15f3 15EC 90 SWAP1 15ED 60 PUSH1 0x30 15EF 61 PUSH2 0x262a 15F2 56 *JUMP 15F3 5B JUMPDEST 15F4 60 PUSH1 0xf8 15F6 1B SHL 15F7 81 DUP2 15F8 83 DUP4 15F9 81 DUP2 15FA 51 MLOAD 15FB 81 DUP2 15FC 10 LT 15FD 61 PUSH2 0x1616 1600 57 *JUMPI 1601 63 PUSH4 0x4e487b71 1606 60 PUSH1 0xe0 1608 1B SHL 1609 60 PUSH1 0x00 160B 52 MSTORE 160C 60 PUSH1 0x32 160E 60 PUSH1 0x04 1610 52 MSTORE 1611 60 PUSH1 0x24 1613 60 PUSH1 0x00 1615 FD *REVERT 1616 5B JUMPDEST 1617 60 PUSH1 0x20 1619 01 ADD 161A 01 ADD 161B 90 SWAP1 161C 60 PUSH1 0x01 161E 60 PUSH1 0x01 1620 60 PUSH1 0xf8 1622 1B SHL 1623 03 SUB 1624 19 NOT 1625 16 AND 1626 90 SWAP1 1627 81 DUP2 1628 60 PUSH1 0x00 162A 1A BYTE 162B 90 SWAP1 162C 53 MSTORE8 162D 50 POP 162E 61 PUSH2 0x1638 1631 60 PUSH1 0x0a 1633 86 DUP7 1634 61 PUSH2 0x2642 1637 56 *JUMP 1638 5B JUMPDEST 1639 94 SWAP5 163A 50 POP 163B 61 PUSH2 0x15ca 163E 56 *JUMP label_163F: // Incoming call from 0x122E, returns to 0x093A // Inputs[5] // { // @1643 storage[0x0b] // @164C stack[-1] // @1661 memory[0x40:0x60] // @168D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1690 stack[-2] // } 163F 5B JUMPDEST 1640 60 PUSH1 0x0b 1642 80 DUP1 1643 54 SLOAD 1644 60 PUSH1 0x01 1646 60 PUSH1 0x01 1648 60 PUSH1 0xa0 164A 1B SHL 164B 03 SUB 164C 83 DUP4 164D 81 DUP2 164E 16 AND 164F 60 PUSH1 0x01 1651 60 PUSH1 0x01 1653 60 PUSH1 0xa0 1655 1B SHL 1656 03 SUB 1657 19 NOT 1658 83 DUP4 1659 16 AND 165A 81 DUP2 165B 17 OR 165C 90 SWAP1 165D 93 SWAP4 165E 55 SSTORE 165F 60 PUSH1 0x40 1661 51 MLOAD 1662 91 SWAP2 1663 16 AND 1664 91 SWAP2 1665 90 SWAP1 1666 82 DUP3 1667 90 SWAP1 1668 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1689 90 SWAP1 168A 60 PUSH1 0x00 168C 90 SWAP1 168D A3 LOG3 168E 50 POP 168F 50 POP 1690 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @165E storage[0x0b] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x0b] & ~((0x01 << 0xa0) - 0x01)) // @168D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0b] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1691: // Incoming call from 0x126E, returns to 0x0603 // Inputs[2] // { // @169B stack[-1] // @16A6 stack[-2] // } 1691 5B JUMPDEST 1692 60 PUSH1 0x01 1694 60 PUSH1 0x01 1696 60 PUSH1 0xe0 1698 1B SHL 1699 03 SUB 169A 19 NOT 169B 81 DUP2 169C 16 AND 169D 63 PUSH4 0x01ffc9a7 16A2 60 PUSH1 0xe0 16A4 1B SHL 16A5 14 EQ 16A6 91 SWAP2 16A7 90 SWAP1 16A8 50 POP 16A9 56 *JUMP // Stack delta = -1 // Outputs[1] { @16A6 stack[-2] = 0x01ffc9a7 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) } // Block ends with unconditional jump to stack[-2] 16AA 5B JUMPDEST 16AB 61 PUSH2 0x16b5 16AE 83 DUP4 16AF 83 DUP4 16B0 83 DUP4 16B1 61 PUSH2 0x077c 16B4 56 *JUMP 16B5 5B JUMPDEST 16B6 60 PUSH1 0x01 16B8 60 PUSH1 0x01 16BA 60 PUSH1 0xa0 16BC 1B SHL 16BD 03 SUB 16BE 83 DUP4 16BF 16 AND 16C0 61 PUSH2 0x16d1 16C3 57 *JUMPI 16C4 61 PUSH2 0x16cc 16C7 81 DUP2 16C8 61 PUSH2 0x1881 16CB 56 *JUMP 16CC 5B JUMPDEST 16CD 61 PUSH2 0x16f4 16D0 56 *JUMP 16D1 5B JUMPDEST 16D2 81 DUP2 16D3 60 PUSH1 0x01 16D5 60 PUSH1 0x01 16D7 60 PUSH1 0xa0 16D9 1B SHL 16DA 03 SUB 16DB 16 AND 16DC 83 DUP4 16DD 60 PUSH1 0x01 16DF 60 PUSH1 0x01 16E1 60 PUSH1 0xa0 16E3 1B SHL 16E4 03 SUB 16E5 16 AND 16E6 14 EQ 16E7 61 PUSH2 0x16f4 16EA 57 *JUMPI 16EB 61 PUSH2 0x16f4 16EE 83 DUP4 16EF 82 DUP3 16F0 61 PUSH2 0x18c5 16F3 56 *JUMP 16F4 5B JUMPDEST 16F5 60 PUSH1 0x01 16F7 60 PUSH1 0x01 16F9 60 PUSH1 0xa0 16FB 1B SHL 16FC 03 SUB 16FD 82 DUP3 16FE 16 AND 16FF 61 PUSH2 0x1710 1702 57 *JUMPI 1703 61 PUSH2 0x170b 1706 81 DUP2 1707 61 PUSH2 0x1962 170A 56 *JUMP 170B 5B JUMPDEST 170C 61 PUSH2 0x077c 170F 56 *JUMP 1710 5B JUMPDEST 1711 82 DUP3 1712 60 PUSH1 0x01 1714 60 PUSH1 0x01 1716 60 PUSH1 0xa0 1718 1B SHL 1719 03 SUB 171A 16 AND 171B 82 DUP3 171C 60 PUSH1 0x01 171E 60 PUSH1 0x01 1720 60 PUSH1 0xa0 1722 1B SHL 1723 03 SUB 1724 16 AND 1725 14 EQ 1726 61 PUSH2 0x077c 1729 57 *JUMPI 172A 61 PUSH2 0x077c 172D 82 DUP3 172E 82 DUP3 172F 61 PUSH2 0x1a3b 1732 56 *JUMP 1733 5B JUMPDEST 1734 61 PUSH2 0x173d 1737 83 DUP4 1738 83 DUP4 1739 61 PUSH2 0x1a7f 173C 56 *JUMP 173D 5B JUMPDEST 173E 61 PUSH2 0x174a 1741 60 PUSH1 0x00 1743 84 DUP5 1744 84 DUP5 1745 84 DUP5 1746 61 PUSH2 0x1766 1749 56 *JUMP 174A 5B JUMPDEST 174B 61 PUSH2 0x077c 174E 57 *JUMPI 174F 60 PUSH1 0x40 1751 51 MLOAD 1752 62 PUSH3 0x461bcd 1756 60 PUSH1 0xe5 1758 1B SHL 1759 81 DUP2 175A 52 MSTORE 175B 60 PUSH1 0x04 175D 01 ADD 175E 61 PUSH2 0x06c4 1761 90 SWAP1 1762 61 PUSH2 0x2053 1765 56 *JUMP 1766 5B JUMPDEST 1767 60 PUSH1 0x00 1769 61 PUSH2 0x177a 176C 84 DUP5 176D 60 PUSH1 0x01 176F 60 PUSH1 0x01 1771 60 PUSH1 0xa0 1773 1B SHL 1774 03 SUB 1775 16 AND 1776 61 PUSH2 0x1b5e 1779 56 *JUMP 177A 5B JUMPDEST 177B 15 ISZERO 177C 61 PUSH2 0x1876 177F 57 *JUMPI 1780 83 DUP4 1781 60 PUSH1 0x01 1783 60 PUSH1 0x01 1785 60 PUSH1 0xa0 1787 1B SHL 1788 03 SUB 1789 16 AND 178A 63 PUSH4 0x150b7a02 178F 61 PUSH2 0x1796 1792 61 PUSH2 0x128c 1795 56 *JUMP 1796 5B JUMPDEST 1797 87 DUP8 1798 86 DUP7 1799 86 DUP7 179A 60 PUSH1 0x40 179C 51 MLOAD 179D 85 DUP6 179E 63 PUSH4 0xffffffff 17A3 16 AND 17A4 60 PUSH1 0xe0 17A6 1B SHL 17A7 81 DUP2 17A8 52 MSTORE 17A9 60 PUSH1 0x04 17AB 01 ADD 17AC 61 PUSH2 0x17b8 17AF 94 SWAP5 17B0 93 SWAP4 17B1 92 SWAP3 17B2 91 SWAP2 17B3 90 SWAP1 17B4 61 PUSH2 0x1eef 17B7 56 *JUMP 17B8 5B JUMPDEST 17B9 60 PUSH1 0x20 17BB 60 PUSH1 0x40 17BD 51 MLOAD 17BE 80 DUP1 17BF 83 DUP4 17C0 03 SUB 17C1 81 DUP2 17C2 60 PUSH1 0x00 17C4 87 DUP8 17C5 80 DUP1 17C6 3B EXTCODESIZE 17C7 15 ISZERO 17C8 80 DUP1 17C9 15 ISZERO 17CA 61 PUSH2 0x17d2 17CD 57 *JUMPI 17CE 60 PUSH1 0x00 17D0 80 DUP1 17D1 FD *REVERT 17D2 5B JUMPDEST 17D3 50 POP 17D4 5A GAS 17D5 F1 CALL 17D6 92 SWAP3 17D7 50 POP 17D8 50 POP 17D9 50 POP 17DA 80 DUP1 17DB 15 ISZERO 17DC 61 PUSH2 0x1802 17DF 57 *JUMPI 17E0 50 POP 17E1 60 PUSH1 0x40 17E3 80 DUP1 17E4 51 MLOAD 17E5 60 PUSH1 0x1f 17E7 3D RETURNDATASIZE 17E8 90 SWAP1 17E9 81 DUP2 17EA 01 ADD 17EB 60 PUSH1 0x1f 17ED 19 NOT 17EE 16 AND 17EF 82 DUP3 17F0 01 ADD 17F1 90 SWAP1 17F2 92 SWAP3 17F3 52 MSTORE 17F4 61 PUSH2 0x17ff 17F7 91 SWAP2 17F8 81 DUP2 17F9 01 ADD 17FA 90 SWAP1 17FB 61 PUSH2 0x1e03 17FE 56 *JUMP 17FF 5B JUMPDEST 1800 60 PUSH1 0x01 1802 5B JUMPDEST 1803 61 PUSH2 0x185c 1806 57 *JUMPI 1807 3D RETURNDATASIZE 1808 80 DUP1 1809 80 DUP1 180A 15 ISZERO 180B 61 PUSH2 0x1830 180E 57 *JUMPI 180F 60 PUSH1 0x40 1811 51 MLOAD 1812 91 SWAP2 1813 50 POP 1814 60 PUSH1 0x1f 1816 19 NOT 1817 60 PUSH1 0x3f 1819 3D RETURNDATASIZE 181A 01 ADD 181B 16 AND 181C 82 DUP3 181D 01 ADD 181E 60 PUSH1 0x40 1820 52 MSTORE 1821 3D RETURNDATASIZE 1822 82 DUP3 1823 52 MSTORE 1824 3D RETURNDATASIZE 1825 60 PUSH1 0x00 1827 60 PUSH1 0x20 1829 84 DUP5 182A 01 ADD 182B 3E RETURNDATACOPY 182C 61 PUSH2 0x1835 182F 56 *JUMP 1830 5B JUMPDEST 1831 60 PUSH1 0x60 1833 91 SWAP2 1834 50 POP 1835 5B JUMPDEST 1836 50 POP 1837 80 DUP1 1838 51 MLOAD 1839 61 PUSH2 0x1854 183C 57 *JUMPI 183D 60 PUSH1 0x40 183F 51 MLOAD 1840 62 PUSH3 0x461bcd 1844 60 PUSH1 0xe5 1846 1B SHL 1847 81 DUP2 1848 52 MSTORE 1849 60 PUSH1 0x04 184B 01 ADD 184C 61 PUSH2 0x06c4 184F 90 SWAP1 1850 61 PUSH2 0x2053 1853 56 *JUMP 1854 5B JUMPDEST 1855 80 DUP1 1856 51 MLOAD 1857 81 DUP2 1858 60 PUSH1 0x20 185A 01 ADD 185B FD *REVERT 185C 5B JUMPDEST 185D 60 PUSH1 0x01 185F 60 PUSH1 0x01 1861 60 PUSH1 0xe0 1863 1B SHL 1864 03 SUB 1865 19 NOT 1866 16 AND 1867 63 PUSH4 0x0a85bd01 186C 60 PUSH1 0xe1 186E 1B SHL 186F 14 EQ 1870 90 SWAP1 1871 50 POP 1872 61 PUSH2 0x137b 1875 56 *JUMP 1876 5B JUMPDEST 1877 50 POP 1878 60 PUSH1 0x01 187A 94 SWAP5 187B 93 SWAP4 187C 50 POP 187D 50 POP 187E 50 POP 187F 50 POP 1880 56 *JUMP 1881 5B JUMPDEST 1882 60 PUSH1 0x09 1884 80 DUP1 1885 54 SLOAD 1886 60 PUSH1 0x00 1888 83 DUP4 1889 81 DUP2 188A 52 MSTORE 188B 60 PUSH1 0x0a 188D 60 PUSH1 0x20 188F 52 MSTORE 1890 60 PUSH1 0x40 1892 81 DUP2 1893 20 SHA3 1894 82 DUP3 1895 90 SWAP1 1896 55 SSTORE 1897 60 PUSH1 0x01 1899 82 DUP3 189A 01 ADD 189B 83 DUP4 189C 55 SSTORE 189D 91 SWAP2 189E 90 SWAP1 189F 91 SWAP2 18A0 52 MSTORE 18A1 7F PUSH32 0x6e1540171b6c0c960b71a7020d9f60077f6af931a8bbf590da0223dacf75c7af 18C2 01 ADD 18C3 55 SSTORE 18C4 56 *JUMP 18C5 5B JUMPDEST 18C6 60 PUSH1 0x00 18C8 60 PUSH1 0x01 18CA 61 PUSH2 0x18d2 18CD 84 DUP5 18CE 61 PUSH2 0x0a44 18D1 56 *JUMP 18D2 5B JUMPDEST 18D3 61 PUSH2 0x18dc 18D6 91 SWAP2 18D7 90 SWAP1 18D8 61 PUSH2 0x2675 18DB 56 *JUMP 18DC 5B JUMPDEST 18DD 60 PUSH1 0x00 18DF 83 DUP4 18E0 81 DUP2 18E1 52 MSTORE 18E2 60 PUSH1 0x08 18E4 60 PUSH1 0x20 18E6 52 MSTORE 18E7 60 PUSH1 0x40 18E9 90 SWAP1 18EA 20 SHA3 18EB 54 SLOAD 18EC 90 SWAP1 18ED 91 SWAP2 18EE 50 POP 18EF 80 DUP1 18F0 82 DUP3 18F1 14 EQ 18F2 61 PUSH2 0x192f 18F5 57 *JUMPI 18F6 60 PUSH1 0x01 18F8 60 PUSH1 0x01 18FA 60 PUSH1 0xa0 18FC 1B SHL 18FD 03 SUB 18FE 84 DUP5 18FF 16 AND 1900 60 PUSH1 0x00 1902 90 SWAP1 1903 81 DUP2 1904 52 MSTORE 1905 60 PUSH1 0x07 1907 60 PUSH1 0x20 1909 90 SWAP1 190A 81 DUP2 190B 52 MSTORE 190C 60 PUSH1 0x40 190E 80 DUP1 190F 83 DUP4 1910 20 SHA3 1911 85 DUP6 1912 84 DUP5 1913 52 MSTORE 1914 82 DUP3 1915 52 MSTORE 1916 80 DUP1 1917 83 DUP4 1918 20 SHA3 1919 54 SLOAD 191A 84 DUP5 191B 84 DUP5 191C 52 MSTORE 191D 81 DUP2 191E 84 DUP5 191F 20 SHA3 1920 81 DUP2 1921 90 SWAP1 1922 55 SSTORE 1923 83 DUP4 1924 52 MSTORE 1925 60 PUSH1 0x08 1927 90 SWAP1 1928 91 SWAP2 1929 52 MSTORE 192A 90 SWAP1 192B 20 SHA3 192C 81 DUP2 192D 90 SWAP1 192E 55 SSTORE 192F 5B JUMPDEST 1930 50 POP 1931 60 PUSH1 0x00 1933 91 SWAP2 1934 82 DUP3 1935 52 MSTORE 1936 60 PUSH1 0x08 1938 60 PUSH1 0x20 193A 90 SWAP1 193B 81 DUP2 193C 52 MSTORE 193D 60 PUSH1 0x40 193F 80 DUP1 1940 84 DUP5 1941 20 SHA3 1942 84 DUP5 1943 90 SWAP1 1944 55 SSTORE 1945 60 PUSH1 0x01 1947 60 PUSH1 0x01 1949 60 PUSH1 0xa0 194B 1B SHL 194C 03 SUB 194D 90 SWAP1 194E 94 SWAP5 194F 16 AND 1950 83 DUP4 1951 52 MSTORE 1952 60 PUSH1 0x07 1954 81 DUP2 1955 52 MSTORE 1956 83 DUP4 1957 83 DUP4 1958 20 SHA3 1959 91 SWAP2 195A 83 DUP4 195B 52 MSTORE 195C 52 MSTORE 195D 90 SWAP1 195E 81 DUP2 195F 20 SHA3 1960 55 SSTORE 1961 56 *JUMP 1962 5B JUMPDEST 1963 60 PUSH1 0x09 1965 54 SLOAD 1966 60 PUSH1 0x00 1968 90 SWAP1 1969 61 PUSH2 0x1974 196C 90 SWAP1 196D 60 PUSH1 0x01 196F 90 SWAP1 1970 61 PUSH2 0x2675 1973 56 *JUMP 1974 5B JUMPDEST 1975 60 PUSH1 0x00 1977 83 DUP4 1978 81 DUP2 1979 52 MSTORE 197A 60 PUSH1 0x0a 197C 60 PUSH1 0x20 197E 52 MSTORE 197F 60 PUSH1 0x40 1981 81 DUP2 1982 20 SHA3 1983 54 SLOAD 1984 60 PUSH1 0x09 1986 80 DUP1 1987 54 SLOAD 1988 93 SWAP4 1989 94 SWAP5 198A 50 POP 198B 90 SWAP1 198C 92 SWAP3 198D 84 DUP5 198E 90 SWAP1 198F 81 DUP2 1990 10 LT 1991 61 PUSH2 0x19aa 1994 57 *JUMPI 1995 63 PUSH4 0x4e487b71 199A 60 PUSH1 0xe0 199C 1B SHL 199D 60 PUSH1 0x00 199F 52 MSTORE 19A0 60 PUSH1 0x32 19A2 60 PUSH1 0x04 19A4 52 MSTORE 19A5 60 PUSH1 0x24 19A7 60 PUSH1 0x00 19A9 FD *REVERT 19AA 5B JUMPDEST 19AB 90 SWAP1 19AC 60 PUSH1 0x00 19AE 52 MSTORE 19AF 60 PUSH1 0x20 19B1 60 PUSH1 0x00 19B3 20 SHA3 19B4 01 ADD 19B5 54 SLOAD 19B6 90 SWAP1 19B7 50 POP 19B8 80 DUP1 19B9 60 PUSH1 0x09 19BB 83 DUP4 19BC 81 DUP2 19BD 54 SLOAD 19BE 81 DUP2 19BF 10 LT 19C0 61 PUSH2 0x19d9 19C3 57 *JUMPI 19C4 63 PUSH4 0x4e487b71 19C9 60 PUSH1 0xe0 19CB 1B SHL 19CC 60 PUSH1 0x00 19CE 52 MSTORE 19CF 60 PUSH1 0x32 19D1 60 PUSH1 0x04 19D3 52 MSTORE 19D4 60 PUSH1 0x24 19D6 60 PUSH1 0x00 19D8 FD *REVERT 19D9 5B JUMPDEST 19DA 60 PUSH1 0x00 19DC 91 SWAP2 19DD 82 DUP3 19DE 52 MSTORE 19DF 60 PUSH1 0x20 19E1 80 DUP1 19E2 83 DUP4 19E3 20 SHA3 19E4 90 SWAP1 19E5 91 SWAP2 19E6 01 ADD 19E7 92 SWAP3 19E8 90 SWAP1 19E9 92 SWAP3 19EA 55 SSTORE 19EB 82 DUP3 19EC 81 DUP2 19ED 52 MSTORE 19EE 60 PUSH1 0x0a 19F0 90 SWAP1 19F1 91 SWAP2 19F2 52 MSTORE 19F3 60 PUSH1 0x40 19F5 80 DUP1 19F6 82 DUP3 19F7 20 SHA3 19F8 84 DUP5 19F9 90 SWAP1 19FA 55 SSTORE 19FB 85 DUP6 19FC 82 DUP3 19FD 52 MSTORE 19FE 81 DUP2 19FF 20 SHA3 1A00 55 SSTORE 1A01 60 PUSH1 0x09 1A03 80 DUP1 1A04 54 SLOAD 1A05 80 DUP1 1A06 61 PUSH2 0x1a1f 1A09 57 *JUMPI 1A0A 63 PUSH4 0x4e487b71 1A0F 60 PUSH1 0xe0 1A11 1B SHL 1A12 60 PUSH1 0x00 1A14 52 MSTORE 1A15 60 PUSH1 0x31 1A17 60 PUSH1 0x04 1A19 52 MSTORE 1A1A 60 PUSH1 0x24 1A1C 60 PUSH1 0x00 1A1E FD *REVERT 1A1F 5B JUMPDEST 1A20 60 PUSH1 0x01 1A22 90 SWAP1 1A23 03 SUB 1A24 81 DUP2 1A25 81 DUP2 1A26 90 SWAP1 1A27 60 PUSH1 0x00 1A29 52 MSTORE 1A2A 60 PUSH1 0x20 1A2C 60 PUSH1 0x00 1A2E 20 SHA3 1A2F 01 ADD 1A30 60 PUSH1 0x00 1A32 90 SWAP1 1A33 55 SSTORE 1A34 90 SWAP1 1A35 55 SSTORE 1A36 50 POP 1A37 50 POP 1A38 50 POP 1A39 50 POP 1A3A 56 *JUMP 1A3B 5B JUMPDEST 1A3C 60 PUSH1 0x00 1A3E 61 PUSH2 0x1a46 1A41 83 DUP4 1A42 61 PUSH2 0x0a44 1A45 56 *JUMP 1A46 5B JUMPDEST 1A47 60 PUSH1 0x01 1A49 60 PUSH1 0x01 1A4B 60 PUSH1 0xa0 1A4D 1B SHL 1A4E 03 SUB 1A4F 90 SWAP1 1A50 93 SWAP4 1A51 16 AND 1A52 60 PUSH1 0x00 1A54 90 SWAP1 1A55 81 DUP2 1A56 52 MSTORE 1A57 60 PUSH1 0x07 1A59 60 PUSH1 0x20 1A5B 90 SWAP1 1A5C 81 DUP2 1A5D 52 MSTORE 1A5E 60 PUSH1 0x40 1A60 80 DUP1 1A61 83 DUP4 1A62 20 SHA3 1A63 86 DUP7 1A64 84 DUP5 1A65 52 MSTORE 1A66 82 DUP3 1A67 52 MSTORE 1A68 80 DUP1 1A69 83 DUP4 1A6A 20 SHA3 1A6B 85 DUP6 1A6C 90 SWAP1 1A6D 55 SSTORE 1A6E 93 SWAP4 1A6F 82 DUP3 1A70 52 MSTORE 1A71 60 PUSH1 0x08 1A73 90 SWAP1 1A74 52 MSTORE 1A75 91 SWAP2 1A76 90 SWAP1 1A77 91 SWAP2 1A78 20 SHA3 1A79 91 SWAP2 1A7A 90 SWAP1 1A7B 91 SWAP2 1A7C 55 SSTORE 1A7D 50 POP 1A7E 56 *JUMP 1A7F 5B JUMPDEST 1A80 60 PUSH1 0x01 1A82 60 PUSH1 0x01 1A84 60 PUSH1 0xa0 1A86 1B SHL 1A87 03 SUB 1A88 82 DUP3 1A89 16 AND 1A8A 61 PUSH2 0x1aa5 1A8D 57 *JUMPI 1A8E 60 PUSH1 0x40 1A90 51 MLOAD 1A91 62 PUSH3 0x461bcd 1A95 60 PUSH1 0xe5 1A97 1B SHL 1A98 81 DUP2 1A99 52 MSTORE 1A9A 60 PUSH1 0x04 1A9C 01 ADD 1A9D 61 PUSH2 0x06c4 1AA0 90 SWAP1 1AA1 61 PUSH2 0x234d 1AA4 56 *JUMP 1AA5 5B JUMPDEST 1AA6 61 PUSH2 0x1aae 1AA9 81 DUP2 1AAA 61 PUSH2 0x126f 1AAD 56 *JUMP 1AAE 5B JUMPDEST 1AAF 15 ISZERO 1AB0 61 PUSH2 0x1acb 1AB3 57 *JUMPI 1AB4 60 PUSH1 0x40 1AB6 51 MLOAD 1AB7 62 PUSH3 0x461bcd 1ABB 60 PUSH1 0xe5 1ABD 1B SHL 1ABE 81 DUP2 1ABF 52 MSTORE 1AC0 60 PUSH1 0x04 1AC2 01 ADD 1AC3 61 PUSH2 0x06c4 1AC6 90 SWAP1 1AC7 61 PUSH2 0x20eb 1ACA 56 *JUMP 1ACB 5B JUMPDEST 1ACC 61 PUSH2 0x1ad7 1ACF 60 PUSH1 0x00 1AD1 83 DUP4 1AD2 83 DUP4 1AD3 61 PUSH2 0x16aa 1AD6 56 *JUMP 1AD7 5B JUMPDEST 1AD8 60 PUSH1 0x01 1ADA 60 PUSH1 0x01 1ADC 60 PUSH1 0xa0 1ADE 1B SHL 1ADF 03 SUB 1AE0 82 DUP3 1AE1 16 AND 1AE2 60 PUSH1 0x00 1AE4 90 SWAP1 1AE5 81 DUP2 1AE6 52 MSTORE 1AE7 60 PUSH1 0x03 1AE9 60 PUSH1 0x20 1AEB 52 MSTORE 1AEC 60 PUSH1 0x40 1AEE 81 DUP2 1AEF 20 SHA3 1AF0 80 DUP1 1AF1 54 SLOAD 1AF2 60 PUSH1 0x01 1AF4 92 SWAP3 1AF5 90 SWAP1 1AF6 61 PUSH2 0x1b00 1AF9 90 SWAP1 1AFA 84 DUP5 1AFB 90 SWAP1 1AFC 61 PUSH2 0x262a 1AFF 56 *JUMP 1B00 5B JUMPDEST 1B01 90 SWAP1 1B02 91 SWAP2 1B03 55 SSTORE 1B04 50 POP 1B05 50 POP 1B06 60 PUSH1 0x00 1B08 81 DUP2 1B09 81 DUP2 1B0A 52 MSTORE 1B0B 60 PUSH1 0x02 1B0D 60 PUSH1 0x20 1B0F 52 MSTORE 1B10 60 PUSH1 0x40 1B12 80 DUP1 1B13 82 DUP3 1B14 20 SHA3 1B15 80 DUP1 1B16 54 SLOAD 1B17 60 PUSH1 0x01 1B19 60 PUSH1 0x01 1B1B 60 PUSH1 0xa0 1B1D 1B SHL 1B1E 03 SUB 1B1F 19 NOT 1B20 16 AND 1B21 60 PUSH1 0x01 1B23 60 PUSH1 0x01 1B25 60 PUSH1 0xa0 1B27 1B SHL 1B28 03 SUB 1B29 86 DUP7 1B2A 16 AND 1B2B 90 SWAP1 1B2C 81 DUP2 1B2D 17 OR 1B2E 90 SWAP1 1B2F 91 SWAP2 1B30 55 SSTORE 1B31 90 SWAP1 1B32 51 MLOAD 1B33 83 DUP4 1B34 92 SWAP3 1B35 90 SWAP1 1B36 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1B57 90 SWAP1 1B58 82 DUP3 1B59 90 SWAP1 1B5A A4 LOG4 1B5B 50 POP 1B5C 50 POP 1B5D 56 *JUMP 1B5E 5B JUMPDEST 1B5F 3B EXTCODESIZE 1B60 15 ISZERO 1B61 15 ISZERO 1B62 90 SWAP1 1B63 56 *JUMP label_1B64: // Incoming jump from 0x0A04 // Inputs[2] // { // @1B65 stack[-3] // @1B67 storage[stack[-3]] // } 1B64 5B JUMPDEST 1B65 82 DUP3 1B66 80 DUP1 1B67 54 SLOAD 1B68 61 PUSH2 0x1b70 1B6B 90 SWAP1 1B6C 61 PUSH2 0x26b8 1B6F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B65 stack[0] = stack[-3] // @1B6B stack[1] = 0x1b70 // @1B6B stack[2] = storage[stack[-3]] // } // Block ends with call to 0x26b8, returns to 0x1B70 label_1B70: // Incoming return from call to 0x26B8 at 0x1B6F // Inputs[5] // { // @1B71 stack[-1] // @1B71 stack[-2] // @1B79 memory[0x00:0x20] // @1B84 stack[-4] // @1B85 stack[-3] // } 1B70 5B JUMPDEST 1B71 90 SWAP1 1B72 60 PUSH1 0x00 1B74 52 MSTORE 1B75 60 PUSH1 0x20 1B77 60 PUSH1 0x00 1B79 20 SHA3 1B7A 90 SWAP1 1B7B 60 PUSH1 0x1f 1B7D 01 ADD 1B7E 60 PUSH1 0x20 1B80 90 SWAP1 1B81 04 DIV 1B82 81 DUP2 1B83 01 ADD 1B84 92 SWAP3 1B85 82 DUP3 1B86 61 PUSH2 0x1b92 1B89 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1B74 memory[0x00:0x20] = stack[-2] // @1B7A stack[-2] = keccak256(memory[0x00:0x20]) // @1B84 stack[-1] = stack[-4] // @1B84 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1b92, if stack[-3] label_1B8A: // Incoming jump from 0x1B89, if not stack[-3] // Inputs[1] { @1B8C stack[-5] } 1B8A 60 PUSH1 0x00 1B8C 85 DUP6 1B8D 55 SSTORE 1B8E 61 PUSH2 0x1bd8 1B91 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B8D storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1bd8 label_1B92: // Incoming jump from 0x1B89, if stack[-3] // Inputs[1] { @1B93 stack[-3] } 1B92 5B JUMPDEST 1B93 82 DUP3 1B94 60 PUSH1 0x1f 1B96 10 LT 1B97 61 PUSH2 0x1bab 1B9A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1bab, if 0x1f < stack[-3] label_1B9B: // Incoming jump from 0x1B9A, if not 0x1f < stack[-3] // Inputs[4] // { // @1B9B stack[-1] // @1B9C memory[stack[-1]:stack[-1] + 0x20] // @1BA1 stack[-3] // @1BA5 stack[-5] // } 1B9B 80 DUP1 1B9C 51 MLOAD 1B9D 60 PUSH1 0xff 1B9F 19 NOT 1BA0 16 AND 1BA1 83 DUP4 1BA2 80 DUP1 1BA3 01 ADD 1BA4 17 OR 1BA5 85 DUP6 1BA6 55 SSTORE 1BA7 61 PUSH2 0x1bd8 1BAA 56 *JUMP // Stack delta = +0 // Outputs[1] { @1BA6 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1bd8 label_1BAB: // Incoming jump from 0x1B9A, if 0x1f < stack[-3] // Inputs[2] // { // @1BAC stack[-3] // @1BB2 stack[-5] // } 1BAB 5B JUMPDEST 1BAC 82 DUP3 1BAD 80 DUP1 1BAE 01 ADD 1BAF 60 PUSH1 0x01 1BB1 01 ADD 1BB2 85 DUP6 1BB3 55 SSTORE 1BB4 82 DUP3 1BB5 15 ISZERO 1BB6 61 PUSH2 0x1bd8 1BB9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BB3 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1bd8, if !stack[-3] label_1BBA: // Incoming jump from 0x1BB9, if not !stack[-3] // Inputs[2] // { // @1BBA stack[-1] // @1BBA stack[-3] // } 1BBA 91 SWAP2 1BBB 82 DUP3 1BBC 01 ADD 1BBD 5B JUMPDEST 1BBE 82 DUP3 1BBF 81 DUP2 1BC0 11 GT 1BC1 15 ISZERO 1BC2 61 PUSH2 0x1bd8 1BC5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BBA stack[-3] = stack[-1] // @1BBC stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1bd8, if !(stack[-1] + stack[-3] > stack[-1]) label_1BC6: // Incoming jump from 0x1BC5, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1BC5, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1BC6 stack[-3] // @1BC7 memory[stack[-3]:stack[-3] + 0x20] // @1BC8 stack[-2] // @1BCA stack[-1] // } 1BC6 82 DUP3 1BC7 51 MLOAD 1BC8 82 DUP3 1BC9 55 SSTORE 1BCA 91 SWAP2 1BCB 60 PUSH1 0x20 1BCD 01 ADD 1BCE 91 SWAP2 1BCF 90 SWAP1 1BD0 60 PUSH1 0x01 1BD2 01 ADD 1BD3 90 SWAP1 1BD4 61 PUSH2 0x1bbd 1BD7 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1BC9 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1BCE stack[-3] = 0x20 + stack[-3] // @1BD3 stack[-2] = 0x01 + stack[-2] // @1BD3 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1bbd label_1BD8: // Incoming jump from 0x1BAA // Incoming jump from 0x1BC5, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1BB9, if !stack[-3] // Incoming jump from 0x1B91 // Incoming jump from 0x1BC5, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @1BDD stack[-4] // @1BDE stack[-3] // } 1BD8 5B JUMPDEST 1BD9 50 POP 1BDA 61 PUSH2 0x1be4 1BDD 92 SWAP3 1BDE 91 SWAP2 1BDF 50 POP 1BE0 61 PUSH2 0x1be8 1BE3 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1BDD stack[-4] = 0x1be4 // @1BDE stack[-3] = stack[-4] // } // Block ends with call to 0x1be8, returns to 0x1BE4 label_1BE4: // Incoming jump from 0x1BF1, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1BF1, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1BE8 at 0x1BE3 // Inputs[2] // { // @1BE6 stack[-2] // @1BE6 stack[-3] // } 1BE4 5B JUMPDEST 1BE5 50 POP 1BE6 90 SWAP1 1BE7 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BE6 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1BE8: // Incoming call from 0x1BE3, returns to 0x1BE4 // Inputs[2] // { // @1BEA stack[-1] // @1BEB stack[-2] // } 1BE8 5B JUMPDEST 1BE9 5B JUMPDEST 1BEA 80 DUP1 1BEB 82 DUP3 1BEC 11 GT 1BED 15 ISZERO 1BEE 61 PUSH2 0x1be4 1BF1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1be4, if !(stack[-2] > stack[-1]) label_1BF2: // Incoming jump from 0x1BF1, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1BF1, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1BF4 stack[-1] } 1BF2 60 PUSH1 0x00 1BF4 81 DUP2 1BF5 55 SSTORE 1BF6 60 PUSH1 0x01 1BF8 01 ADD 1BF9 61 PUSH2 0x1be9 1BFC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1BF5 storage[stack[-1]] = 0x00 // @1BF8 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1be9 label_1BFD: // Incoming call from 0x1E64, returns to 0x137B // Incoming call from 0x1D77, returns to 0x1D78 // Inputs[1] { @1C0A stack[-2] } 1BFD 5B JUMPDEST 1BFE 60 PUSH1 0x00 1C00 67 PUSH8 0xffffffffffffffff 1C09 80 DUP1 1C0A 84 DUP5 1C0B 11 GT 1C0C 15 ISZERO 1C0D 61 PUSH2 0x1c18 1C10 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BFE stack[0] = 0x00 // @1C00 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1c18, if !(stack[-2] > 0xffffffffffffffff) label_1C11: // Incoming jump from 0x1C10, if not !(stack[-2] > 0xffffffffffffffff) 1C11 61 PUSH2 0x1c18 1C14 61 PUSH2 0x274e 1C17 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C11 stack[0] = 0x1c18 } // Block ends with unconditional jump to 0x274e label_1C18: // Incoming jump from 0x1C10, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @1C1B memory[0x40:0x60] // @1C1E stack[-4] // @1C29 stack[-1] // } 1C18 5B JUMPDEST 1C19 60 PUSH1 0x40 1C1B 51 MLOAD 1C1C 60 PUSH1 0x1f 1C1E 85 DUP6 1C1F 01 ADD 1C20 60 PUSH1 0x1f 1C22 19 NOT 1C23 16 AND 1C24 81 DUP2 1C25 01 ADD 1C26 60 PUSH1 0x20 1C28 01 ADD 1C29 82 DUP3 1C2A 81 DUP2 1C2B 11 GT 1C2C 82 DUP3 1C2D 82 DUP3 1C2E 10 LT 1C2F 17 OR 1C30 15 ISZERO 1C31 61 PUSH2 0x1c3c 1C34 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C1B stack[0] = memory[0x40:0x60] // @1C28 stack[1] = 0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) // } // Block ends with conditional jump to 0x1c3c, if !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) > stack[-1])) label_1C35: // Incoming jump from 0x1C34, if not !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) > stack[-1])) 1C35 61 PUSH2 0x1c3c 1C38 61 PUSH2 0x274e 1C3B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C35 stack[0] = 0x1c3c } // Block ends with unconditional jump to 0x274e label_1C3C: // Incoming jump from 0x1C34, if !((0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) < memory[0x40:0x60]) | (0x20 + memory[0x40:0x60] + (~0x1f & stack[-4] + 0x1f) > stack[-1])) // Inputs[6] // { // @1C3F stack[-1] // @1C40 stack[-6] // @1C41 stack[-2] // @1C43 stack[-4] // @1C46 stack[-5] // @1C49 stack[-7] // } 1C3C 5B JUMPDEST 1C3D 60 PUSH1 0x40 1C3F 52 MSTORE 1C40 84 DUP5 1C41 81 DUP2 1C42 52 MSTORE 1C43 91 SWAP2 1C44 50 POP 1C45 81 DUP2 1C46 83 DUP4 1C47 85 DUP6 1C48 01 ADD 1C49 86 DUP7 1C4A 10 LT 1C4B 15 ISZERO 1C4C 61 PUSH2 0x1c54 1C4F 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @1C3F memory[0x40:0x60] = stack[-1] // @1C42 memory[stack[-2]:stack[-2] + 0x20] = stack[-6] // @1C43 stack[-4] = stack[-2] // @1C45 stack[-2] = stack[-2] // } // Block ends with conditional jump to 0x1c54, if !(stack[-7] < stack[-6] + stack[-5]) label_1C50: // Incoming jump from 0x1C4F, if not !(stack[-7] < stack[-6] + stack[-5]) // Inputs[1] { @1C53 memory[0x00:0x00] } 1C50 60 PUSH1 0x00 1C52 80 DUP1 1C53 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C53 revert(memory[0x00:0x00]); } // Block terminates label_1C54: // Incoming jump from 0x1C4F, if !(stack[-7] < stack[-6] + stack[-5]) // Inputs[7] // { // @1C55 stack[-5] // @1C56 stack[-4] // @1C59 stack[-1] // @1C5B msg.data[stack[-4]:stack[-4] + stack[-5]] // @1C67 stack[-7] // @1C67 stack[-3] // @1C68 stack[-6] // } 1C54 5B JUMPDEST 1C55 84 DUP5 1C56 84 DUP5 1C57 60 PUSH1 0x20 1C59 83 DUP4 1C5A 01 ADD 1C5B 37 CALLDATACOPY 1C5C 60 PUSH1 0x00 1C5E 60 PUSH1 0x20 1C60 86 DUP7 1C61 83 DUP4 1C62 01 ADD 1C63 01 ADD 1C64 52 MSTORE 1C65 50 POP 1C66 50 POP 1C67 93 SWAP4 1C68 92 SWAP3 1C69 50 POP 1C6A 50 POP 1C6B 50 POP 1C6C 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @1C5B memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-5]] = msg.data[stack[-4]:stack[-4] + stack[-5]] // @1C64 memory[stack[-1] + stack[-5] + 0x20:stack[-1] + stack[-5] + 0x20 + 0x20] = 0x00 // @1C67 stack[-7] = stack[-3] // } // Block ends with unconditional jump to stack[-7] label_1C6D: // Incoming call from 0x1D28, returns to 0x1D29 // Incoming call from 0x1D36, returns to 0x1D37 // Incoming call from 0x1DD8, returns to 0x1DD9 // Incoming call from 0x1C9D, returns to 0x10A8 // Incoming call from 0x1D9E, returns to 0x1D9F // Incoming call from 0x1CC6, returns to 0x1CC7 // Incoming call from 0x1CFA, returns to 0x1CFB // Incoming call from 0x1CB8, returns to 0x1CB9 // Incoming call from 0x1CEC, returns to 0x1CED // Inputs[2] // { // @1C6E stack[-1] // @1C6F msg.data[stack[-1]:stack[-1] + 0x20] // } 1C6D 5B JUMPDEST 1C6E 80 DUP1 1C6F 35 CALLDATALOAD 1C70 60 PUSH1 0x01 1C72 60 PUSH1 0x01 1C74 60 PUSH1 0xa0 1C76 1B SHL 1C77 03 SUB 1C78 81 DUP2 1C79 16 AND 1C7A 81 DUP2 1C7B 14 EQ 1C7C 61 PUSH2 0x0606 1C7F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C6F stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0606, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1C80: // Incoming jump from 0x1C7F, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1C83 memory[0x00:0x00] } 1C80 60 PUSH1 0x00 1C82 80 DUP1 1C83 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C83 revert(memory[0x00:0x00]); } // Block terminates label_1C84: // Incoming call from 0x05CF, returns to 0x05D0 // Incoming call from 0x0505, returns to 0x0506 // Incoming call from 0x041E, returns to 0x041F // Incoming call from 0x0466, returns to 0x0467 // Inputs[2] // { // @1C89 stack[-1] // @1C8A stack[-2] // } 1C84 5B JUMPDEST 1C85 60 PUSH1 0x00 1C87 60 PUSH1 0x20 1C89 82 DUP3 1C8A 84 DUP5 1C8B 03 SUB 1C8C 12 SLT 1C8D 15 ISZERO 1C8E 61 PUSH2 0x1c95 1C91 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C85 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c95, if !(stack[-2] - stack[-1] i< 0x20) label_1C92: // Incoming jump from 0x1C91, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1C92 stack[-1] // @1C94 memory[stack[-1]:stack[-1] + stack[-1]] // } 1C92 80 DUP1 1C93 81 DUP2 1C94 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C94 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1C95: // Incoming jump from 0x1C91, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1C99 stack[-2] } 1C95 5B JUMPDEST 1C96 61 PUSH2 0x10a8 1C99 82 DUP3 1C9A 61 PUSH2 0x1c6d 1C9D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C96 stack[0] = 0x10a8 // @1C99 stack[1] = stack[-2] // } // Block ends with call to 0x1c6d, returns to 0x10A8 label_1C9E: // Incoming call from 0x05AF, returns to 0x05B0 // Inputs[2] // { // @1CA4 stack[-1] // @1CA5 stack[-2] // } 1C9E 5B JUMPDEST 1C9F 60 PUSH1 0x00 1CA1 80 DUP1 1CA2 60 PUSH1 0x40 1CA4 83 DUP4 1CA5 85 DUP6 1CA6 03 SUB 1CA7 12 SLT 1CA8 15 ISZERO 1CA9 61 PUSH2 0x1cb0 1CAC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C9F stack[0] = 0x00 // @1CA1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1cb0, if !(stack[-2] - stack[-1] i< 0x40) label_1CAD: // Incoming jump from 0x1CAC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1CAD stack[-1] // @1CAF memory[stack[-1]:stack[-1] + stack[-1]] // } 1CAD 80 DUP1 1CAE 81 DUP2 1CAF FD *REVERT // Stack delta = +0 // Outputs[1] { @1CAF revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1CB0: // Incoming jump from 0x1CAC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1CB4 stack[-3] } 1CB0 5B JUMPDEST 1CB1 61 PUSH2 0x1cb9 1CB4 83 DUP4 1CB5 61 PUSH2 0x1c6d 1CB8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1CB1 stack[0] = 0x1cb9 // @1CB4 stack[1] = stack[-3] // } // Block ends with call to 0x1c6d, returns to 0x1CB9 label_1CB9: // Incoming return from call to 0x1C6D at 0x1CB8 // Inputs[3] // { // @1CBA stack[-1] // @1CBA stack[-3] // @1CC1 stack[-4] // } 1CB9 5B JUMPDEST 1CBA 91 SWAP2 1CBB 50 POP 1CBC 61 PUSH2 0x1cc7 1CBF 60 PUSH1 0x20 1CC1 84 DUP5 1CC2 01 ADD 1CC3 61 PUSH2 0x1c6d 1CC6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1CBA stack[-3] = stack[-1] // @1CBC stack[-1] = 0x1cc7 // @1CC2 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1c6d, returns to 0x1CC7 label_1CC7: // Incoming return from call to 0x1C6D at 0x1CC6 // Inputs[6] // { // @1CC8 stack[-2] // @1CC8 stack[-1] // @1CCA stack[-5] // @1CCC stack[-3] // @1CCC stack[-6] // @1CCD stack[-4] // } 1CC7 5B JUMPDEST 1CC8 90 SWAP1 1CC9 50 POP 1CCA 92 SWAP3 1CCB 50 POP 1CCC 92 SWAP3 1CCD 90 SWAP1 1CCE 50 POP 1CCF 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1CCA stack[-5] = stack[-1] // @1CCC stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1CD0: // Incoming call from 0x0389, returns to 0x038A // Incoming call from 0x030A, returns to 0x030B // Inputs[2] // { // @1CD8 stack[-1] // @1CD9 stack[-2] // } 1CD0 5B JUMPDEST 1CD1 60 PUSH1 0x00 1CD3 80 DUP1 1CD4 60 PUSH1 0x00 1CD6 60 PUSH1 0x60 1CD8 84 DUP5 1CD9 86 DUP7 1CDA 03 SUB 1CDB 12 SLT 1CDC 15 ISZERO 1CDD 61 PUSH2 0x1ce4 1CE0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1CD1 stack[0] = 0x00 // @1CD3 stack[1] = 0x00 // @1CD4 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ce4, if !(stack[-2] - stack[-1] i< 0x60) label_1CE1: // Incoming jump from 0x1CE0, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1CE1 stack[-1] // @1CE3 memory[stack[-1]:stack[-1] + stack[-1]] // } 1CE1 80 DUP1 1CE2 81 DUP2 1CE3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CE3 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1CE4: // Incoming jump from 0x1CE0, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1CE8 stack[-4] } 1CE4 5B JUMPDEST 1CE5 61 PUSH2 0x1ced 1CE8 84 DUP5 1CE9 61 PUSH2 0x1c6d 1CEC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1CE5 stack[0] = 0x1ced // @1CE8 stack[1] = stack[-4] // } // Block ends with call to 0x1c6d, returns to 0x1CED label_1CED: // Incoming return from call to 0x1C6D at 0x1CEC // Inputs[3] // { // @1CEE stack[-4] // @1CEE stack[-1] // @1CF5 stack[-5] // } 1CED 5B JUMPDEST 1CEE 92 SWAP3 1CEF 50 POP 1CF0 61 PUSH2 0x1cfb 1CF3 60 PUSH1 0x20 1CF5 85 DUP6 1CF6 01 ADD 1CF7 61 PUSH2 0x1c6d 1CFA 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1CEE stack[-4] = stack[-1] // @1CF0 stack[-1] = 0x1cfb // @1CF6 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1c6d, returns to 0x1CFB label_1CFB: // Incoming return from call to 0x1C6D at 0x1CFA // Inputs[8] // { // @1CFC stack[-1] // @1CFC stack[-3] // @1D00 stack[-5] // @1D02 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1D03 stack[-2] // @1D07 stack[-6] // @1D09 stack[-7] // @1D09 stack[-4] // } 1CFB 5B JUMPDEST 1CFC 91 SWAP2 1CFD 50 POP 1CFE 60 PUSH1 0x40 1D00 84 DUP5 1D01 01 ADD 1D02 35 CALLDATALOAD 1D03 90 SWAP1 1D04 50 POP 1D05 92 SWAP3 1D06 50 POP 1D07 92 SWAP3 1D08 50 POP 1D09 92 SWAP3 1D0A 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1D05 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1D07 stack[-6] = stack[-1] // @1D09 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1D0B: // Incoming call from 0x054F, returns to 0x0550 // Inputs[2] // { // @1D14 stack[-1] // @1D15 stack[-2] // } 1D0B 5B JUMPDEST 1D0C 60 PUSH1 0x00 1D0E 80 DUP1 1D0F 60 PUSH1 0x00 1D11 80 DUP1 1D12 60 PUSH1 0x80 1D14 85 DUP6 1D15 87 DUP8 1D16 03 SUB 1D17 12 SLT 1D18 15 ISZERO 1D19 61 PUSH2 0x1d20 1D1C 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1D0C stack[0] = 0x00 // @1D0E stack[1] = 0x00 // @1D0F stack[2] = 0x00 // @1D11 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1d20, if !(stack[-2] - stack[-1] i< 0x80) label_1D1D: // Incoming jump from 0x1D1C, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @1D1D stack[-1] // @1D1F memory[stack[-1]:stack[-1] + stack[-1]] // } 1D1D 80 DUP1 1D1E 81 DUP2 1D1F FD *REVERT // Stack delta = +0 // Outputs[1] { @1D1F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1D20: // Incoming jump from 0x1D1C, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1D24 stack[-5] } 1D20 5B JUMPDEST 1D21 61 PUSH2 0x1d29 1D24 85 DUP6 1D25 61 PUSH2 0x1c6d 1D28 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D21 stack[0] = 0x1d29 // @1D24 stack[1] = stack[-5] // } // Block ends with call to 0x1c6d, returns to 0x1D29 label_1D29: // Incoming return from call to 0x1C6D at 0x1D28 // Inputs[3] // { // @1D2A stack[-5] // @1D2A stack[-1] // @1D31 stack[-6] // } 1D29 5B JUMPDEST 1D2A 93 SWAP4 1D2B 50 POP 1D2C 61 PUSH2 0x1d37 1D2F 60 PUSH1 0x20 1D31 86 DUP7 1D32 01 ADD 1D33 61 PUSH2 0x1c6d 1D36 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D2A stack[-5] = stack[-1] // @1D2C stack[-1] = 0x1d37 // @1D32 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1c6d, returns to 0x1D37 label_1D37: // Incoming return from call to 0x1C6D at 0x1D36 // Inputs[6] // { // @1D38 stack[-4] // @1D38 stack[-1] // @1D3C stack[-6] // @1D3E msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1D3F stack[-3] // @1D45 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 1D37 5B JUMPDEST 1D38 92 SWAP3 1D39 50 POP 1D3A 60 PUSH1 0x40 1D3C 85 DUP6 1D3D 01 ADD 1D3E 35 CALLDATALOAD 1D3F 91 SWAP2 1D40 50 POP 1D41 60 PUSH1 0x60 1D43 85 DUP6 1D44 01 ADD 1D45 35 CALLDATALOAD 1D46 67 PUSH8 0xffffffffffffffff 1D4F 81 DUP2 1D50 11 GT 1D51 15 ISZERO 1D52 61 PUSH2 0x1d59 1D55 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1D38 stack[-4] = stack[-1] // @1D3F stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @1D45 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1d59, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_1D56: // Incoming jump from 0x1D55, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1D56 stack[-2] // @1D58 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D56 81 DUP2 1D57 82 DUP3 1D58 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D58 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1D59: // Incoming jump from 0x1D55, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1D5A stack[-6] // @1D5B stack[-1] // @1D60 stack[-7] // } 1D59 5B JUMPDEST 1D5A 85 DUP6 1D5B 01 ADD 1D5C 60 PUSH1 0x1f 1D5E 81 DUP2 1D5F 01 ADD 1D60 87 DUP8 1D61 13 SGT 1D62 61 PUSH2 0x1d69 1D65 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1D5B stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x1d69, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_1D66: // Incoming jump from 0x1D65, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[2] // { // @1D66 stack[-2] // @1D68 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D66 81 DUP2 1D67 82 DUP3 1D68 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D68 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1D69: // Incoming jump from 0x1D65, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @1D6D stack[-7] // @1D6E stack[-1] // @1D6F msg.data[stack[-1]:stack[-1] + 0x20] // } 1D69 5B JUMPDEST 1D6A 61 PUSH2 0x1d78 1D6D 87 DUP8 1D6E 82 DUP3 1D6F 35 CALLDATALOAD 1D70 60 PUSH1 0x20 1D72 84 DUP5 1D73 01 ADD 1D74 61 PUSH2 0x1bfd 1D77 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D6A stack[0] = 0x1d78 // @1D6D stack[1] = stack[-7] // @1D6F stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1D73 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1bfd, returns to 0x1D78 label_1D78: // Incoming return from call to 0x1BFD at 0x1D77 // Inputs[8] // { // @1D79 stack[-1] // @1D79 stack[-3] // @1D7C stack[-6] // @1D7D stack[-9] // @1D7E stack[-5] // @1D7F stack[-8] // @1D81 stack[-4] // @1D81 stack[-7] // } 1D78 5B JUMPDEST 1D79 91 SWAP2 1D7A 50 POP 1D7B 50 POP 1D7C 92 SWAP3 1D7D 95 SWAP6 1D7E 91 SWAP2 1D7F 94 SWAP5 1D80 50 POP 1D81 92 SWAP3 1D82 50 POP 1D83 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @1D7C stack[-6] = stack[-1] // @1D7D stack[-9] = stack[-6] // @1D7F stack[-8] = stack[-5] // @1D81 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_1D84: // Incoming call from 0x04E5, returns to 0x04E6 // Inputs[2] // { // @1D8A stack[-1] // @1D8B stack[-2] // } 1D84 5B JUMPDEST 1D85 60 PUSH1 0x00 1D87 80 DUP1 1D88 60 PUSH1 0x40 1D8A 83 DUP4 1D8B 85 DUP6 1D8C 03 SUB 1D8D 12 SLT 1D8E 15 ISZERO 1D8F 61 PUSH2 0x1d96 1D92 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D85 stack[0] = 0x00 // @1D87 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d96, if !(stack[-2] - stack[-1] i< 0x40) label_1D93: // Incoming jump from 0x1D92, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D93 stack[-2] // @1D95 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D93 81 DUP2 1D94 82 DUP3 1D95 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D95 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1D96: // Incoming jump from 0x1D92, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D9A stack[-3] } 1D96 5B JUMPDEST 1D97 61 PUSH2 0x1d9f 1D9A 83 DUP4 1D9B 61 PUSH2 0x1c6d 1D9E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D97 stack[0] = 0x1d9f // @1D9A stack[1] = stack[-3] // } // Block ends with call to 0x1c6d, returns to 0x1D9F label_1D9F: // Incoming return from call to 0x1C6D at 0x1D9E // Inputs[4] // { // @1DA0 stack[-1] // @1DA0 stack[-3] // @1DA4 stack[-4] // @1DA6 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1D9F 5B JUMPDEST 1DA0 91 SWAP2 1DA1 50 POP 1DA2 60 PUSH1 0x20 1DA4 83 DUP4 1DA5 01 ADD 1DA6 35 CALLDATALOAD 1DA7 80 DUP1 1DA8 15 ISZERO 1DA9 15 ISZERO 1DAA 81 DUP2 1DAB 14 EQ 1DAC 61 PUSH2 0x1db3 1DAF 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1DA0 stack[-3] = stack[-1] // @1DA6 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1db3, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1DB0: // Incoming jump from 0x1DAF, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @1DB0 stack[-2] // @1DB2 memory[stack[-2]:stack[-2] + stack[-2]] // } 1DB0 81 DUP2 1DB1 82 DUP3 1DB2 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DB2 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1DB3: // Incoming jump from 0x1DAF, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1DB4 stack[-1] // @1DB5 stack[-2] // @1DB8 stack[-5] // @1DBA stack[-3] // @1DBA stack[-6] // @1DBB stack[-4] // } 1DB3 5B JUMPDEST 1DB4 80 DUP1 1DB5 91 SWAP2 1DB6 50 POP 1DB7 50 POP 1DB8 92 SWAP3 1DB9 50 POP 1DBA 92 SWAP3 1DBB 90 SWAP1 1DBC 50 POP 1DBD 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1DB8 stack[-5] = stack[-1] // @1DBA stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1DBE: // Incoming call from 0x033F, returns to 0x0340 // Incoming call from 0x02B1, returns to 0x02B2 // Inputs[2] // { // @1DC4 stack[-1] // @1DC5 stack[-2] // } 1DBE 5B JUMPDEST 1DBF 60 PUSH1 0x00 1DC1 80 DUP1 1DC2 60 PUSH1 0x40 1DC4 83 DUP4 1DC5 85 DUP6 1DC6 03 SUB 1DC7 12 SLT 1DC8 15 ISZERO 1DC9 61 PUSH2 0x1dd0 1DCC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DBF stack[0] = 0x00 // @1DC1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1dd0, if !(stack[-2] - stack[-1] i< 0x40) label_1DCD: // Incoming jump from 0x1DCC, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DCD stack[-2] // @1DCF memory[stack[-2]:stack[-2] + stack[-2]] // } 1DCD 81 DUP2 1DCE 82 DUP3 1DCF FD *REVERT // Stack delta = +0 // Outputs[1] { @1DCF revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1DD0: // Incoming jump from 0x1DCC, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1DD4 stack[-3] } 1DD0 5B JUMPDEST 1DD1 61 PUSH2 0x1dd9 1DD4 83 DUP4 1DD5 61 PUSH2 0x1c6d 1DD8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DD1 stack[0] = 0x1dd9 // @1DD4 stack[1] = stack[-3] // } // Block ends with call to 0x1c6d, returns to 0x1DD9 label_1DD9: // Incoming return from call to 0x1C6D at 0x1DD8 // Inputs[5] // { // @1DDA stack[-6] // @1DDA stack[-1] // @1DDD stack[-4] // @1DE1 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1DE2 stack[-5] // } 1DD9 5B JUMPDEST 1DDA 94 SWAP5 1DDB 60 PUSH1 0x20 1DDD 93 SWAP4 1DDE 90 SWAP1 1DDF 93 SWAP4 1DE0 01 ADD 1DE1 35 CALLDATALOAD 1DE2 93 SWAP4 1DE3 50 POP 1DE4 50 POP 1DE5 50 POP 1DE6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1DDA stack[-6] = stack[-1] // @1DE2 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1DE7: // Incoming call from 0x0242, returns to 0x0243 // Inputs[2] // { // @1DEC stack[-1] // @1DED stack[-2] // } 1DE7 5B JUMPDEST 1DE8 60 PUSH1 0x00 1DEA 60 PUSH1 0x20 1DEC 82 DUP3 1DED 84 DUP5 1DEE 03 SUB 1DEF 12 SLT 1DF0 15 ISZERO 1DF1 61 PUSH2 0x1df8 1DF4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DE8 stack[0] = 0x00 } // Block ends with conditional jump to 0x1df8, if !(stack[-2] - stack[-1] i< 0x20) label_1DF5: // Incoming jump from 0x1DF4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1DF5 stack[-1] // @1DF7 memory[stack[-1]:stack[-1] + stack[-1]] // } 1DF5 80 DUP1 1DF6 81 DUP2 1DF7 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DF7 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1DF8: // Incoming jump from 0x1DF4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1DF9 stack[-2] // @1DFA msg.data[stack[-2]:stack[-2] + 0x20] // } 1DF8 5B JUMPDEST 1DF9 81 DUP2 1DFA 35 CALLDATALOAD 1DFB 61 PUSH2 0x10a8 1DFE 81 DUP2 1DFF 61 PUSH2 0x2764 1E02 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DFA stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1DFB stack[1] = 0x10a8 // @1DFE stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2764, returns to 0x10A8 1E03 5B JUMPDEST 1E04 60 PUSH1 0x00 1E06 60 PUSH1 0x20 1E08 82 DUP3 1E09 84 DUP5 1E0A 03 SUB 1E0B 12 SLT 1E0C 15 ISZERO 1E0D 61 PUSH2 0x1e14 1E10 57 *JUMPI 1E11 80 DUP1 1E12 81 DUP2 1E13 FD *REVERT 1E14 5B JUMPDEST 1E15 81 DUP2 1E16 51 MLOAD 1E17 61 PUSH2 0x10a8 1E1A 81 DUP2 1E1B 61 PUSH2 0x2764 1E1E 56 *JUMP label_1E1F: // Incoming call from 0x03C9, returns to 0x03CA // Inputs[2] // { // @1E24 stack[-1] // @1E25 stack[-2] // } 1E1F 5B JUMPDEST 1E20 60 PUSH1 0x00 1E22 60 PUSH1 0x20 1E24 82 DUP3 1E25 84 DUP5 1E26 03 SUB 1E27 12 SLT 1E28 15 ISZERO 1E29 61 PUSH2 0x1e30 1E2C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E20 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e30, if !(stack[-2] - stack[-1] i< 0x20) label_1E2D: // Incoming jump from 0x1E2C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E2D stack[-1] // @1E2F memory[stack[-1]:stack[-1] + stack[-1]] // } 1E2D 80 DUP1 1E2E 81 DUP2 1E2F FD *REVERT // Stack delta = +0 // Outputs[1] { @1E2F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1E30: // Incoming jump from 0x1E2C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E31 stack[-2] // @1E32 msg.data[stack[-2]:stack[-2] + 0x20] // } 1E30 5B JUMPDEST 1E31 81 DUP2 1E32 35 CALLDATALOAD 1E33 67 PUSH8 0xffffffffffffffff 1E3C 81 DUP2 1E3D 11 GT 1E3E 15 ISZERO 1E3F 61 PUSH2 0x1e46 1E42 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E32 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1e46, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1E43: // Incoming jump from 0x1E42, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1E43 stack[-2] // @1E45 memory[stack[-2]:stack[-2] + stack[-2]] // } 1E43 81 DUP2 1E44 82 DUP3 1E45 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E45 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1E46: // Incoming jump from 0x1E42, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1E47 stack[-3] // @1E48 stack[-1] // @1E4D stack[-4] // } 1E46 5B JUMPDEST 1E47 82 DUP3 1E48 01 ADD 1E49 60 PUSH1 0x1f 1E4B 81 DUP2 1E4C 01 ADD 1E4D 84 DUP5 1E4E 13 SGT 1E4F 61 PUSH2 0x1e56 1E52 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E48 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1e56, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1E53: // Incoming jump from 0x1E52, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @1E53 stack[-2] // @1E55 memory[stack[-2]:stack[-2] + stack[-2]] // } 1E53 81 DUP2 1E54 82 DUP3 1E55 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E55 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1E56: // Incoming jump from 0x1E52, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1E5A stack[-4] // @1E5B stack[-1] // @1E5C msg.data[stack[-1]:stack[-1] + 0x20] // } 1E56 5B JUMPDEST 1E57 61 PUSH2 0x137b 1E5A 84 DUP5 1E5B 82 DUP3 1E5C 35 CALLDATALOAD 1E5D 60 PUSH1 0x20 1E5F 84 DUP5 1E60 01 ADD 1E61 61 PUSH2 0x1bfd 1E64 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E57 stack[0] = 0x137b // @1E5A stack[1] = stack[-4] // @1E5C stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1E60 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1bfd, returns to 0x137B label_1E65: // Incoming call from 0x03A9, returns to 0x03AA // Incoming call from 0x056F, returns to 0x0570 // Incoming call from 0x04C5, returns to 0x04C6 // Incoming call from 0x03E9, returns to 0x03EA // Incoming call from 0x0446, returns to 0x0447 // Incoming call from 0x0284, returns to 0x0285 // Incoming call from 0x058F, returns to 0x0590 // Inputs[2] // { // @1E6A stack[-1] // @1E6B stack[-2] // } 1E65 5B JUMPDEST 1E66 60 PUSH1 0x00 1E68 60 PUSH1 0x20 1E6A 82 DUP3 1E6B 84 DUP5 1E6C 03 SUB 1E6D 12 SLT 1E6E 15 ISZERO 1E6F 61 PUSH2 0x1e76 1E72 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E66 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e76, if !(stack[-2] - stack[-1] i< 0x20) label_1E73: // Incoming jump from 0x1E72, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E73 stack[-1] // @1E75 memory[stack[-1]:stack[-1] + stack[-1]] // } 1E73 80 DUP1 1E74 81 DUP2 1E75 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E75 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1E76: // Incoming jump from 0x1E72, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1E78 msg.data[stack[-2]:stack[-2] + 0x20] // @1E78 stack[-2] // @1E79 stack[-4] // @1E7A stack[-3] // } 1E76 5B JUMPDEST 1E77 50 POP 1E78 35 CALLDATALOAD 1E79 91 SWAP2 1E7A 90 SWAP1 1E7B 50 POP 1E7C 56 *JUMP // Stack delta = -3 // Outputs[1] { @1E79 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1E7D: // Incoming call from 0x1F8D, returns to 0x10A8 // Inputs[3] // { // @1E80 stack[-1] // @1E81 memory[stack[-1]:stack[-1] + 0x20] // @1E83 stack[-2] // } 1E7D 5B JUMPDEST 1E7E 60 PUSH1 0x00 1E80 81 DUP2 1E81 51 MLOAD 1E82 80 DUP1 1E83 84 DUP5 1E84 52 MSTORE 1E85 61 PUSH2 0x1e95 1E88 81 DUP2 1E89 60 PUSH1 0x20 1E8B 86 DUP7 1E8C 01 ADD 1E8D 60 PUSH1 0x20 1E8F 86 DUP7 1E90 01 ADD 1E91 61 PUSH2 0x268c 1E94 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1E7E stack[0] = 0x00 // @1E81 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1E84 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1E85 stack[2] = 0x1e95 // @1E88 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1E8C stack[4] = stack[-2] + 0x20 // @1E90 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x268c, returns to 0x1E95 label_1E95: // Incoming return from call to 0x268C at 0x1E94 // Inputs[4] // { // @1E98 stack[-1] // @1E9D stack[-4] // @1E9E stack[-2] // @1EA4 stack[-5] // } 1E95 5B JUMPDEST 1E96 60 PUSH1 0x1f 1E98 01 ADD 1E99 60 PUSH1 0x1f 1E9B 19 NOT 1E9C 16 AND 1E9D 92 SWAP3 1E9E 90 SWAP1 1E9F 92 SWAP3 1EA0 01 ADD 1EA1 60 PUSH1 0x20 1EA3 01 ADD 1EA4 92 SWAP3 1EA5 91 SWAP2 1EA6 50 POP 1EA7 50 POP 1EA8 56 *JUMP // Stack delta = -4 // Outputs[1] { @1EA4 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 1EA9 5B JUMPDEST 1EAA 60 PUSH1 0x00 1EAC 83 DUP4 1EAD 51 MLOAD 1EAE 61 PUSH2 0x1ebb 1EB1 81 DUP2 1EB2 84 DUP5 1EB3 60 PUSH1 0x20 1EB5 88 DUP9 1EB6 01 ADD 1EB7 61 PUSH2 0x268c 1EBA 56 *JUMP 1EBB 5B JUMPDEST 1EBC 83 DUP4 1EBD 51 MLOAD 1EBE 90 SWAP1 1EBF 83 DUP4 1EC0 01 ADD 1EC1 90 SWAP1 1EC2 61 PUSH2 0x1ecf 1EC5 81 DUP2 1EC6 83 DUP4 1EC7 60 PUSH1 0x20 1EC9 88 DUP9 1ECA 01 ADD 1ECB 61 PUSH2 0x268c 1ECE 56 *JUMP 1ECF 5B JUMPDEST 1ED0 01 ADD 1ED1 94 SWAP5 1ED2 93 SWAP4 1ED3 50 POP 1ED4 50 POP 1ED5 50 POP 1ED6 50 POP 1ED7 56 *JUMP label_1ED8: // Incoming call from 0x08D6, returns to 0x08D7 // Inputs[2] // { // @1ED9 stack[-1] // @1ED9 stack[-2] // } 1ED8 5B JUMPDEST 1ED9 90 SWAP1 1EDA 56 *JUMP // Stack delta = -1 // Outputs[1] { @1ED9 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1EDB: // Incoming call from 0x0296, returns to 0x021F // Inputs[3] // { // @1EE4 stack[-2] // @1EE5 stack[-1] // @1EED stack[-3] // } 1EDB 5B JUMPDEST 1EDC 60 PUSH1 0x01 1EDE 60 PUSH1 0x01 1EE0 60 PUSH1 0xa0 1EE2 1B SHL 1EE3 03 SUB 1EE4 91 SWAP2 1EE5 90 SWAP1 1EE6 91 SWAP2 1EE7 16 AND 1EE8 81 DUP2 1EE9 52 MSTORE 1EEA 60 PUSH1 0x20 1EEC 01 ADD 1EED 90 SWAP1 1EEE 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1EE9 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @1EED stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] 1EEF 5B JUMPDEST 1EF0 60 PUSH1 0x01 1EF2 60 PUSH1 0x01 1EF4 60 PUSH1 0xa0 1EF6 1B SHL 1EF7 03 SUB 1EF8 85 DUP6 1EF9 81 DUP2 1EFA 16 AND 1EFB 82 DUP3 1EFC 52 MSTORE 1EFD 84 DUP5 1EFE 16 AND 1EFF 60 PUSH1 0x20 1F01 82 DUP3 1F02 01 ADD 1F03 52 MSTORE 1F04 60 PUSH1 0x40 1F06 81 DUP2 1F07 01 ADD 1F08 83 DUP4 1F09 90 SWAP1 1F0A 52 MSTORE 1F0B 60 PUSH1 0x80 1F0D 60 PUSH1 0x60 1F0F 82 DUP3 1F10 01 ADD 1F11 81 DUP2 1F12 90 SWAP1 1F13 52 MSTORE 1F14 60 PUSH1 0x00 1F16 90 SWAP1 1F17 61 PUSH2 0x1f22 1F1A 90 SWAP1 1F1B 83 DUP4 1F1C 01 ADD 1F1D 84 DUP5 1F1E 61 PUSH2 0x1e7d 1F21 56 *JUMP 1F22 5B JUMPDEST 1F23 96 SWAP7 1F24 95 SWAP6 1F25 50 POP 1F26 50 POP 1F27 50 POP 1F28 50 POP 1F29 50 POP 1F2A 50 POP 1F2B 56 *JUMP label_1F2C: // Incoming call from 0x0478, returns to 0x021F // Inputs[3] // { // @1F30 stack[-1] // @1F32 stack[-2] // @1F33 memory[stack[-2]:stack[-2] + 0x20] // } 1F2C 5B JUMPDEST 1F2D 60 PUSH1 0x20 1F2F 80 DUP1 1F30 82 DUP3 1F31 52 MSTORE 1F32 82 DUP3 1F33 51 MLOAD 1F34 82 DUP3 1F35 82 DUP3 1F36 01 ADD 1F37 81 DUP2 1F38 90 SWAP1 1F39 52 MSTORE 1F3A 60 PUSH1 0x00 1F3C 91 SWAP2 1F3D 90 SWAP1 1F3E 84 DUP5 1F3F 82 DUP3 1F40 01 ADD 1F41 90 SWAP1 1F42 60 PUSH1 0x40 1F44 85 DUP6 1F45 01 ADD 1F46 90 SWAP1 1F47 84 DUP5 1F48 5B JUMPDEST 1F49 81 DUP2 1F4A 81 DUP2 1F4B 10 LT 1F4C 15 ISZERO 1F4D 61 PUSH2 0x1f64 1F50 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @1F31 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1F39 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1F3C stack[0] = 0x00 // @1F3D stack[1] = 0x20 // @1F41 stack[2] = 0x20 + stack[-2] // @1F46 stack[3] = stack[-1] + 0x40 // @1F46 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @1F47 stack[5] = 0x00 // } // Block ends with conditional jump to 0x1f64, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1F51: // Incoming jump from 0x1F50, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1F50, if not !(stack[-1] < stack[-2]) // Inputs[5] // { // @1F51 stack[-4] // @1F52 memory[stack[-4]:stack[-4] + 0x20] // @1F53 stack[-3] // @1F55 stack[-1] // @1F56 stack[-5] // } 1F51 83 DUP4 1F52 51 MLOAD 1F53 83 DUP4 1F54 52 MSTORE 1F55 92 SWAP3 1F56 84 DUP5 1F57 01 ADD 1F58 92 SWAP3 1F59 91 SWAP2 1F5A 84 DUP5 1F5B 01 ADD 1F5C 91 SWAP2 1F5D 60 PUSH1 0x01 1F5F 01 ADD 1F60 61 PUSH2 0x1f48 1F63 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1F54 memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @1F58 stack[-4] = stack[-5] + stack[-4] // @1F5C stack[-3] = stack[-5] + stack[-3] // @1F5F stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1f48 label_1F64: // Incoming jump from 0x1F50, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1F50, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @1F66 stack[-2] // @1F66 stack[-3] // @1F67 stack[-9] // @1F68 stack[-8] // } 1F64 5B JUMPDEST 1F65 50 POP 1F66 90 SWAP1 1F67 96 SWAP7 1F68 95 SWAP6 1F69 50 POP 1F6A 50 POP 1F6B 50 POP 1F6C 50 POP 1F6D 50 POP 1F6E 50 POP 1F6F 56 *JUMP // Stack delta = -8 // Outputs[1] { @1F67 stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] label_1F70: // Incoming call from 0x0F72, returns to 0x0F73 // Incoming call from 0x021E, returns to 0x021F // Inputs[3] // { // @1F71 stack[-2] // @1F71 stack[-1] // @1F79 stack[-3] // } 1F70 5B JUMPDEST 1F71 90 SWAP1 1F72 15 ISZERO 1F73 15 ISZERO 1F74 81 DUP2 1F75 52 MSTORE 1F76 60 PUSH1 0x20 1F78 01 ADD 1F79 90 SWAP1 1F7A 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1F75 memory[stack[-1]:stack[-1] + 0x20] = !!stack[-2] // @1F79 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_1F7B: // Incoming jump from 0x0269 // Inputs[2] // { // @1F80 stack[-1] // @1F89 stack[-2] // } 1F7B 5B JUMPDEST 1F7C 60 PUSH1 0x00 1F7E 60 PUSH1 0x20 1F80 82 DUP3 1F81 52 MSTORE 1F82 61 PUSH2 0x10a8 1F85 60 PUSH1 0x20 1F87 83 DUP4 1F88 01 ADD 1F89 84 DUP5 1F8A 61 PUSH2 0x1e7d 1F8D 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1F7C stack[0] = 0x00 // @1F81 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1F82 stack[1] = 0x10a8 // @1F88 stack[2] = stack[-1] + 0x20 // @1F89 stack[3] = stack[-2] // } // Block ends with call to 0x1e7d, returns to 0x10A8 label_1F8E: // Incoming call from 0x0B3D, returns to 0x06C4 // Inputs[2] // { // @1F92 stack[-1] // @1FB4 stack[-2] // } 1F8E 5B JUMPDEST 1F8F 60 PUSH1 0x20 1F91 80 DUP1 1F92 82 DUP3 1F93 52 MSTORE 1F94 60 PUSH1 0x0e 1F96 90 SWAP1 1F97 82 DUP3 1F98 01 ADD 1F99 52 MSTORE 1F9A 6D PUSH14 0x14149154d0531157d0d313d4d151 1FA9 60 PUSH1 0x92 1FAB 1B SHL 1FAC 60 PUSH1 0x40 1FAE 82 DUP3 1FAF 01 ADD 1FB0 52 MSTORE 1FB1 60 PUSH1 0x60 1FB3 01 ADD 1FB4 90 SWAP1 1FB5 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1F93 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1F99 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0e // @1FB0 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x14149154d0531157d0d313d4d151 << 0x92 // @1FB4 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 1FB6 5B JUMPDEST 1FB7 60 PUSH1 0x20 1FB9 80 DUP1 1FBA 82 DUP3 1FBB 52 MSTORE 1FBC 60 PUSH1 0x0e 1FBE 90 SWAP1 1FBF 82 DUP3 1FC0 01 ADD 1FC1 52 MSTORE 1FC2 6D PUSH14 0x50524553414c455f535550504c59 1FD1 60 PUSH1 0x90 1FD3 1B SHL 1FD4 60 PUSH1 0x40 1FD6 82 DUP3 1FD7 01 ADD 1FD8 52 MSTORE 1FD9 60 PUSH1 0x60 1FDB 01 ADD 1FDC 90 SWAP1 1FDD 56 *JUMP 1FDE 5B JUMPDEST 1FDF 60 PUSH1 0x20 1FE1 80 DUP1 1FE2 82 DUP3 1FE3 52 MSTORE 1FE4 60 PUSH1 0x10 1FE6 90 SWAP1 1FE7 82 DUP3 1FE8 01 ADD 1FE9 52 MSTORE 1FEA 6F PUSH16 0x2727aa2fa2a727aaa3a42fa2aa2422a9 1FFB 60 PUSH1 0x81 1FFD 1B SHL 1FFE 60 PUSH1 0x40 2000 82 DUP3 2001 01 ADD 2002 52 MSTORE 2003 60 PUSH1 0x60 2005 01 ADD 2006 90 SWAP1 2007 56 *JUMP label_2008: // Incoming call from 0x0848, returns to 0x06C4 // Inputs[2] // { // @200C stack[-1] // @2051 stack[-2] // } 2008 5B JUMPDEST 2009 60 PUSH1 0x20 200B 80 DUP1 200C 82 DUP3 200D 52 MSTORE 200E 60 PUSH1 0x2b 2010 90 SWAP1 2011 82 DUP3 2012 01 ADD 2013 52 MSTORE 2014 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 2035 60 PUSH1 0x40 2037 82 DUP3 2038 01 ADD 2039 52 MSTORE 203A 6A PUSH11 0x74206f6620626f756e6473 2046 60 PUSH1 0xa8 2048 1B SHL 2049 60 PUSH1 0x60 204B 82 DUP3 204C 01 ADD 204D 52 MSTORE 204E 60 PUSH1 0x80 2050 01 ADD 2051 90 SWAP1 2052 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @200D memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2013 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2b // @2039 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 // @204D memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x74206f6620626f756e6473 << 0xa8 // @2051 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 2053 5B JUMPDEST 2054 60 PUSH1 0x20 2056 80 DUP1 2057 82 DUP3 2058 52 MSTORE 2059 60 PUSH1 0x32 205B 90 SWAP1 205C 82 DUP3 205D 01 ADD 205E 52 MSTORE 205F 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 2080 60 PUSH1 0x40 2082 82 DUP3 2083 01 ADD 2084 52 MSTORE 2085 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 2098 60 PUSH1 0x71 209A 1B SHL 209B 60 PUSH1 0x60 209D 82 DUP3 209E 01 ADD 209F 52 MSTORE 20A0 60 PUSH1 0x80 20A2 01 ADD 20A3 90 SWAP1 20A4 56 *JUMP label_20A5: // Incoming call from 0x1225, returns to 0x06C4 // Inputs[2] // { // @20A9 stack[-1] // @20E9 stack[-2] // } 20A5 5B JUMPDEST 20A6 60 PUSH1 0x20 20A8 80 DUP1 20A9 82 DUP3 20AA 52 MSTORE 20AB 60 PUSH1 0x26 20AD 90 SWAP1 20AE 82 DUP3 20AF 01 ADD 20B0 52 MSTORE 20B1 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 20D2 60 PUSH1 0x40 20D4 82 DUP3 20D5 01 ADD 20D6 52 MSTORE 20D7 65 PUSH6 0x646472657373 20DE 60 PUSH1 0xd0 20E0 1B SHL 20E1 60 PUSH1 0x60 20E3 82 DUP3 20E4 01 ADD 20E5 52 MSTORE 20E6 60 PUSH1 0x80 20E8 01 ADD 20E9 90 SWAP1 20EA 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @20AA memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @20B0 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x26 // @20D6 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @20E5 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x646472657373 << 0xd0 // @20E9 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 20EB 5B JUMPDEST 20EC 60 PUSH1 0x20 20EE 80 DUP1 20EF 82 DUP3 20F0 52 MSTORE 20F1 60 PUSH1 0x1c 20F3 90 SWAP1 20F4 82 DUP3 20F5 01 ADD 20F6 52 MSTORE 20F7 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 2118 60 PUSH1 0x40 211A 82 DUP3 211B 01 ADD 211C 52 MSTORE 211D 60 PUSH1 0x60 211F 01 ADD 2120 90 SWAP1 2121 56 *JUMP 2122 5B JUMPDEST 2123 60 PUSH1 0x20 2125 80 DUP1 2126 82 DUP3 2127 52 MSTORE 2128 60 PUSH1 0x0c 212A 90 SWAP1 212B 82 DUP3 212C 01 ADD 212D 52 MSTORE 212E 6B PUSH12 0x544f54414c5f535550504c59 213B 60 PUSH1 0xa0 213D 1B SHL 213E 60 PUSH1 0x40 2140 82 DUP3 2141 01 ADD 2142 52 MSTORE 2143 60 PUSH1 0x60 2145 01 ADD 2146 90 SWAP1 2147 56 *JUMP 2148 5B JUMPDEST 2149 60 PUSH1 0x20 214B 80 DUP1 214C 82 DUP3 214D 52 MSTORE 214E 60 PUSH1 0x24 2150 90 SWAP1 2151 82 DUP3 2152 01 ADD 2153 52 MSTORE 2154 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 2175 60 PUSH1 0x40 2177 82 DUP3 2178 01 ADD 2179 52 MSTORE 217A 63 PUSH4 0x72657373 217F 60 PUSH1 0xe0 2181 1B SHL 2182 60 PUSH1 0x60 2184 82 DUP3 2185 01 ADD 2186 52 MSTORE 2187 60 PUSH1 0x80 2189 01 ADD 218A 90 SWAP1 218B 56 *JUMP label_218C: // Incoming call from 0x0EE9, returns to 0x06C4 // Inputs[2] // { // @2190 stack[-1] // @21C1 stack[-2] // } 218C 5B JUMPDEST 218D 60 PUSH1 0x20 218F 80 DUP1 2190 82 DUP3 2191 52 MSTORE 2192 60 PUSH1 0x19 2194 90 SWAP1 2195 82 DUP3 2196 01 ADD 2197 52 MSTORE 2198 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 21B9 60 PUSH1 0x40 21BB 82 DUP3 21BC 01 ADD 21BD 52 MSTORE 21BE 60 PUSH1 0x60 21C0 01 ADD 21C1 90 SWAP1 21C2 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2191 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2197 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x19 // @21BD memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @21C1 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_21C3: // Incoming call from 0x0DF6, returns to 0x06C4 // Inputs[2] // { // @21C7 stack[-1] // @21E6 stack[-2] // } 21C3 5B JUMPDEST 21C4 60 PUSH1 0x20 21C6 80 DUP1 21C7 82 DUP3 21C8 52 MSTORE 21C9 60 PUSH1 0x0b 21CB 90 SWAP1 21CC 82 DUP3 21CD 01 ADD 21CE 52 MSTORE 21CF 6A PUSH11 0x14d0531157d0d313d4d151 21DB 60 PUSH1 0xaa 21DD 1B SHL 21DE 60 PUSH1 0x40 21E0 82 DUP3 21E1 01 ADD 21E2 52 MSTORE 21E3 60 PUSH1 0x60 21E5 01 ADD 21E6 90 SWAP1 21E7 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @21C8 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @21CE memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0b // @21E2 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x14d0531157d0d313d4d151 << 0xaa // @21E6 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 21E8 5B JUMPDEST 21E9 60 PUSH1 0x20 21EB 80 DUP1 21EC 82 DUP3 21ED 52 MSTORE 21EE 60 PUSH1 0x0f 21F0 90 SWAP1 21F1 82 DUP3 21F2 01 ADD 21F3 52 MSTORE 21F4 6E PUSH15 0x09a82b0be9a929ca8bea08aa4bea8b 2204 60 PUSH1 0x8b 2206 1B SHL 2207 60 PUSH1 0x40 2209 82 DUP3 220A 01 ADD 220B 52 MSTORE 220C 60 PUSH1 0x60 220E 01 ADD 220F 90 SWAP1 2210 56 *JUMP label_2211: // Incoming call from 0x1324, returns to 0x06C4 // Inputs[2] // { // @2215 stack[-1] // @225B stack[-2] // } 2211 5B JUMPDEST 2212 60 PUSH1 0x20 2214 80 DUP1 2215 82 DUP3 2216 52 MSTORE 2217 60 PUSH1 0x2c 2219 90 SWAP1 221A 82 DUP3 221B 01 ADD 221C 52 MSTORE 221D 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 223E 60 PUSH1 0x40 2240 82 DUP3 2241 01 ADD 2242 52 MSTORE 2243 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 2250 60 PUSH1 0xa1 2252 1B SHL 2253 60 PUSH1 0x60 2255 82 DUP3 2256 01 ADD 2257 52 MSTORE 2258 60 PUSH1 0x80 225A 01 ADD 225B 90 SWAP1 225C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2216 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @221C memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2c // @2242 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @2257 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @225B stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 225D 5B JUMPDEST 225E 60 PUSH1 0x20 2260 80 DUP1 2261 82 DUP3 2262 52 MSTORE 2263 60 PUSH1 0x38 2265 90 SWAP1 2266 82 DUP3 2267 01 ADD 2268 52 MSTORE 2269 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 228A 60 PUSH1 0x40 228C 82 DUP3 228D 01 ADD 228E 52 MSTORE 228F 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 22B0 60 PUSH1 0x60 22B2 82 DUP3 22B3 01 ADD 22B4 52 MSTORE 22B5 60 PUSH1 0x80 22B7 01 ADD 22B8 90 SWAP1 22B9 56 *JUMP label_22BA: // Incoming call from 0x0A6B, returns to 0x06C4 // Inputs[2] // { // @22BE stack[-1] // @2302 stack[-2] // } 22BA 5B JUMPDEST 22BB 60 PUSH1 0x20 22BD 80 DUP1 22BE 82 DUP3 22BF 52 MSTORE 22C0 60 PUSH1 0x2a 22C2 90 SWAP1 22C3 82 DUP3 22C4 01 ADD 22C5 52 MSTORE 22C6 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 22E7 60 PUSH1 0x40 22E9 82 DUP3 22EA 01 ADD 22EB 52 MSTORE 22EC 69 PUSH10 0x726f2061646472657373 22F7 60 PUSH1 0xb0 22F9 1B SHL 22FA 60 PUSH1 0x60 22FC 82 DUP3 22FD 01 ADD 22FE 52 MSTORE 22FF 60 PUSH1 0x80 2301 01 ADD 2302 90 SWAP1 2303 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @22BF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @22C5 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2a // @22EB memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @22FE memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x726f2061646472657373 << 0xb0 // @2302 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2304: // Incoming call from 0x0A3D, returns to 0x06C4 // Inputs[2] // { // @2308 stack[-1] // @234B stack[-2] // } 2304 5B JUMPDEST 2305 60 PUSH1 0x20 2307 80 DUP1 2308 82 DUP3 2309 52 MSTORE 230A 60 PUSH1 0x29 230C 90 SWAP1 230D 82 DUP3 230E 01 ADD 230F 52 MSTORE 2310 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 2331 60 PUSH1 0x40 2333 82 DUP3 2334 01 ADD 2335 52 MSTORE 2336 68 PUSH9 0x32b73a103a37b5b2b7 2340 60 PUSH1 0xb9 2342 1B SHL 2343 60 PUSH1 0x60 2345 82 DUP3 2346 01 ADD 2347 52 MSTORE 2348 60 PUSH1 0x80 234A 01 ADD 234B 90 SWAP1 234C 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2309 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @230F memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x29 // @2335 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @2347 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x32b73a103a37b5b2b7 << 0xb9 // @234B stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 234D 5B JUMPDEST 234E 60 PUSH1 0x20 2350 80 DUP1 2351 82 DUP3 2352 52 MSTORE 2353 81 DUP2 2354 81 DUP2 2355 01 ADD 2356 52 MSTORE 2357 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 2378 60 PUSH1 0x40 237A 82 DUP3 237B 01 ADD 237C 52 MSTORE 237D 60 PUSH1 0x60 237F 01 ADD 2380 90 SWAP1 2381 56 *JUMP label_2382: // Incoming call from 0x06C3, returns to 0x06C4 // Inputs[2] // { // @2386 stack[-1] // @23CC stack[-2] // } 2382 5B JUMPDEST 2383 60 PUSH1 0x20 2385 80 DUP1 2386 82 DUP3 2387 52 MSTORE 2388 60 PUSH1 0x2c 238A 90 SWAP1 238B 82 DUP3 238C 01 ADD 238D 52 MSTORE 238E 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 23AF 60 PUSH1 0x40 23B1 82 DUP3 23B2 01 ADD 23B3 52 MSTORE 23B4 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 23C1 60 PUSH1 0xa1 23C3 1B SHL 23C4 60 PUSH1 0x60 23C6 82 DUP3 23C7 01 ADD 23C8 52 MSTORE 23C9 60 PUSH1 0x80 23CB 01 ADD 23CC 90 SWAP1 23CD 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2387 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @238D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2c // @23B3 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @23C8 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @23CC stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_23CE: // Incoming call from 0x11FF, returns to 0x06C4 // Incoming call from 0x09F1, returns to 0x06C4 // Incoming call from 0x08B6, returns to 0x06C4 // Incoming call from 0x10ED, returns to 0x06C4 // Incoming call from 0x0D98, returns to 0x06C4 // Incoming call from 0x0FD5, returns to 0x06C4 // Incoming call from 0x07BF, returns to 0x06C4 // Inputs[2] // { // @23D2 stack[-1] // @2401 stack[-2] // } 23CE 5B JUMPDEST 23CF 60 PUSH1 0x20 23D1 80 DUP1 23D2 82 DUP3 23D3 52 MSTORE 23D4 81 DUP2 23D5 81 DUP2 23D6 01 ADD 23D7 52 MSTORE 23D8 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 23F9 60 PUSH1 0x40 23FB 82 DUP3 23FC 01 ADD 23FD 52 MSTORE 23FE 60 PUSH1 0x60 2400 01 ADD 2401 90 SWAP1 2402 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @23D3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @23D7 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @23FD memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2401 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 2403 5B JUMPDEST 2404 60 PUSH1 0x20 2406 80 DUP1 2407 82 DUP3 2408 52 MSTORE 2409 60 PUSH1 0x29 240B 90 SWAP1 240C 82 DUP3 240D 01 ADD 240E 52 MSTORE 240F 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 2430 60 PUSH1 0x40 2432 82 DUP3 2433 01 ADD 2434 52 MSTORE 2435 68 PUSH9 0x39903737ba1037bbb7 243F 60 PUSH1 0xb9 2441 1B SHL 2442 60 PUSH1 0x60 2444 82 DUP3 2445 01 ADD 2446 52 MSTORE 2447 60 PUSH1 0x80 2449 01 ADD 244A 90 SWAP1 244B 56 *JUMP label_244C: // Incoming call from 0x1052, returns to 0x06C4 // Inputs[2] // { // @2450 stack[-1] // @2499 stack[-2] // } 244C 5B JUMPDEST 244D 60 PUSH1 0x20 244F 80 DUP1 2450 82 DUP3 2451 52 MSTORE 2452 60 PUSH1 0x2f 2454 90 SWAP1 2455 82 DUP3 2456 01 ADD 2457 52 MSTORE 2458 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 2479 60 PUSH1 0x40 247B 82 DUP3 247C 01 ADD 247D 52 MSTORE 247E 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 248E 60 PUSH1 0x89 2490 1B SHL 2491 60 PUSH1 0x60 2493 82 DUP3 2494 01 ADD 2495 52 MSTORE 2496 60 PUSH1 0x80 2498 01 ADD 2499 90 SWAP1 249A 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2451 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2457 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2f // @247D memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @2495 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @2499 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 249B 5B JUMPDEST 249C 60 PUSH1 0x20 249E 80 DUP1 249F 82 DUP3 24A0 52 MSTORE 24A1 60 PUSH1 0x21 24A3 90 SWAP1 24A4 82 DUP3 24A5 01 ADD 24A6 52 MSTORE 24A7 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 24C8 60 PUSH1 0x40 24CA 82 DUP3 24CB 01 ADD 24CC 52 MSTORE 24CD 60 PUSH1 0x39 24CF 60 PUSH1 0xf9 24D1 1B SHL 24D2 60 PUSH1 0x60 24D4 82 DUP3 24D5 01 ADD 24D6 52 MSTORE 24D7 60 PUSH1 0x80 24D9 01 ADD 24DA 90 SWAP1 24DB 56 *JUMP 24DC 5B JUMPDEST 24DD 60 PUSH1 0x20 24DF 80 DUP1 24E0 82 DUP3 24E1 52 MSTORE 24E2 60 PUSH1 0x31 24E4 90 SWAP1 24E5 82 DUP3 24E6 01 ADD 24E7 52 MSTORE 24E8 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2509 60 PUSH1 0x40 250B 82 DUP3 250C 01 ADD 250D 52 MSTORE 250E 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 2520 60 PUSH1 0x7a 2522 1B SHL 2523 60 PUSH1 0x60 2525 82 DUP3 2526 01 ADD 2527 52 MSTORE 2528 60 PUSH1 0x80 252A 01 ADD 252B 90 SWAP1 252C 56 *JUMP label_252D: // Incoming call from 0x097F, returns to 0x06C4 // Inputs[2] // { // @2531 stack[-1] // @2577 stack[-2] // } 252D 5B JUMPDEST 252E 60 PUSH1 0x20 2530 80 DUP1 2531 82 DUP3 2532 52 MSTORE 2533 60 PUSH1 0x2c 2535 90 SWAP1 2536 82 DUP3 2537 01 ADD 2538 52 MSTORE 2539 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 255A 60 PUSH1 0x40 255C 82 DUP3 255D 01 ADD 255E 52 MSTORE 255F 6B PUSH12 0x7574206f6620626f756e6473 256C 60 PUSH1 0xa0 256E 1B SHL 256F 60 PUSH1 0x60 2571 82 DUP3 2572 01 ADD 2573 52 MSTORE 2574 60 PUSH1 0x80 2576 01 ADD 2577 90 SWAP1 2578 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2532 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2538 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2c // @255E memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @2573 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x7574206f6620626f756e6473 << 0xa0 // @2577 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 2579 5B JUMPDEST 257A 60 PUSH1 0x20 257C 80 DUP1 257D 82 DUP3 257E 52 MSTORE 257F 60 PUSH1 0x1c 2581 90 SWAP1 2582 82 DUP3 2583 01 ADD 2584 52 MSTORE 2585 7F PUSH32 0x4d41585f50524553414c455f4d494e545f5045525f4144445245535300000000 25A6 60 PUSH1 0x40 25A8 82 DUP3 25A9 01 ADD 25AA 52 MSTORE 25AB 60 PUSH1 0x60 25AD 01 ADD 25AE 90 SWAP1 25AF 56 *JUMP label_25B0: // Incoming call from 0x0939, returns to 0x06C4 // Inputs[2] // { // @25B4 stack[-1] // @25D3 stack[-2] // } 25B0 5B JUMPDEST 25B1 60 PUSH1 0x20 25B3 80 DUP1 25B4 82 DUP3 25B5 52 MSTORE 25B6 60 PUSH1 0x0b 25B8 90 SWAP1 25B9 82 DUP3 25BA 01 ADD 25BB 52 MSTORE 25BC 6A PUSH11 0x11905253115117d4d15391 25C8 60 PUSH1 0xaa 25CA 1B SHL 25CB 60 PUSH1 0x40 25CD 82 DUP3 25CE 01 ADD 25CF 52 MSTORE 25D0 60 PUSH1 0x60 25D2 01 ADD 25D3 90 SWAP1 25D4 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @25B5 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25BB memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0b // @25CF memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x11905253115117d4d15391 << 0xaa // @25D3 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_25D5: // Incoming call from 0x110F, returns to 0x06C4 // Inputs[2] // { // @25D9 stack[-1] // @25FB stack[-2] // } 25D5 5B JUMPDEST 25D6 60 PUSH1 0x20 25D8 80 DUP1 25D9 82 DUP3 25DA 52 MSTORE 25DB 60 PUSH1 0x0e 25DD 90 SWAP1 25DE 82 DUP3 25DF 01 ADD 25E0 52 MSTORE 25E1 6D PUSH14 0x524553455256455f535550504c59 25F0 60 PUSH1 0x90 25F2 1B SHL 25F3 60 PUSH1 0x40 25F5 82 DUP3 25F6 01 ADD 25F7 52 MSTORE 25F8 60 PUSH1 0x60 25FA 01 ADD 25FB 90 SWAP1 25FC 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @25DA memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25E0 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0e // @25F7 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x524553455256455f535550504c59 << 0x90 // @25FB stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 25FD 5B JUMPDEST 25FE 60 PUSH1 0x20 2600 80 DUP1 2601 82 DUP3 2602 52 MSTORE 2603 60 PUSH1 0x0a 2605 90 SWAP1 2606 82 DUP3 2607 01 ADD 2608 52 MSTORE 2609 69 PUSH10 0x4d41585f535550504c59 2614 60 PUSH1 0xb0 2616 1B SHL 2617 60 PUSH1 0x40 2619 82 DUP3 261A 01 ADD 261B 52 MSTORE 261C 60 PUSH1 0x60 261E 01 ADD 261F 90 SWAP1 2620 56 *JUMP label_2621: // Incoming call from 0x02EF, returns to 0x021F // Inputs[3] // { // @2622 stack[-2] // @2622 stack[-1] // @2628 stack[-3] // } 2621 5B JUMPDEST 2622 90 SWAP1 2623 81 DUP2 2624 52 MSTORE 2625 60 PUSH1 0x20 2627 01 ADD 2628 90 SWAP1 2629 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2624 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @2628 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] label_262A: // Incoming call from 0x14BB, returns to 0x10A8 // Inputs[2] // { // @262D stack[-2] // @262F stack[-1] // } 262A 5B JUMPDEST 262B 60 PUSH1 0x00 262D 82 DUP3 262E 19 NOT 262F 82 DUP3 2630 11 GT 2631 15 ISZERO 2632 61 PUSH2 0x263d 2635 57 *JUMPI // Stack delta = +1 // Outputs[1] { @262B stack[0] = 0x00 } // Block ends with conditional jump to 0x263d, if !(stack[-1] > ~stack[-2]) label_2636: // Incoming jump from 0x2635, if not !(stack[-1] > ~stack[-2]) 2636 61 PUSH2 0x263d 2639 61 PUSH2 0x2722 263C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2636 stack[0] = 0x263d } // Block ends with unconditional jump to 0x2722 label_263D: // Incoming jump from 0x2635, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @263F stack[-2] // @263F stack[-3] // @2640 stack[-4] // } 263D 5B JUMPDEST 263E 50 POP 263F 01 ADD 2640 90 SWAP1 2641 56 *JUMP // Stack delta = -3 // Outputs[1] { @2640 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] 2642 5B JUMPDEST 2643 60 PUSH1 0x00 2645 82 DUP3 2646 61 PUSH2 0x2651 2649 57 *JUMPI 264A 61 PUSH2 0x2651 264D 61 PUSH2 0x2738 2650 56 *JUMP 2651 5B JUMPDEST 2652 50 POP 2653 04 DIV 2654 90 SWAP1 2655 56 *JUMP 2656 5B JUMPDEST 2657 60 PUSH1 0x00 2659 81 DUP2 265A 60 PUSH1 0x00 265C 19 NOT 265D 04 DIV 265E 83 DUP4 265F 11 GT 2660 82 DUP3 2661 15 ISZERO 2662 15 ISZERO 2663 16 AND 2664 15 ISZERO 2665 61 PUSH2 0x2670 2668 57 *JUMPI 2669 61 PUSH2 0x2670 266C 61 PUSH2 0x2722 266F 56 *JUMP 2670 5B JUMPDEST 2671 50 POP 2672 02 MUL 2673 90 SWAP1 2674 56 *JUMP 2675 5B JUMPDEST 2676 60 PUSH1 0x00 2678 82 DUP3 2679 82 DUP3 267A 10 LT 267B 15 ISZERO 267C 61 PUSH2 0x2687 267F 57 *JUMPI 2680 61 PUSH2 0x2687 2683 61 PUSH2 0x2722 2686 56 *JUMP 2687 5B JUMPDEST 2688 50 POP 2689 03 SUB 268A 90 SWAP1 268B 56 *JUMP label_268C: // Incoming call from 0x1E94, returns to 0x1E95 // Inputs[1] { @2690 stack[-3] } 268C 5B JUMPDEST 268D 60 PUSH1 0x00 268F 5B JUMPDEST 2690 83 DUP4 2691 81 DUP2 2692 10 LT 2693 15 ISZERO 2694 61 PUSH2 0x26a7 2697 57 *JUMPI // Stack delta = +1 // Outputs[1] { @268D stack[0] = 0x00 } // Block ends with conditional jump to 0x26a7, if !(0x00 < stack[-3]) label_2698: // Incoming jump from 0x2697, if not !(0x00 < stack[-3]) // Incoming jump from 0x2697, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2698 stack[-2] // @2699 stack[-1] // @269B memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @269C stack[-3] // } 2698 81 DUP2 2699 81 DUP2 269A 01 ADD 269B 51 MLOAD 269C 83 DUP4 269D 82 DUP3 269E 01 ADD 269F 52 MSTORE 26A0 60 PUSH1 0x20 26A2 01 ADD 26A3 61 PUSH2 0x268f 26A6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @269F memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @26A2 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x268f label_26A7: // Incoming jump from 0x2697, if !(0x00 < stack[-3]) // Incoming jump from 0x2697, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @26A8 stack[-4] // @26A9 stack[-1] // } 26A7 5B JUMPDEST 26A8 83 DUP4 26A9 81 DUP2 26AA 11 GT 26AB 15 ISZERO 26AC 61 PUSH2 0x1026 26AF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1026, if !(stack[-1] > stack[-4]) label_26B0: // Incoming jump from 0x26AF, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @26B4 stack[-4] // @26B5 stack[-3] // @26B7 stack[-5] // } 26B0 50 POP 26B1 50 POP 26B2 60 PUSH1 0x00 26B4 91 SWAP2 26B5 01 ADD 26B6 52 MSTORE 26B7 56 *JUMP // Stack delta = -5 // Outputs[1] { @26B6 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_26B8: // Incoming call from 0x0619, returns to 0x061A // Incoming call from 0x1523, returns to 0x061A // Incoming call from 0x1B6F, returns to 0x1B70 // Incoming call from 0x0A94, returns to 0x0A95 // Incoming call from 0x0AC0, returns to 0x0AC1 // Incoming call from 0x0645, returns to 0x0646 // Incoming call from 0x0DD3, returns to 0x061A // Inputs[1] { @26BB stack[-1] } 26B8 5B JUMPDEST 26B9 60 PUSH1 0x02 26BB 81 DUP2 26BC 04 DIV 26BD 60 PUSH1 0x01 26BF 82 DUP3 26C0 16 AND 26C1 80 DUP1 26C2 61 PUSH2 0x26cc 26C5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @26BC stack[0] = stack[-1] / 0x02 // @26C0 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x26cc, if stack[-1] & 0x01 label_26C6: // Incoming jump from 0x26C5, if not stack[-1] & 0x01 // Inputs[2] // { // @26C8 stack[-2] // @26D1 stack[-1] // } 26C6 60 PUSH1 0x7f 26C8 82 DUP3 26C9 16 AND 26CA 91 SWAP2 26CB 50 POP 26CC 5B JUMPDEST 26CD 60 PUSH1 0x20 26CF 82 DUP3 26D0 10 LT 26D1 81 DUP2 26D2 14 EQ 26D3 15 ISZERO 26D4 61 PUSH2 0x26ed 26D7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26CA stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x26ed, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_26D8: // Incoming jump from 0x26D7, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x26D7, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @26EC memory[0x00:0x24] } 26D8 63 PUSH4 0x4e487b71 26DD 60 PUSH1 0xe0 26DF 1B SHL 26E0 60 PUSH1 0x00 26E2 52 MSTORE 26E3 60 PUSH1 0x22 26E5 60 PUSH1 0x04 26E7 52 MSTORE 26E8 60 PUSH1 0x24 26EA 60 PUSH1 0x00 26EC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26E2 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @26E7 memory[0x04:0x24] = 0x22 // @26EC revert(memory[0x00:0x24]); // } // Block terminates label_26ED: // Incoming jump from 0x26D7, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x26D7, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @26EF stack[-4] // @26EF stack[-2] // @26F0 stack[-3] // } 26ED 5B JUMPDEST 26EE 50 POP 26EF 91 SWAP2 26F0 90 SWAP1 26F1 50 POP 26F2 56 *JUMP // Stack delta = -3 // Outputs[1] { @26EF stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_26F3: // Incoming call from 0x0D49, returns to 0x0D4A // Inputs[1] { @26F9 stack[-1] } 26F3 5B JUMPDEST 26F4 60 PUSH1 0x00 26F6 60 PUSH1 0x00 26F8 19 NOT 26F9 82 DUP3 26FA 14 EQ 26FB 15 ISZERO 26FC 61 PUSH2 0x2707 26FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26F4 stack[0] = 0x00 } // Block ends with conditional jump to 0x2707, if !(stack[-1] == ~0x00) label_2700: // Incoming jump from 0x26FF, if not !(stack[-1] == ~0x00) 2700 61 PUSH2 0x2707 2703 61 PUSH2 0x2722 2706 56 *JUMP // Stack delta = +1 // Outputs[1] { @2700 stack[0] = 0x2707 } // Block ends with unconditional jump to 0x2722 label_2707: // Incoming jump from 0x26FF, if !(stack[-1] == ~0x00) // Inputs[2] // { // @270B stack[-2] // @270C stack[-3] // } 2707 5B JUMPDEST 2708 50 POP 2709 60 PUSH1 0x01 270B 01 ADD 270C 90 SWAP1 270D 56 *JUMP // Stack delta = -2 // Outputs[1] { @270C stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] 270E 5B JUMPDEST 270F 60 PUSH1 0x00 2711 82 DUP3 2712 61 PUSH2 0x271d 2715 57 *JUMPI 2716 61 PUSH2 0x271d 2719 61 PUSH2 0x2738 271C 56 *JUMP 271D 5B JUMPDEST 271E 50 POP 271F 06 MOD 2720 90 SWAP1 2721 56 *JUMP label_2722: // Incoming jump from 0x263C // Incoming jump from 0x2706 // Inputs[1] { @2737 memory[0x00:0x24] } 2722 5B JUMPDEST 2723 63 PUSH4 0x4e487b71 2728 60 PUSH1 0xe0 272A 1B SHL 272B 60 PUSH1 0x00 272D 52 MSTORE 272E 60 PUSH1 0x11 2730 60 PUSH1 0x04 2732 52 MSTORE 2733 60 PUSH1 0x24 2735 60 PUSH1 0x00 2737 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @272D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2732 memory[0x04:0x24] = 0x11 // @2737 revert(memory[0x00:0x24]); // } // Block terminates 2738 5B JUMPDEST 2739 63 PUSH4 0x4e487b71 273E 60 PUSH1 0xe0 2740 1B SHL 2741 60 PUSH1 0x00 2743 52 MSTORE 2744 60 PUSH1 0x12 2746 60 PUSH1 0x04 2748 52 MSTORE 2749 60 PUSH1 0x24 274B 60 PUSH1 0x00 274D FD *REVERT label_274E: // Incoming jump from 0x1C3B // Incoming jump from 0x1C17 // Inputs[1] { @2763 memory[0x00:0x24] } 274E 5B JUMPDEST 274F 63 PUSH4 0x4e487b71 2754 60 PUSH1 0xe0 2756 1B SHL 2757 60 PUSH1 0x00 2759 52 MSTORE 275A 60 PUSH1 0x41 275C 60 PUSH1 0x04 275E 52 MSTORE 275F 60 PUSH1 0x24 2761 60 PUSH1 0x00 2763 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2759 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @275E memory[0x04:0x24] = 0x41 // @2763 revert(memory[0x00:0x24]); // } // Block terminates label_2764: // Incoming call from 0x1E02, returns to 0x10A8 // Inputs[1] { @276E stack[-1] } 2764 5B JUMPDEST 2765 60 PUSH1 0x01 2767 60 PUSH1 0x01 2769 60 PUSH1 0xe0 276B 1B SHL 276C 03 SUB 276D 19 NOT 276E 81 DUP2 276F 16 AND 2770 81 DUP2 2771 14 EQ 2772 61 PUSH2 0x093a 2775 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x093a, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2776: // Incoming jump from 0x2775, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2779 memory[0x00:0x00] } 2776 60 PUSH1 0x00 2778 80 DUP1 2779 FD *REVERT // Stack delta = +0 // Outputs[1] { @2779 revert(memory[0x00:0x00]); } // Block terminates 277A FE *ASSERT 277B A2 LOG2 277C 64 PUSH5 0x6970667358 2782 22 22 2783 12 SLT 2784 20 SHA3 2785 5C 5C 2786 E8 E8 2787 7C PUSH29 0x6854ad44178f4ba1a65ab9197d13cf07358fafc669b703e9a2f7227e43 27A5 64 PUSH5 0x736f6c6343 27AB 00 *STOP 27AC 08 ADDMOD 27AD 00 *STOP 27AE 00 *STOP 27AF 33 CALLER