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 0x02e7 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x02e7, 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 0x5c975abb 0019 11 GT 001A 61 PUSH2 0x0184 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0184, if 0x5c975abb > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x5c975abb > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x95d89b41 0024 11 GT 0025 61 PUSH2 0x00d6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d6, if 0x95d89b41 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0x95d89b41 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xb88d4fde 002F 11 GT 0030 61 PUSH2 0x008a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008a, 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 0xe334b267 003A 11 GT 003B 61 PUSH2 0x0064 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xe334b267 > stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe334b267 > stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe334b267 0045 14 EQ 0046 61 PUSH2 0x0818 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0818, if 0xe334b267 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe334b267 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x0848 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0848, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x0891 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0891, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x003E, if 0xe334b267 > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xb88d4fde 006B 14 EQ 006C 61 PUSH2 0x07a3 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a3, if 0xb88d4fde == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xb8997a97 0076 14 EQ 0077 61 PUSH2 0x07b6 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07b6, if 0xb8997a97 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xb8997a97 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xc87b56dd 0081 14 EQ 0082 61 PUSH2 0x07f8 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07f8, if 0xc87b56dd == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0089 memory[0x00:0x00] } 0086 60 PUSH1 0x00 0088 80 DUP1 0089 FD *REVERT // Stack delta = +0 // Outputs[1] { @0089 revert(memory[0x00:0x00]); } // Block terminates label_008A: // Incoming jump from 0x0033, if 0xb88d4fde > stack[-1] // Inputs[1] { @008B stack[-1] } 008A 5B JUMPDEST 008B 80 DUP1 008C 63 PUSH4 0xa0c6d465 0091 11 GT 0092 61 PUSH2 0x00bb 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bb, if 0xa0c6d465 > stack[-1] label_0096: // Incoming jump from 0x0095, if not 0xa0c6d465 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0xa0c6d465 009C 14 EQ 009D 61 PUSH2 0x073e 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x073e, if 0xa0c6d465 == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xa0c6d465 == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xa22cb465 00A7 14 EQ 00A8 61 PUSH2 0x075e 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x075e, if 0xa22cb465 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xad2f852a 00B2 14 EQ 00B3 61 PUSH2 0x077e 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x077e, if 0xad2f852a == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xad2f852a == stack[-1] // Inputs[1] { @00BA memory[0x00:0x00] } 00B7 60 PUSH1 0x00 00B9 80 DUP1 00BA FD *REVERT // Stack delta = +0 // Outputs[1] { @00BA revert(memory[0x00:0x00]); } // Block terminates label_00BB: // Incoming jump from 0x0095, if 0xa0c6d465 > stack[-1] // Inputs[1] { @00BC stack[-1] } 00BB 5B JUMPDEST 00BC 80 DUP1 00BD 63 PUSH4 0x95d89b41 00C2 14 EQ 00C3 61 PUSH2 0x06f1 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f1, if 0x95d89b41 == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C7 80 DUP1 00C8 63 PUSH4 0x98f06ab1 00CD 14 EQ 00CE 61 PUSH2 0x0706 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0706, if 0x98f06ab1 == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0x98f06ab1 == stack[-1] // Inputs[1] { @00D5 memory[0x00:0x00] } 00D2 60 PUSH1 0x00 00D4 80 DUP1 00D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D5 revert(memory[0x00:0x00]); } // Block terminates label_00D6: // Incoming jump from 0x0028, if 0x95d89b41 > stack[-1] // Inputs[1] { @00D7 stack[-1] } 00D6 5B JUMPDEST 00D7 80 DUP1 00D8 63 PUSH4 0x715018a6 00DD 11 GT 00DE 61 PUSH2 0x0138 00E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0138, if 0x715018a6 > stack[-1] label_00E2: // Incoming jump from 0x00E1, if not 0x715018a6 > stack[-1] // Inputs[1] { @00E2 stack[-1] } 00E2 80 DUP1 00E3 63 PUSH4 0x8456cb59 00E8 11 GT 00E9 61 PUSH2 0x0112 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0112, if 0x8456cb59 > stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0x8456cb59 > stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0x8456cb59 00F3 14 EQ 00F4 61 PUSH2 0x06a8 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a8, if 0x8456cb59 == stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0x8456cb59 == stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0x8693da20 00FE 14 EQ 00FF 61 PUSH2 0x06bd 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06bd, if 0x8693da20 == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x8693da20 == stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0x8da5cb5b 0109 14 EQ 010A 61 PUSH2 0x06d3 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d3, if 0x8da5cb5b == stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0111 memory[0x00:0x00] } 010E 60 PUSH1 0x00 0110 80 DUP1 0111 FD *REVERT // Stack delta = +0 // Outputs[1] { @0111 revert(memory[0x00:0x00]); } // Block terminates label_0112: // Incoming jump from 0x00EC, if 0x8456cb59 > stack[-1] // Inputs[1] { @0113 stack[-1] } 0112 5B JUMPDEST 0113 80 DUP1 0114 63 PUSH4 0x715018a6 0119 14 EQ 011A 61 PUSH2 0x0646 011D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0646, if 0x715018a6 == stack[-1] label_011E: // Incoming jump from 0x011D, if not 0x715018a6 == stack[-1] // Inputs[1] { @011E stack[-1] } 011E 80 DUP1 011F 63 PUSH4 0x7ae0f496 0124 14 EQ 0125 61 PUSH2 0x065b 0128 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065b, if 0x7ae0f496 == stack[-1] label_0129: // Incoming jump from 0x0128, if not 0x7ae0f496 == stack[-1] // Inputs[1] { @0129 stack[-1] } 0129 80 DUP1 012A 63 PUSH4 0x811d2437 012F 14 EQ 0130 61 PUSH2 0x0688 0133 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0688, if 0x811d2437 == stack[-1] label_0134: // Incoming jump from 0x0133, if not 0x811d2437 == stack[-1] // Inputs[1] { @0137 memory[0x00:0x00] } 0134 60 PUSH1 0x00 0136 80 DUP1 0137 FD *REVERT // Stack delta = +0 // Outputs[1] { @0137 revert(memory[0x00:0x00]); } // Block terminates label_0138: // Incoming jump from 0x00E1, if 0x715018a6 > stack[-1] // Inputs[1] { @0139 stack[-1] } 0138 5B JUMPDEST 0139 80 DUP1 013A 63 PUSH4 0x6797fdda 013F 11 GT 0140 61 PUSH2 0x0169 0143 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0169, if 0x6797fdda > stack[-1] label_0144: // Incoming jump from 0x0143, if not 0x6797fdda > stack[-1] // Inputs[1] { @0144 stack[-1] } 0144 80 DUP1 0145 63 PUSH4 0x6797fdda 014A 14 EQ 014B 61 PUSH2 0x05e6 014E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e6, if 0x6797fdda == stack[-1] label_014F: // Incoming jump from 0x014E, if not 0x6797fdda == stack[-1] // Inputs[1] { @014F stack[-1] } 014F 80 DUP1 0150 63 PUSH4 0x70a08231 0155 14 EQ 0156 61 PUSH2 0x0606 0159 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0606, if 0x70a08231 == stack[-1] label_015A: // Incoming jump from 0x0159, if not 0x70a08231 == stack[-1] // Inputs[1] { @015A stack[-1] } 015A 80 DUP1 015B 63 PUSH4 0x70cf0448 0160 14 EQ 0161 61 PUSH2 0x0626 0164 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0626, if 0x70cf0448 == stack[-1] label_0165: // Incoming jump from 0x0164, if not 0x70cf0448 == stack[-1] // Inputs[1] { @0168 memory[0x00:0x00] } 0165 60 PUSH1 0x00 0167 80 DUP1 0168 FD *REVERT // Stack delta = +0 // Outputs[1] { @0168 revert(memory[0x00:0x00]); } // Block terminates label_0169: // Incoming jump from 0x0143, if 0x6797fdda > stack[-1] // Inputs[1] { @016A stack[-1] } 0169 5B JUMPDEST 016A 80 DUP1 016B 63 PUSH4 0x5c975abb 0170 14 EQ 0171 61 PUSH2 0x05a7 0174 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a7, if 0x5c975abb == stack[-1] label_0175: // Incoming jump from 0x0174, if not 0x5c975abb == stack[-1] // Inputs[1] { @0175 stack[-1] } 0175 80 DUP1 0176 63 PUSH4 0x6352211e 017B 14 EQ 017C 61 PUSH2 0x05c6 017F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c6, if 0x6352211e == stack[-1] label_0180: // Incoming jump from 0x017F, if not 0x6352211e == stack[-1] // Inputs[1] { @0183 memory[0x00:0x00] } 0180 60 PUSH1 0x00 0182 80 DUP1 0183 FD *REVERT // Stack delta = +0 // Outputs[1] { @0183 revert(memory[0x00:0x00]); } // Block terminates label_0184: // Incoming jump from 0x001D, if 0x5c975abb > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0185 stack[-1] } 0184 5B JUMPDEST 0185 80 DUP1 0186 63 PUSH4 0x2db11544 018B 11 GT 018C 61 PUSH2 0x023d 018F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023d, if 0x2db11544 > stack[-1] label_0190: // Incoming jump from 0x018F, if not 0x2db11544 > stack[-1] // Inputs[1] { @0190 stack[-1] } 0190 80 DUP1 0191 63 PUSH4 0x3ccfd60b 0196 11 GT 0197 61 PUSH2 0x01f1 019A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f1, if 0x3ccfd60b > stack[-1] label_019B: // Incoming jump from 0x019A, if not 0x3ccfd60b > stack[-1] // Inputs[1] { @019B stack[-1] } 019B 80 DUP1 019C 63 PUSH4 0x484b973c 01A1 11 GT 01A2 61 PUSH2 0x01cb 01A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cb, if 0x484b973c > stack[-1] label_01A6: // Incoming jump from 0x01A5, if not 0x484b973c > stack[-1] // Inputs[1] { @01A6 stack[-1] } 01A6 80 DUP1 01A7 63 PUSH4 0x484b973c 01AC 14 EQ 01AD 61 PUSH2 0x054d 01B0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054d, if 0x484b973c == stack[-1] label_01B1: // Incoming jump from 0x01B0, if not 0x484b973c == stack[-1] // Inputs[1] { @01B1 stack[-1] } 01B1 80 DUP1 01B2 63 PUSH4 0x4bf365df 01B7 14 EQ 01B8 61 PUSH2 0x056d 01BB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056d, if 0x4bf365df == stack[-1] label_01BC: // Incoming jump from 0x01BB, if not 0x4bf365df == stack[-1] // Inputs[1] { @01BC stack[-1] } 01BC 80 DUP1 01BD 63 PUSH4 0x55f804b3 01C2 14 EQ 01C3 61 PUSH2 0x0587 01C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0587, if 0x55f804b3 == stack[-1] label_01C7: // Incoming jump from 0x01C6, if not 0x55f804b3 == stack[-1] // Inputs[1] { @01CA memory[0x00:0x00] } 01C7 60 PUSH1 0x00 01C9 80 DUP1 01CA FD *REVERT // Stack delta = +0 // Outputs[1] { @01CA revert(memory[0x00:0x00]); } // Block terminates label_01CB: // Incoming jump from 0x01A5, if 0x484b973c > stack[-1] // Inputs[1] { @01CC stack[-1] } 01CB 5B JUMPDEST 01CC 80 DUP1 01CD 63 PUSH4 0x3ccfd60b 01D2 14 EQ 01D3 61 PUSH2 0x0510 01D6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0510, if 0x3ccfd60b == stack[-1] label_01D7: // Incoming jump from 0x01D6, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @01D7 stack[-1] } 01D7 80 DUP1 01D8 63 PUSH4 0x3f4ba83a 01DD 14 EQ 01DE 61 PUSH2 0x0525 01E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0525, if 0x3f4ba83a == stack[-1] label_01E2: // Incoming jump from 0x01E1, if not 0x3f4ba83a == stack[-1] // Inputs[1] { @01E2 stack[-1] } 01E2 80 DUP1 01E3 63 PUSH4 0x42842e0e 01E8 14 EQ 01E9 61 PUSH2 0x053a 01EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x053a, if 0x42842e0e == stack[-1] label_01ED: // Incoming jump from 0x01EC, if not 0x42842e0e == stack[-1] // Inputs[1] { @01F0 memory[0x00:0x00] } 01ED 60 PUSH1 0x00 01EF 80 DUP1 01F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F0 revert(memory[0x00:0x00]); } // Block terminates label_01F1: // Incoming jump from 0x019A, if 0x3ccfd60b > stack[-1] // Inputs[1] { @01F2 stack[-1] } 01F1 5B JUMPDEST 01F2 80 DUP1 01F3 63 PUSH4 0x32cb6b0c 01F8 11 GT 01F9 61 PUSH2 0x0222 01FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0222, if 0x32cb6b0c > stack[-1] label_01FD: // Incoming jump from 0x01FC, if not 0x32cb6b0c > stack[-1] // Inputs[1] { @01FD stack[-1] } 01FD 80 DUP1 01FE 63 PUSH4 0x32cb6b0c 0203 14 EQ 0204 61 PUSH2 0x04cd 0207 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cd, if 0x32cb6b0c == stack[-1] label_0208: // Incoming jump from 0x0207, if not 0x32cb6b0c == stack[-1] // Inputs[1] { @0208 stack[-1] } 0208 80 DUP1 0209 63 PUSH4 0x33bc1c5c 020E 14 EQ 020F 61 PUSH2 0x04e3 0212 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e3, if 0x33bc1c5c == stack[-1] label_0213: // Incoming jump from 0x0212, if not 0x33bc1c5c == stack[-1] // Inputs[1] { @0213 stack[-1] } 0213 80 DUP1 0214 63 PUSH4 0x373cf8b3 0219 14 EQ 021A 61 PUSH2 0x04fd 021D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04fd, if 0x373cf8b3 == stack[-1] label_021E: // Incoming jump from 0x021D, if not 0x373cf8b3 == stack[-1] // Inputs[1] { @0221 memory[0x00:0x00] } 021E 60 PUSH1 0x00 0220 80 DUP1 0221 FD *REVERT // Stack delta = +0 // Outputs[1] { @0221 revert(memory[0x00:0x00]); } // Block terminates label_0222: // Incoming jump from 0x01FC, if 0x32cb6b0c > stack[-1] // Inputs[1] { @0223 stack[-1] } 0222 5B JUMPDEST 0223 80 DUP1 0224 63 PUSH4 0x2db11544 0229 14 EQ 022A 61 PUSH2 0x049a 022D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049a, if 0x2db11544 == stack[-1] label_022E: // Incoming jump from 0x022D, if not 0x2db11544 == stack[-1] // Inputs[1] { @022E stack[-1] } 022E 80 DUP1 022F 63 PUSH4 0x31faafb4 0234 14 EQ 0235 61 PUSH2 0x04ad 0238 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ad, if 0x31faafb4 == stack[-1] label_0239: // Incoming jump from 0x0238, if not 0x31faafb4 == stack[-1] // Inputs[1] { @023C memory[0x00:0x00] } 0239 60 PUSH1 0x00 023B 80 DUP1 023C FD *REVERT // Stack delta = +0 // Outputs[1] { @023C revert(memory[0x00:0x00]); } // Block terminates label_023D: // Incoming jump from 0x018F, if 0x2db11544 > stack[-1] // Inputs[1] { @023E stack[-1] } 023D 5B JUMPDEST 023E 80 DUP1 023F 63 PUSH4 0x09858949 0244 11 GT 0245 61 PUSH2 0x029f 0248 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029f, if 0x09858949 > stack[-1] label_0249: // Incoming jump from 0x0248, if not 0x09858949 > stack[-1] // Inputs[1] { @0249 stack[-1] } 0249 80 DUP1 024A 63 PUSH4 0x23b872dd 024F 11 GT 0250 61 PUSH2 0x0279 0253 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0279, if 0x23b872dd > stack[-1] label_0254: // Incoming jump from 0x0253, if not 0x23b872dd > stack[-1] // Inputs[1] { @0254 stack[-1] } 0254 80 DUP1 0255 63 PUSH4 0x23b872dd 025A 14 EQ 025B 61 PUSH2 0x0428 025E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0428, if 0x23b872dd == stack[-1] label_025F: // Incoming jump from 0x025E, if not 0x23b872dd == stack[-1] // Inputs[1] { @025F stack[-1] } 025F 80 DUP1 0260 63 PUSH4 0x285d70d4 0265 14 EQ 0266 61 PUSH2 0x043b 0269 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043b, if 0x285d70d4 == stack[-1] label_026A: // Incoming jump from 0x0269, if not 0x285d70d4 == stack[-1] // Inputs[1] { @026A stack[-1] } 026A 80 DUP1 026B 63 PUSH4 0x2a55205a 0270 14 EQ 0271 61 PUSH2 0x045b 0274 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x045b, if 0x2a55205a == stack[-1] label_0275: // Incoming jump from 0x0274, if not 0x2a55205a == stack[-1] // Inputs[1] { @0278 memory[0x00:0x00] } 0275 60 PUSH1 0x00 0277 80 DUP1 0278 FD *REVERT // Stack delta = +0 // Outputs[1] { @0278 revert(memory[0x00:0x00]); } // Block terminates label_0279: // Incoming jump from 0x0253, if 0x23b872dd > stack[-1] // Inputs[1] { @027A stack[-1] } 0279 5B JUMPDEST 027A 80 DUP1 027B 63 PUSH4 0x09858949 0280 14 EQ 0281 61 PUSH2 0x03b0 0284 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b0, if 0x09858949 == stack[-1] label_0285: // Incoming jump from 0x0284, if not 0x09858949 == stack[-1] // Inputs[1] { @0285 stack[-1] } 0285 80 DUP1 0286 63 PUSH4 0x0a54cd36 028B 14 EQ 028C 61 PUSH2 0x03eb 028F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03eb, if 0x0a54cd36 == stack[-1] label_0290: // Incoming jump from 0x028F, if not 0x0a54cd36 == stack[-1] // Inputs[1] { @0290 stack[-1] } 0290 80 DUP1 0291 63 PUSH4 0x18160ddd 0296 14 EQ 0297 61 PUSH2 0x040b 029A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x040b, if 0x18160ddd == stack[-1] label_029B: // Incoming jump from 0x029A, if not 0x18160ddd == stack[-1] // Inputs[1] { @029E memory[0x00:0x00] } 029B 60 PUSH1 0x00 029D 80 DUP1 029E FD *REVERT // Stack delta = +0 // Outputs[1] { @029E revert(memory[0x00:0x00]); } // Block terminates label_029F: // Incoming jump from 0x0248, if 0x09858949 > stack[-1] // Inputs[1] { @02A0 stack[-1] } 029F 5B JUMPDEST 02A0 80 DUP1 02A1 63 PUSH4 0x06fdde03 02A6 11 GT 02A7 61 PUSH2 0x02d0 02AA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d0, if 0x06fdde03 > stack[-1] label_02AB: // Incoming jump from 0x02AA, if not 0x06fdde03 > stack[-1] // Inputs[1] { @02AB stack[-1] } 02AB 80 DUP1 02AC 63 PUSH4 0x06fdde03 02B1 14 EQ 02B2 61 PUSH2 0x0343 02B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0343, if 0x06fdde03 == stack[-1] label_02B6: // Incoming jump from 0x02B5, if not 0x06fdde03 == stack[-1] // Inputs[1] { @02B6 stack[-1] } 02B6 80 DUP1 02B7 63 PUSH4 0x081812fc 02BC 14 EQ 02BD 61 PUSH2 0x0365 02C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0365, if 0x081812fc == stack[-1] label_02C1: // Incoming jump from 0x02C0, if not 0x081812fc == stack[-1] // Inputs[1] { @02C1 stack[-1] } 02C1 80 DUP1 02C2 63 PUSH4 0x095ea7b3 02C7 14 EQ 02C8 61 PUSH2 0x039d 02CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039d, if 0x095ea7b3 == stack[-1] label_02CC: // Incoming jump from 0x02CB, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @02CF memory[0x00:0x00] } 02CC 60 PUSH1 0x00 02CE 80 DUP1 02CF FD *REVERT // Stack delta = +0 // Outputs[1] { @02CF revert(memory[0x00:0x00]); } // Block terminates label_02D0: // Incoming jump from 0x02AA, if 0x06fdde03 > stack[-1] // Inputs[1] { @02D1 stack[-1] } 02D0 5B JUMPDEST 02D1 80 DUP1 02D2 63 PUSH4 0x01ffc9a7 02D7 14 EQ 02D8 61 PUSH2 0x02ec 02DB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ec, if 0x01ffc9a7 == stack[-1] label_02DC: // Incoming jump from 0x02DB, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @02DC stack[-1] } 02DC 80 DUP1 02DD 63 PUSH4 0x06d254da 02E2 14 EQ 02E3 61 PUSH2 0x0321 02E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0321, if 0x06d254da == stack[-1] label_02E7: // Incoming jump from 0x02E6, if not 0x06d254da == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @02EB memory[0x00:0x00] } 02E7 5B JUMPDEST 02E8 60 PUSH1 0x00 02EA 80 DUP1 02EB FD *REVERT // Stack delta = +0 // Outputs[1] { @02EB revert(memory[0x00:0x00]); } // Block terminates label_02EC: // Incoming jump from 0x02DB, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @02ED msg.value } 02EC 5B JUMPDEST 02ED 34 CALLVALUE 02EE 80 DUP1 02EF 15 ISZERO 02F0 61 PUSH2 0x02f8 02F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02ED stack[0] = msg.value } // Block ends with conditional jump to 0x02f8, if !msg.value label_02F4: // Incoming jump from 0x02F3, if not !msg.value // Inputs[1] { @02F7 memory[0x00:0x00] } 02F4 60 PUSH1 0x00 02F6 80 DUP1 02F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F7 revert(memory[0x00:0x00]); } // Block terminates label_02F8: // Incoming jump from 0x02F3, if !msg.value // Inputs[1] { @0300 msg.data.length } 02F8 5B JUMPDEST 02F9 50 POP 02FA 61 PUSH2 0x030c 02FD 61 PUSH2 0x0307 0300 36 CALLDATASIZE 0301 60 PUSH1 0x04 0303 61 PUSH2 0x2293 0306 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02FA stack[-1] = 0x030c // @02FD stack[0] = 0x0307 // @0300 stack[1] = msg.data.length // @0301 stack[2] = 0x04 // } // Block ends with call to 0x2293, returns to 0x0307 label_0307: // Incoming return from call to 0x2293 at 0x0306 0307 5B JUMPDEST 0308 61 PUSH2 0x08b1 030B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08b1 label_030C: // Incoming jump from 0x05C5 // Incoming return from call to 0x0307 at 0x0306 // Incoming jump from 0x04FC // Incoming jump from 0x0586 // Incoming return from call to 0x0833 at 0x0832 // Inputs[2] // { // @030F memory[0x40:0x60] // @0310 stack[-1] // } 030C 5B JUMPDEST 030D 60 PUSH1 0x40 030F 51 MLOAD 0310 90 SWAP1 0311 15 ISZERO 0312 15 ISZERO 0313 81 DUP2 0314 52 MSTORE 0315 60 PUSH1 0x20 0317 01 ADD // Stack delta = +0 // Outputs[2] // { // @0314 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0317 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0318: // Incoming jump from 0x07F7 // Incoming jump from 0x0317 // Incoming jump from 0x0499 // Incoming jump from 0x03EA // Incoming return from call to 0x2337 at 0x0364 // Incoming jump from 0x039C // Inputs[3] // { // @031B memory[0x40:0x60] // @031D stack[-1] // @0320 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0318 5B JUMPDEST 0319 60 PUSH1 0x40 031B 51 MLOAD 031C 80 DUP1 031D 91 SWAP2 031E 03 SUB 031F 90 SWAP1 0320 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0320 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0321: // Incoming jump from 0x02E6, if 0x06d254da == stack[-1] // Inputs[1] { @0322 msg.value } 0321 5B JUMPDEST 0322 34 CALLVALUE 0323 80 DUP1 0324 15 ISZERO 0325 61 PUSH2 0x032d 0328 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0322 stack[0] = msg.value } // Block ends with conditional jump to 0x032d, if !msg.value label_0329: // Incoming jump from 0x0328, if not !msg.value // Inputs[1] { @032C memory[0x00:0x00] } 0329 60 PUSH1 0x00 032B 80 DUP1 032C FD *REVERT // Stack delta = +0 // Outputs[1] { @032C revert(memory[0x00:0x00]); } // Block terminates label_032D: // Incoming jump from 0x0328, if !msg.value // Inputs[1] { @0335 msg.data.length } 032D 5B JUMPDEST 032E 50 POP 032F 61 PUSH2 0x0341 0332 61 PUSH2 0x033c 0335 36 CALLDATASIZE 0336 60 PUSH1 0x04 0338 61 PUSH2 0x22cc 033B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @032F stack[-1] = 0x0341 // @0332 stack[0] = 0x033c // @0335 stack[1] = msg.data.length // @0336 stack[2] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x033C label_033C: // Incoming return from call to 0x22CC at 0x033B 033C 5B JUMPDEST 033D 61 PUSH2 0x08d1 0340 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08d1 label_0341: // Incoming return from call to 0x03AB at 0x03AA // Incoming return from call to 0x0568 at 0x0567 // Incoming return from call to 0x04A8 at 0x04A7 // Incoming return from call to 0x06A3 at 0x06A2 // Incoming return from call to 0x050B at 0x050A // Incoming return from call to 0x0406 at 0x0405 // Incoming return from call to 0x0436 at 0x0435 // Incoming return from call to 0x07B1 at 0x07B0 // Incoming return from call to 0x0456 at 0x0455 // Incoming return from call to 0x0601 at 0x0600 // Incoming return from call to 0x0759 at 0x0758 0341 5B JUMPDEST 0342 00 *STOP // Stack delta = +0 // Outputs[1] { @0342 stop(); } // Block terminates label_0343: // Incoming jump from 0x02B5, if 0x06fdde03 == stack[-1] // Inputs[1] { @0344 msg.value } 0343 5B JUMPDEST 0344 34 CALLVALUE 0345 80 DUP1 0346 15 ISZERO 0347 61 PUSH2 0x034f 034A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0344 stack[0] = msg.value } // Block ends with conditional jump to 0x034f, if !msg.value label_034B: // Incoming jump from 0x034A, if not !msg.value // Inputs[1] { @034E memory[0x00:0x00] } 034B 60 PUSH1 0x00 034D 80 DUP1 034E FD *REVERT // Stack delta = +0 // Outputs[1] { @034E revert(memory[0x00:0x00]); } // Block terminates label_034F: // Incoming jump from 0x034A, if !msg.value 034F 5B JUMPDEST 0350 50 POP 0351 61 PUSH2 0x0358 0354 61 PUSH2 0x093c 0357 56 *JUMP // Stack delta = +0 // Outputs[1] { @0351 stack[-1] = 0x0358 } // Block ends with call to 0x093c, returns to 0x0358 label_0358: // Incoming return from call to 0x163B at 0x0705 // Incoming return from call to 0x093C at 0x0357 // Inputs[2] // { // @035B memory[0x40:0x60] // @035F stack[-1] // } 0358 5B JUMPDEST 0359 60 PUSH1 0x40 035B 51 MLOAD 035C 61 PUSH2 0x0318 035F 91 SWAP2 0360 90 SWAP1 0361 61 PUSH2 0x2337 0364 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @035F stack[-1] = 0x0318 // @0360 stack[1] = memory[0x40:0x60] // @0360 stack[0] = stack[-1] // } // Block ends with call to 0x2337, returns to 0x0318 label_0365: // Incoming jump from 0x02C0, if 0x081812fc == stack[-1] // Inputs[1] { @0366 msg.value } 0365 5B JUMPDEST 0366 34 CALLVALUE 0367 80 DUP1 0368 15 ISZERO 0369 61 PUSH2 0x0371 036C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0366 stack[0] = msg.value } // Block ends with conditional jump to 0x0371, if !msg.value label_036D: // Incoming jump from 0x036C, if not !msg.value // Inputs[1] { @0370 memory[0x00:0x00] } 036D 60 PUSH1 0x00 036F 80 DUP1 0370 FD *REVERT // Stack delta = +0 // Outputs[1] { @0370 revert(memory[0x00:0x00]); } // Block terminates label_0371: // Incoming jump from 0x036C, if !msg.value // Inputs[1] { @0379 msg.data.length } 0371 5B JUMPDEST 0372 50 POP 0373 61 PUSH2 0x0385 0376 61 PUSH2 0x0380 0379 36 CALLDATASIZE 037A 60 PUSH1 0x04 037C 61 PUSH2 0x234a 037F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0373 stack[-1] = 0x0385 // @0376 stack[0] = 0x0380 // @0379 stack[1] = msg.data.length // @037A stack[2] = 0x04 // } // Block ends with call to 0x234a, returns to 0x0380 label_0380: // Incoming return from call to 0x234A at 0x037F 0380 5B JUMPDEST 0381 61 PUSH2 0x09ce 0384 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09ce label_0385: // Incoming jump from 0x07A2 // Incoming return from call to 0x05E1 at 0x05E0 // Incoming jump from 0x06F0 // Incoming return from call to 0x0380 at 0x037F // Inputs[2] // { // @0388 memory[0x40:0x60] // @0392 stack[-1] // } 0385 5B JUMPDEST 0386 60 PUSH1 0x40 0388 51 MLOAD 0389 60 PUSH1 0x01 038B 60 PUSH1 0x01 038D 60 PUSH1 0xa0 038F 1B SHL 0390 03 SUB 0391 90 SWAP1 0392 91 SWAP2 0393 16 AND 0394 81 DUP2 0395 52 MSTORE 0396 60 PUSH1 0x20 0398 01 ADD 0399 61 PUSH2 0x0318 039C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0395 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0398 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0318 label_039D: // Incoming jump from 0x02CB, if 0x095ea7b3 == stack[-1] // Inputs[1] { @03A4 msg.data.length } 039D 5B JUMPDEST 039E 61 PUSH2 0x0341 03A1 61 PUSH2 0x03ab 03A4 36 CALLDATASIZE 03A5 60 PUSH1 0x04 03A7 61 PUSH2 0x2363 03AA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @039E stack[0] = 0x0341 // @03A1 stack[1] = 0x03ab // @03A4 stack[2] = msg.data.length // @03A5 stack[3] = 0x04 // } // Block ends with call to 0x2363, returns to 0x03AB label_03AB: // Incoming return from call to 0x2363 at 0x03AA 03AB 5B JUMPDEST 03AC 61 PUSH2 0x0a2b 03AF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a2b label_03B0: // Incoming jump from 0x0284, if 0x09858949 == stack[-1] // Inputs[1] { @03B1 msg.value } 03B0 5B JUMPDEST 03B1 34 CALLVALUE 03B2 80 DUP1 03B3 15 ISZERO 03B4 61 PUSH2 0x03bc 03B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B1 stack[0] = msg.value } // Block ends with conditional jump to 0x03bc, if !msg.value label_03B8: // Incoming jump from 0x03B7, if not !msg.value // Inputs[1] { @03BB memory[0x00:0x00] } 03B8 60 PUSH1 0x00 03BA 80 DUP1 03BB FD *REVERT // Stack delta = +0 // Outputs[1] { @03BB revert(memory[0x00:0x00]); } // Block terminates label_03BC: // Incoming jump from 0x03B7, if !msg.value // Inputs[1] { @03C4 msg.data.length } 03BC 5B JUMPDEST 03BD 50 POP 03BE 61 PUSH2 0x03dd 03C1 61 PUSH2 0x03cb 03C4 36 CALLDATASIZE 03C5 60 PUSH1 0x04 03C7 61 PUSH2 0x239c 03CA 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03BE stack[-1] = 0x03dd // @03C1 stack[0] = 0x03cb // @03C4 stack[1] = msg.data.length // @03C5 stack[2] = 0x04 // } // Block ends with call to 0x239c, returns to 0x03CB label_03CB: // Incoming return from call to 0x239C at 0x03CA // Inputs[4] // { // @03D3 stack[-1] // @03D9 memory[0x00:0x40] // @03DA storage[keccak256(memory[0x00:0x40])] // @03DB stack[-2] // } 03CB 5B JUMPDEST 03CC 60 PUSH1 0x11 03CE 60 PUSH1 0x20 03D0 52 MSTORE 03D1 60 PUSH1 0x00 03D3 90 SWAP1 03D4 81 DUP2 03D5 52 MSTORE 03D6 60 PUSH1 0x40 03D8 90 SWAP1 03D9 20 SHA3 03DA 54 SLOAD 03DB 81 DUP2 03DC 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @03D0 memory[0x20:0x40] = 0x11 // @03D5 memory[0x00:0x20] = stack[-1] // @03DA stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_03DD: // Incoming jump from 0x06D2 // Incoming return from call to 0x0621 at 0x0620 // Incoming jump from 0x04E2 // Incoming return from call to 0x0676 at 0x0675 // Incoming return from call to 0x03CB at 0x03CA // Incoming jump from 0x0427 // Inputs[2] // { // @03E0 memory[0x40:0x60] // @03E1 stack[-1] // } 03DD 5B JUMPDEST 03DE 60 PUSH1 0x40 03E0 51 MLOAD 03E1 90 SWAP1 03E2 81 DUP2 03E3 52 MSTORE 03E4 60 PUSH1 0x20 03E6 01 ADD 03E7 61 PUSH2 0x0318 03EA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @03E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03E6 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0318 label_03EB: // Incoming jump from 0x028F, if 0x0a54cd36 == stack[-1] // Inputs[1] { @03EC msg.value } 03EB 5B JUMPDEST 03EC 34 CALLVALUE 03ED 80 DUP1 03EE 15 ISZERO 03EF 61 PUSH2 0x03f7 03F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03EC stack[0] = msg.value } // Block ends with conditional jump to 0x03f7, if !msg.value label_03F3: // Incoming jump from 0x03F2, if not !msg.value // Inputs[1] { @03F6 memory[0x00:0x00] } 03F3 60 PUSH1 0x00 03F5 80 DUP1 03F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F6 revert(memory[0x00:0x00]); } // Block terminates label_03F7: // Incoming jump from 0x03F2, if !msg.value // Inputs[1] { @03FF msg.data.length } 03F7 5B JUMPDEST 03F8 50 POP 03F9 61 PUSH2 0x0341 03FC 61 PUSH2 0x0406 03FF 36 CALLDATASIZE 0400 60 PUSH1 0x04 0402 61 PUSH2 0x23b7 0405 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F9 stack[-1] = 0x0341 // @03FC stack[0] = 0x0406 // @03FF stack[1] = msg.data.length // @0400 stack[2] = 0x04 // } // Block ends with call to 0x23b7, returns to 0x0406 label_0406: // Incoming return from call to 0x23B7 at 0x0405 0406 5B JUMPDEST 0407 61 PUSH2 0x0b0e 040A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b0e label_040B: // Incoming jump from 0x029A, if 0x18160ddd == stack[-1] // Inputs[1] { @040C msg.value } 040B 5B JUMPDEST 040C 34 CALLVALUE 040D 80 DUP1 040E 15 ISZERO 040F 61 PUSH2 0x0417 0412 57 *JUMPI // Stack delta = +1 // Outputs[1] { @040C stack[0] = msg.value } // Block ends with conditional jump to 0x0417, if !msg.value label_0413: // Incoming jump from 0x0412, if not !msg.value // Inputs[1] { @0416 memory[0x00:0x00] } 0413 60 PUSH1 0x00 0415 80 DUP1 0416 FD *REVERT // Stack delta = +0 // Outputs[1] { @0416 revert(memory[0x00:0x00]); } // Block terminates label_0417: // Incoming jump from 0x0412, if !msg.value // Inputs[2] // { // @041B storage[0x01] // @041E storage[0x00] // } 0417 5B JUMPDEST 0418 50 POP 0419 60 PUSH1 0x01 041B 54 SLOAD 041C 60 PUSH1 0x00 041E 54 SLOAD 041F 03 SUB 0420 60 PUSH1 0x00 0422 19 NOT 0423 01 ADD 0424 61 PUSH2 0x03dd 0427 56 *JUMP // Stack delta = +0 // Outputs[1] { @0423 stack[-1] = ~0x00 + (storage[0x00] - storage[0x01]) } // Block ends with unconditional jump to 0x03dd label_0428: // Incoming jump from 0x025E, if 0x23b872dd == stack[-1] // Inputs[1] { @042F msg.data.length } 0428 5B JUMPDEST 0429 61 PUSH2 0x0341 042C 61 PUSH2 0x0436 042F 36 CALLDATASIZE 0430 60 PUSH1 0x04 0432 61 PUSH2 0x23e3 0435 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0429 stack[0] = 0x0341 // @042C stack[1] = 0x0436 // @042F stack[2] = msg.data.length // @0430 stack[3] = 0x04 // } // Block ends with call to 0x23e3, returns to 0x0436 label_0436: // Incoming return from call to 0x23E3 at 0x0435 0436 5B JUMPDEST 0437 61 PUSH2 0x0b53 043A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b53 label_043B: // Incoming jump from 0x0269, if 0x285d70d4 == stack[-1] // Inputs[1] { @043C msg.value } 043B 5B JUMPDEST 043C 34 CALLVALUE 043D 80 DUP1 043E 15 ISZERO 043F 61 PUSH2 0x0447 0442 57 *JUMPI // Stack delta = +1 // Outputs[1] { @043C stack[0] = msg.value } // Block ends with conditional jump to 0x0447, if !msg.value label_0443: // Incoming jump from 0x0442, if not !msg.value // Inputs[1] { @0446 memory[0x00:0x00] } 0443 60 PUSH1 0x00 0445 80 DUP1 0446 FD *REVERT // Stack delta = +0 // Outputs[1] { @0446 revert(memory[0x00:0x00]); } // Block terminates label_0447: // Incoming jump from 0x0442, if !msg.value // Inputs[1] { @044F msg.data.length } 0447 5B JUMPDEST 0448 50 POP 0449 61 PUSH2 0x0341 044C 61 PUSH2 0x0456 044F 36 CALLDATASIZE 0450 60 PUSH1 0x04 0452 61 PUSH2 0x242f 0455 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0449 stack[-1] = 0x0341 // @044C stack[0] = 0x0456 // @044F stack[1] = msg.data.length // @0450 stack[2] = 0x04 // } // Block ends with call to 0x242f, returns to 0x0456 label_0456: // Incoming return from call to 0x242F at 0x0455 0456 5B JUMPDEST 0457 61 PUSH2 0x0d55 045A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d55 label_045B: // Incoming jump from 0x0274, if 0x2a55205a == stack[-1] // Inputs[1] { @045C msg.value } 045B 5B JUMPDEST 045C 34 CALLVALUE 045D 80 DUP1 045E 15 ISZERO 045F 61 PUSH2 0x0467 0462 57 *JUMPI // Stack delta = +1 // Outputs[1] { @045C stack[0] = msg.value } // Block ends with conditional jump to 0x0467, if !msg.value label_0463: // Incoming jump from 0x0462, if not !msg.value // Inputs[1] { @0466 memory[0x00:0x00] } 0463 60 PUSH1 0x00 0465 80 DUP1 0466 FD *REVERT // Stack delta = +0 // Outputs[1] { @0466 revert(memory[0x00:0x00]); } // Block terminates label_0467: // Incoming jump from 0x0462, if !msg.value // Inputs[1] { @046F msg.data.length } 0467 5B JUMPDEST 0468 50 POP 0469 61 PUSH2 0x047b 046C 61 PUSH2 0x0476 046F 36 CALLDATASIZE 0470 60 PUSH1 0x04 0472 61 PUSH2 0x244a 0475 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0469 stack[-1] = 0x047b // @046C stack[0] = 0x0476 // @046F stack[1] = msg.data.length // @0470 stack[2] = 0x04 // } // Block ends with call to 0x244a, returns to 0x0476 label_0476: // Incoming return from call to 0x244A at 0x0475 0476 5B JUMPDEST 0477 61 PUSH2 0x0d70 047A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d70 label_047B: // Incoming return from call to 0x0476 at 0x0475 // Inputs[3] // { // @047F memory[0x40:0x60] // @0489 stack[-2] // @0491 stack[-1] // } 047B 5B JUMPDEST 047C 60 PUSH1 0x40 047E 80 DUP1 047F 51 MLOAD 0480 60 PUSH1 0x01 0482 60 PUSH1 0x01 0484 60 PUSH1 0xa0 0486 1B SHL 0487 03 SUB 0488 90 SWAP1 0489 93 SWAP4 048A 16 AND 048B 83 DUP4 048C 52 MSTORE 048D 60 PUSH1 0x20 048F 83 DUP4 0490 01 ADD 0491 91 SWAP2 0492 90 SWAP1 0493 91 SWAP2 0494 52 MSTORE 0495 01 ADD 0496 61 PUSH2 0x0318 0499 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @048C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0494 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0495 stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0318 label_049A: // Incoming jump from 0x022D, if 0x2db11544 == stack[-1] // Inputs[1] { @04A1 msg.data.length } 049A 5B JUMPDEST 049B 61 PUSH2 0x0341 049E 61 PUSH2 0x04a8 04A1 36 CALLDATASIZE 04A2 60 PUSH1 0x04 04A4 61 PUSH2 0x234a 04A7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @049B stack[0] = 0x0341 // @049E stack[1] = 0x04a8 // @04A1 stack[2] = msg.data.length // @04A2 stack[3] = 0x04 // } // Block ends with call to 0x234a, returns to 0x04A8 label_04A8: // Incoming return from call to 0x234A at 0x04A7 04A8 5B JUMPDEST 04A9 61 PUSH2 0x0e2b 04AC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e2b label_04AD: // Incoming jump from 0x0238, if 0x31faafb4 == stack[-1] // Inputs[1] { @04AE msg.value } 04AD 5B JUMPDEST 04AE 34 CALLVALUE 04AF 80 DUP1 04B0 15 ISZERO 04B1 61 PUSH2 0x04b9 04B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04AE stack[0] = msg.value } // Block ends with conditional jump to 0x04b9, if !msg.value label_04B5: // Incoming jump from 0x04B4, if not !msg.value // Inputs[1] { @04B8 memory[0x00:0x00] } 04B5 60 PUSH1 0x00 04B7 80 DUP1 04B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B8 revert(memory[0x00:0x00]); } // Block terminates label_04B9: // Incoming jump from 0x04B4, if !msg.value // Inputs[1] { @04C1 msg.data.length } 04B9 5B JUMPDEST 04BA 50 POP 04BB 61 PUSH2 0x0341 04BE 61 PUSH2 0x04c8 04C1 36 CALLDATASIZE 04C2 60 PUSH1 0x04 04C4 61 PUSH2 0x246c 04C7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04BB stack[-1] = 0x0341 // @04BE stack[0] = 0x04c8 // @04C1 stack[1] = msg.data.length // @04C2 stack[2] = 0x04 // } // Block ends with call to 0x246c, returns to 0x04C8 label_04C8: // Incoming return from call to 0x246C at 0x04C7 04C8 5B JUMPDEST 04C9 61 PUSH2 0x1008 04CC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1008 label_04CD: // Incoming jump from 0x0207, if 0x32cb6b0c == stack[-1] // Inputs[1] { @04CE msg.value } 04CD 5B JUMPDEST 04CE 34 CALLVALUE 04CF 80 DUP1 04D0 15 ISZERO 04D1 61 PUSH2 0x04d9 04D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CE stack[0] = msg.value } // Block ends with conditional jump to 0x04d9, if !msg.value label_04D5: // Incoming jump from 0x04D4, if not !msg.value // Inputs[1] { @04D8 memory[0x00:0x00] } 04D5 60 PUSH1 0x00 04D7 80 DUP1 04D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D8 revert(memory[0x00:0x00]); } // Block terminates label_04D9: // Incoming jump from 0x04D4, if !msg.value 04D9 5B JUMPDEST 04DA 50 POP 04DB 61 PUSH2 0x03dd 04DE 61 PUSH2 0x1770 04E1 81 DUP2 04E2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04DB stack[-1] = 0x03dd // @04DE stack[0] = 0x1770 // } // Block ends with unconditional jump to 0x03dd label_04E3: // Incoming jump from 0x0212, if 0x33bc1c5c == stack[-1] // Inputs[1] { @04E4 msg.value } 04E3 5B JUMPDEST 04E4 34 CALLVALUE 04E5 80 DUP1 04E6 15 ISZERO 04E7 61 PUSH2 0x04ef 04EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E4 stack[0] = msg.value } // Block ends with conditional jump to 0x04ef, if !msg.value label_04EB: // Incoming jump from 0x04EA, if not !msg.value // Inputs[1] { @04EE memory[0x00:0x00] } 04EB 60 PUSH1 0x00 04ED 80 DUP1 04EE FD *REVERT // Stack delta = +0 // Outputs[1] { @04EE revert(memory[0x00:0x00]); } // Block terminates label_04EF: // Incoming jump from 0x04EA, if !msg.value // Inputs[1] { @04F3 storage[0x0d] } 04EF 5B JUMPDEST 04F0 50 POP 04F1 60 PUSH1 0x0d 04F3 54 SLOAD 04F4 61 PUSH2 0x030c 04F7 90 SWAP1 04F8 60 PUSH1 0xff 04FA 16 AND 04FB 81 DUP2 04FC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04F7 stack[-1] = 0x030c // @04FA stack[0] = 0xff & storage[0x0d] // } // Block ends with unconditional jump to 0x030c label_04FD: // Incoming jump from 0x021D, if 0x373cf8b3 == stack[-1] // Inputs[1] { @0504 msg.data.length } 04FD 5B JUMPDEST 04FE 61 PUSH2 0x0341 0501 61 PUSH2 0x050b 0504 36 CALLDATASIZE 0505 60 PUSH1 0x04 0507 61 PUSH2 0x249a 050A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04FE stack[0] = 0x0341 // @0501 stack[1] = 0x050b // @0504 stack[2] = msg.data.length // @0505 stack[3] = 0x04 // } // Block ends with call to 0x249a, returns to 0x050B label_050B: // Incoming return from call to 0x249A at 0x050A 050B 5B JUMPDEST 050C 61 PUSH2 0x1054 050F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1054 label_0510: // Incoming jump from 0x01D6, if 0x3ccfd60b == stack[-1] // Inputs[1] { @0511 msg.value } 0510 5B JUMPDEST 0511 34 CALLVALUE 0512 80 DUP1 0513 15 ISZERO 0514 61 PUSH2 0x051c 0517 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0511 stack[0] = msg.value } // Block ends with conditional jump to 0x051c, if !msg.value label_0518: // Incoming jump from 0x0517, if not !msg.value // Inputs[1] { @051B memory[0x00:0x00] } 0518 60 PUSH1 0x00 051A 80 DUP1 051B FD *REVERT // Stack delta = +0 // Outputs[1] { @051B revert(memory[0x00:0x00]); } // Block terminates label_051C: // Incoming jump from 0x0517, if !msg.value 051C 5B JUMPDEST 051D 50 POP 051E 61 PUSH2 0x0341 0521 61 PUSH2 0x14a5 0524 56 *JUMP // Stack delta = +0 // Outputs[1] { @051E stack[-1] = 0x0341 } // Block ends with unconditional jump to 0x14a5 label_0525: // Incoming jump from 0x01E1, if 0x3f4ba83a == stack[-1] // Inputs[1] { @0526 msg.value } 0525 5B JUMPDEST 0526 34 CALLVALUE 0527 80 DUP1 0528 15 ISZERO 0529 61 PUSH2 0x0531 052C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0526 stack[0] = msg.value } // Block ends with conditional jump to 0x0531, if !msg.value label_052D: // Incoming jump from 0x052C, if not !msg.value // Inputs[1] { @0530 memory[0x00:0x00] } 052D 60 PUSH1 0x00 052F 80 DUP1 0530 FD *REVERT // Stack delta = +0 // Outputs[1] { @0530 revert(memory[0x00:0x00]); } // Block terminates label_0531: // Incoming jump from 0x052C, if !msg.value 0531 5B JUMPDEST 0532 50 POP 0533 61 PUSH2 0x0341 0536 61 PUSH2 0x14cd 0539 56 *JUMP // Stack delta = +0 // Outputs[1] { @0533 stack[-1] = 0x0341 } // Block ends with unconditional jump to 0x14cd label_053A: // Incoming jump from 0x01EC, if 0x42842e0e == stack[-1] // Inputs[1] { @0541 msg.data.length } 053A 5B JUMPDEST 053B 61 PUSH2 0x0341 053E 61 PUSH2 0x0548 0541 36 CALLDATASIZE 0542 60 PUSH1 0x04 0544 61 PUSH2 0x23e3 0547 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @053B stack[0] = 0x0341 // @053E stack[1] = 0x0548 // @0541 stack[2] = msg.data.length // @0542 stack[3] = 0x04 // } // Block ends with call to 0x23e3, returns to 0x0548 label_0548: // Incoming return from call to 0x23E3 at 0x0547 0548 5B JUMPDEST 0549 61 PUSH2 0x14dd 054C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14dd label_054D: // Incoming jump from 0x01B0, if 0x484b973c == stack[-1] // Inputs[1] { @054E msg.value } 054D 5B JUMPDEST 054E 34 CALLVALUE 054F 80 DUP1 0550 15 ISZERO 0551 61 PUSH2 0x0559 0554 57 *JUMPI // Stack delta = +1 // Outputs[1] { @054E stack[0] = msg.value } // Block ends with conditional jump to 0x0559, if !msg.value label_0555: // Incoming jump from 0x0554, if not !msg.value // Inputs[1] { @0558 memory[0x00:0x00] } 0555 60 PUSH1 0x00 0557 80 DUP1 0558 FD *REVERT // Stack delta = +0 // Outputs[1] { @0558 revert(memory[0x00:0x00]); } // Block terminates label_0559: // Incoming jump from 0x0554, if !msg.value // Inputs[1] { @0561 msg.data.length } 0559 5B JUMPDEST 055A 50 POP 055B 61 PUSH2 0x0341 055E 61 PUSH2 0x0568 0561 36 CALLDATASIZE 0562 60 PUSH1 0x04 0564 61 PUSH2 0x2363 0567 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @055B stack[-1] = 0x0341 // @055E stack[0] = 0x0568 // @0561 stack[1] = msg.data.length // @0562 stack[2] = 0x04 // } // Block ends with call to 0x2363, returns to 0x0568 label_0568: // Incoming return from call to 0x2363 at 0x0567 0568 5B JUMPDEST 0569 61 PUSH2 0x14fd 056C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14fd label_056D: // Incoming jump from 0x01BB, if 0x4bf365df == stack[-1] // Inputs[1] { @056E msg.value } 056D 5B JUMPDEST 056E 34 CALLVALUE 056F 80 DUP1 0570 15 ISZERO 0571 61 PUSH2 0x0579 0574 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056E stack[0] = msg.value } // Block ends with conditional jump to 0x0579, if !msg.value label_0575: // Incoming jump from 0x0574, if not !msg.value // Inputs[1] { @0578 memory[0x00:0x00] } 0575 60 PUSH1 0x00 0577 80 DUP1 0578 FD *REVERT // Stack delta = +0 // Outputs[1] { @0578 revert(memory[0x00:0x00]); } // Block terminates label_0579: // Incoming jump from 0x0574, if !msg.value // Inputs[1] { @057D storage[0x0f] } 0579 5B JUMPDEST 057A 50 POP 057B 60 PUSH1 0x0f 057D 54 SLOAD 057E 61 PUSH2 0x030c 0581 90 SWAP1 0582 60 PUSH1 0xff 0584 16 AND 0585 81 DUP2 0586 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0581 stack[-1] = 0x030c // @0584 stack[0] = 0xff & storage[0x0f] // } // Block ends with unconditional jump to 0x030c label_0587: // Incoming jump from 0x01C6, if 0x55f804b3 == stack[-1] // Inputs[1] { @0588 msg.value } 0587 5B JUMPDEST 0588 34 CALLVALUE 0589 80 DUP1 058A 15 ISZERO 058B 61 PUSH2 0x0593 058E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0588 stack[0] = msg.value } // Block ends with conditional jump to 0x0593, if !msg.value label_058F: // Incoming jump from 0x058E, if not !msg.value // Inputs[1] { @0592 memory[0x00:0x00] } 058F 60 PUSH1 0x00 0591 80 DUP1 0592 FD *REVERT // Stack delta = +0 // Outputs[1] { @0592 revert(memory[0x00:0x00]); } // Block terminates label_0593: // Incoming jump from 0x058E, if !msg.value // Inputs[1] { @059B msg.data.length } 0593 5B JUMPDEST 0594 50 POP 0595 61 PUSH2 0x0341 0598 61 PUSH2 0x05a2 059B 36 CALLDATASIZE 059C 60 PUSH1 0x04 059E 61 PUSH2 0x25c0 05A1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0595 stack[-1] = 0x0341 // @0598 stack[0] = 0x05a2 // @059B stack[1] = msg.data.length // @059C stack[2] = 0x04 // } // Block ends with call to 0x25c0, returns to 0x05A2 label_05A2: // Incoming return from call to 0x25C0 at 0x05A1 05A2 5B JUMPDEST 05A3 61 PUSH2 0x1513 05A6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1513 label_05A7: // Incoming jump from 0x0174, if 0x5c975abb == stack[-1] // Inputs[1] { @05A8 msg.value } 05A7 5B JUMPDEST 05A8 34 CALLVALUE 05A9 80 DUP1 05AA 15 ISZERO 05AB 61 PUSH2 0x05b3 05AE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A8 stack[0] = msg.value } // Block ends with conditional jump to 0x05b3, if !msg.value label_05AF: // Incoming jump from 0x05AE, if not !msg.value // Inputs[1] { @05B2 memory[0x00:0x00] } 05AF 60 PUSH1 0x00 05B1 80 DUP1 05B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B2 revert(memory[0x00:0x00]); } // Block terminates label_05B3: // Incoming jump from 0x05AE, if !msg.value // Inputs[1] { @05B7 storage[0x0b] } 05B3 5B JUMPDEST 05B4 50 POP 05B5 60 PUSH1 0x0b 05B7 54 SLOAD 05B8 60 PUSH1 0x01 05BA 60 PUSH1 0xa0 05BC 1B SHL 05BD 90 SWAP1 05BE 04 DIV 05BF 60 PUSH1 0xff 05C1 16 AND 05C2 61 PUSH2 0x030c 05C5 56 *JUMP // Stack delta = +0 // Outputs[1] { @05C1 stack[-1] = 0xff & storage[0x0b] / (0x01 << 0xa0) } // Block ends with unconditional jump to 0x030c label_05C6: // Incoming jump from 0x017F, if 0x6352211e == stack[-1] // Inputs[1] { @05C7 msg.value } 05C6 5B JUMPDEST 05C7 34 CALLVALUE 05C8 80 DUP1 05C9 15 ISZERO 05CA 61 PUSH2 0x05d2 05CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C7 stack[0] = msg.value } // Block ends with conditional jump to 0x05d2, if !msg.value label_05CE: // Incoming jump from 0x05CD, if not !msg.value // Inputs[1] { @05D1 memory[0x00:0x00] } 05CE 60 PUSH1 0x00 05D0 80 DUP1 05D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D1 revert(memory[0x00:0x00]); } // Block terminates label_05D2: // Incoming jump from 0x05CD, if !msg.value // Inputs[1] { @05DA msg.data.length } 05D2 5B JUMPDEST 05D3 50 POP 05D4 61 PUSH2 0x0385 05D7 61 PUSH2 0x05e1 05DA 36 CALLDATASIZE 05DB 60 PUSH1 0x04 05DD 61 PUSH2 0x234a 05E0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05D4 stack[-1] = 0x0385 // @05D7 stack[0] = 0x05e1 // @05DA stack[1] = msg.data.length // @05DB stack[2] = 0x04 // } // Block ends with call to 0x234a, returns to 0x05E1 label_05E1: // Incoming return from call to 0x234A at 0x05E0 05E1 5B JUMPDEST 05E2 61 PUSH2 0x1527 05E5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1527 label_05E6: // Incoming jump from 0x014E, if 0x6797fdda == stack[-1] // Inputs[1] { @05E7 msg.value } 05E6 5B JUMPDEST 05E7 34 CALLVALUE 05E8 80 DUP1 05E9 15 ISZERO 05EA 61 PUSH2 0x05f2 05ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E7 stack[0] = msg.value } // Block ends with conditional jump to 0x05f2, if !msg.value label_05EE: // Incoming jump from 0x05ED, if not !msg.value // Inputs[1] { @05F1 memory[0x00:0x00] } 05EE 60 PUSH1 0x00 05F0 80 DUP1 05F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F1 revert(memory[0x00:0x00]); } // Block terminates label_05F2: // Incoming jump from 0x05ED, if !msg.value // Inputs[1] { @05FA msg.data.length } 05F2 5B JUMPDEST 05F3 50 POP 05F4 61 PUSH2 0x0341 05F7 61 PUSH2 0x0601 05FA 36 CALLDATASIZE 05FB 60 PUSH1 0x04 05FD 61 PUSH2 0x23b7 0600 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05F4 stack[-1] = 0x0341 // @05F7 stack[0] = 0x0601 // @05FA stack[1] = msg.data.length // @05FB stack[2] = 0x04 // } // Block ends with call to 0x23b7, returns to 0x0601 label_0601: // Incoming return from call to 0x23B7 at 0x0600 0601 5B JUMPDEST 0602 61 PUSH2 0x1532 0605 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1532 label_0606: // Incoming jump from 0x0159, if 0x70a08231 == stack[-1] // Inputs[1] { @0607 msg.value } 0606 5B JUMPDEST 0607 34 CALLVALUE 0608 80 DUP1 0609 15 ISZERO 060A 61 PUSH2 0x0612 060D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0607 stack[0] = msg.value } // Block ends with conditional jump to 0x0612, if !msg.value label_060E: // Incoming jump from 0x060D, if not !msg.value // Inputs[1] { @0611 memory[0x00:0x00] } 060E 60 PUSH1 0x00 0610 80 DUP1 0611 FD *REVERT // Stack delta = +0 // Outputs[1] { @0611 revert(memory[0x00:0x00]); } // Block terminates label_0612: // Incoming jump from 0x060D, if !msg.value // Inputs[1] { @061A msg.data.length } 0612 5B JUMPDEST 0613 50 POP 0614 61 PUSH2 0x03dd 0617 61 PUSH2 0x0621 061A 36 CALLDATASIZE 061B 60 PUSH1 0x04 061D 61 PUSH2 0x22cc 0620 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0614 stack[-1] = 0x03dd // @0617 stack[0] = 0x0621 // @061A stack[1] = msg.data.length // @061B stack[2] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x0621 label_0621: // Incoming return from call to 0x22CC at 0x0620 0621 5B JUMPDEST 0622 61 PUSH2 0x1551 0625 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1551 label_0626: // Incoming jump from 0x0164, if 0x70cf0448 == stack[-1] // Inputs[1] { @0627 msg.value } 0626 5B JUMPDEST 0627 34 CALLVALUE 0628 80 DUP1 0629 15 ISZERO 062A 61 PUSH2 0x0632 062D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0627 stack[0] = msg.value } // Block ends with conditional jump to 0x0632, if !msg.value label_062E: // Incoming jump from 0x062D, if not !msg.value // Inputs[1] { @0631 memory[0x00:0x00] } 062E 60 PUSH1 0x00 0630 80 DUP1 0631 FD *REVERT // Stack delta = +0 // Outputs[1] { @0631 revert(memory[0x00:0x00]); } // Block terminates label_0632: // Incoming jump from 0x062D, if !msg.value // Inputs[1] { @063A msg.data.length } 0632 5B JUMPDEST 0633 50 POP 0634 61 PUSH2 0x0341 0637 61 PUSH2 0x0641 063A 36 CALLDATASIZE 063B 60 PUSH1 0x04 063D 61 PUSH2 0x2609 0640 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0634 stack[-1] = 0x0341 // @0637 stack[0] = 0x0641 // @063A stack[1] = msg.data.length // @063B stack[2] = 0x04 // } // Block ends with unconditional jump to 0x2609 0641 5B JUMPDEST 0642 61 PUSH2 0x15b9 0645 56 *JUMP label_0646: // Incoming jump from 0x011D, if 0x715018a6 == stack[-1] // Inputs[1] { @0647 msg.value } 0646 5B JUMPDEST 0647 34 CALLVALUE 0648 80 DUP1 0649 15 ISZERO 064A 61 PUSH2 0x0652 064D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0647 stack[0] = msg.value } // Block ends with conditional jump to 0x0652, if !msg.value label_064E: // Incoming jump from 0x064D, if not !msg.value // Inputs[1] { @0651 memory[0x00:0x00] } 064E 60 PUSH1 0x00 0650 80 DUP1 0651 FD *REVERT // Stack delta = +0 // Outputs[1] { @0651 revert(memory[0x00:0x00]); } // Block terminates label_0652: // Incoming jump from 0x064D, if !msg.value 0652 5B JUMPDEST 0653 50 POP 0654 61 PUSH2 0x0341 0657 61 PUSH2 0x160c 065A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0654 stack[-1] = 0x0341 } // Block ends with unconditional jump to 0x160c label_065B: // Incoming jump from 0x0128, if 0x7ae0f496 == stack[-1] // Inputs[1] { @065C msg.value } 065B 5B JUMPDEST 065C 34 CALLVALUE 065D 80 DUP1 065E 15 ISZERO 065F 61 PUSH2 0x0667 0662 57 *JUMPI // Stack delta = +1 // Outputs[1] { @065C stack[0] = msg.value } // Block ends with conditional jump to 0x0667, if !msg.value label_0663: // Incoming jump from 0x0662, if not !msg.value // Inputs[1] { @0666 memory[0x00:0x00] } 0663 60 PUSH1 0x00 0665 80 DUP1 0666 FD *REVERT // Stack delta = +0 // Outputs[1] { @0666 revert(memory[0x00:0x00]); } // Block terminates label_0667: // Incoming jump from 0x0662, if !msg.value // Inputs[1] { @066F msg.data.length } 0667 5B JUMPDEST 0668 50 POP 0669 61 PUSH2 0x03dd 066C 61 PUSH2 0x0676 066F 36 CALLDATASIZE 0670 60 PUSH1 0x04 0672 61 PUSH2 0x239c 0675 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0669 stack[-1] = 0x03dd // @066C stack[0] = 0x0676 // @066F stack[1] = msg.data.length // @0670 stack[2] = 0x04 // } // Block ends with call to 0x239c, returns to 0x0676 label_0676: // Incoming return from call to 0x239C at 0x0675 // Inputs[4] // { // @067E stack[-1] // @0684 memory[0x00:0x40] // @0685 storage[keccak256(memory[0x00:0x40])] // @0686 stack[-2] // } 0676 5B JUMPDEST 0677 60 PUSH1 0x13 0679 60 PUSH1 0x20 067B 52 MSTORE 067C 60 PUSH1 0x00 067E 90 SWAP1 067F 81 DUP2 0680 52 MSTORE 0681 60 PUSH1 0x40 0683 90 SWAP1 0684 20 SHA3 0685 54 SLOAD 0686 81 DUP2 0687 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @067B memory[0x20:0x40] = 0x13 // @0680 memory[0x00:0x20] = stack[-1] // @0685 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0688: // Incoming jump from 0x0133, if 0x811d2437 == stack[-1] // Inputs[1] { @0689 msg.value } 0688 5B JUMPDEST 0689 34 CALLVALUE 068A 80 DUP1 068B 15 ISZERO 068C 61 PUSH2 0x0694 068F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0689 stack[0] = msg.value } // Block ends with conditional jump to 0x0694, if !msg.value label_0690: // Incoming jump from 0x068F, if not !msg.value // Inputs[1] { @0693 memory[0x00:0x00] } 0690 60 PUSH1 0x00 0692 80 DUP1 0693 FD *REVERT // Stack delta = +0 // Outputs[1] { @0693 revert(memory[0x00:0x00]); } // Block terminates label_0694: // Incoming jump from 0x068F, if !msg.value // Inputs[1] { @069C msg.data.length } 0694 5B JUMPDEST 0695 50 POP 0696 61 PUSH2 0x0341 0699 61 PUSH2 0x06a3 069C 36 CALLDATASIZE 069D 60 PUSH1 0x04 069F 61 PUSH2 0x234a 06A2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0696 stack[-1] = 0x0341 // @0699 stack[0] = 0x06a3 // @069C stack[1] = msg.data.length // @069D stack[2] = 0x04 // } // Block ends with call to 0x234a, returns to 0x06A3 label_06A3: // Incoming return from call to 0x234A at 0x06A2 06A3 5B JUMPDEST 06A4 61 PUSH2 0x161e 06A7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x161e label_06A8: // Incoming jump from 0x00F7, if 0x8456cb59 == stack[-1] // Inputs[1] { @06A9 msg.value } 06A8 5B JUMPDEST 06A9 34 CALLVALUE 06AA 80 DUP1 06AB 15 ISZERO 06AC 61 PUSH2 0x06b4 06AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06A9 stack[0] = msg.value } // Block ends with conditional jump to 0x06b4, if !msg.value label_06B0: // Incoming jump from 0x06AF, if not !msg.value // Inputs[1] { @06B3 memory[0x00:0x00] } 06B0 60 PUSH1 0x00 06B2 80 DUP1 06B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B3 revert(memory[0x00:0x00]); } // Block terminates label_06B4: // Incoming jump from 0x06AF, if !msg.value 06B4 5B JUMPDEST 06B5 50 POP 06B6 61 PUSH2 0x0341 06B9 61 PUSH2 0x162b 06BC 56 *JUMP // Stack delta = +0 // Outputs[1] { @06B6 stack[-1] = 0x0341 } // Block ends with unconditional jump to 0x162b label_06BD: // Incoming jump from 0x0102, if 0x8693da20 == stack[-1] // Inputs[1] { @06BE msg.value } 06BD 5B JUMPDEST 06BE 34 CALLVALUE 06BF 80 DUP1 06C0 15 ISZERO 06C1 61 PUSH2 0x06c9 06C4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06BE stack[0] = msg.value } // Block ends with conditional jump to 0x06c9, if !msg.value label_06C5: // Incoming jump from 0x06C4, if not !msg.value // Inputs[1] { @06C8 memory[0x00:0x00] } 06C5 60 PUSH1 0x00 06C7 80 DUP1 06C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C8 revert(memory[0x00:0x00]); } // Block terminates label_06C9: // Incoming jump from 0x06C4, if !msg.value // Inputs[1] { @06D0 storage[0x0e] } 06C9 5B JUMPDEST 06CA 50 POP 06CB 61 PUSH2 0x03dd 06CE 60 PUSH1 0x0e 06D0 54 SLOAD 06D1 81 DUP2 06D2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06CB stack[-1] = 0x03dd // @06D0 stack[0] = storage[0x0e] // } // Block ends with unconditional jump to 0x03dd label_06D3: // Incoming jump from 0x010D, if 0x8da5cb5b == stack[-1] // Inputs[1] { @06D4 msg.value } 06D3 5B JUMPDEST 06D4 34 CALLVALUE 06D5 80 DUP1 06D6 15 ISZERO 06D7 61 PUSH2 0x06df 06DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06D4 stack[0] = msg.value } // Block ends with conditional jump to 0x06df, if !msg.value label_06DB: // Incoming jump from 0x06DA, if not !msg.value // Inputs[1] { @06DE memory[0x00:0x00] } 06DB 60 PUSH1 0x00 06DD 80 DUP1 06DE FD *REVERT // Stack delta = +0 // Outputs[1] { @06DE revert(memory[0x00:0x00]); } // Block terminates label_06DF: // Incoming jump from 0x06DA, if !msg.value // Inputs[1] { @06E3 storage[0x0b] } 06DF 5B JUMPDEST 06E0 50 POP 06E1 60 PUSH1 0x0b 06E3 54 SLOAD 06E4 60 PUSH1 0x01 06E6 60 PUSH1 0x01 06E8 60 PUSH1 0xa0 06EA 1B SHL 06EB 03 SUB 06EC 16 AND 06ED 61 PUSH2 0x0385 06F0 56 *JUMP // Stack delta = +0 // Outputs[1] { @06EC stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0b] } // Block ends with unconditional jump to 0x0385 label_06F1: // Incoming jump from 0x00C6, if 0x95d89b41 == stack[-1] // Inputs[1] { @06F2 msg.value } 06F1 5B JUMPDEST 06F2 34 CALLVALUE 06F3 80 DUP1 06F4 15 ISZERO 06F5 61 PUSH2 0x06fd 06F8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06F2 stack[0] = msg.value } // Block ends with conditional jump to 0x06fd, if !msg.value label_06F9: // Incoming jump from 0x06F8, if not !msg.value // Inputs[1] { @06FC memory[0x00:0x00] } 06F9 60 PUSH1 0x00 06FB 80 DUP1 06FC FD *REVERT // Stack delta = +0 // Outputs[1] { @06FC revert(memory[0x00:0x00]); } // Block terminates label_06FD: // Incoming jump from 0x06F8, if !msg.value 06FD 5B JUMPDEST 06FE 50 POP 06FF 61 PUSH2 0x0358 0702 61 PUSH2 0x163b 0705 56 *JUMP // Stack delta = +0 // Outputs[1] { @06FF stack[-1] = 0x0358 } // Block ends with call to 0x163b, returns to 0x0358 label_0706: // Incoming jump from 0x00D1, if 0x98f06ab1 == stack[-1] // Inputs[1] { @0707 msg.value } 0706 5B JUMPDEST 0707 34 CALLVALUE 0708 80 DUP1 0709 15 ISZERO 070A 61 PUSH2 0x0712 070D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0707 stack[0] = msg.value } // Block ends with conditional jump to 0x0712, if !msg.value label_070E: // Incoming jump from 0x070D, if not !msg.value // Inputs[1] { @0711 memory[0x00:0x00] } 070E 60 PUSH1 0x00 0710 80 DUP1 0711 FD *REVERT // Stack delta = +0 // Outputs[1] { @0711 revert(memory[0x00:0x00]); } // Block terminates label_0712: // Incoming jump from 0x070D, if !msg.value // Inputs[1] { @071A msg.data.length } 0712 5B JUMPDEST 0713 50 POP 0714 61 PUSH2 0x03dd 0717 61 PUSH2 0x0721 071A 36 CALLDATASIZE 071B 60 PUSH1 0x04 071D 61 PUSH2 0x2633 0720 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0714 stack[-1] = 0x03dd // @0717 stack[0] = 0x0721 // @071A stack[1] = msg.data.length // @071B stack[2] = 0x04 // } // Block ends with unconditional jump to 0x2633 0721 5B JUMPDEST 0722 60 PUSH1 0x14 0724 60 PUSH1 0x20 0726 90 SWAP1 0727 81 DUP2 0728 52 MSTORE 0729 60 PUSH1 0x00 072B 92 SWAP3 072C 83 DUP4 072D 52 MSTORE 072E 60 PUSH1 0x40 0730 80 DUP1 0731 84 DUP5 0732 20 SHA3 0733 90 SWAP1 0734 91 SWAP2 0735 52 MSTORE 0736 90 SWAP1 0737 82 DUP3 0738 52 MSTORE 0739 90 SWAP1 073A 20 SHA3 073B 54 SLOAD 073C 81 DUP2 073D 56 *JUMP label_073E: // Incoming jump from 0x00A0, if 0xa0c6d465 == stack[-1] // Inputs[1] { @073F msg.value } 073E 5B JUMPDEST 073F 34 CALLVALUE 0740 80 DUP1 0741 15 ISZERO 0742 61 PUSH2 0x074a 0745 57 *JUMPI // Stack delta = +1 // Outputs[1] { @073F stack[0] = msg.value } // Block ends with conditional jump to 0x074a, if !msg.value label_0746: // Incoming jump from 0x0745, if not !msg.value // Inputs[1] { @0749 memory[0x00:0x00] } 0746 60 PUSH1 0x00 0748 80 DUP1 0749 FD *REVERT // Stack delta = +0 // Outputs[1] { @0749 revert(memory[0x00:0x00]); } // Block terminates label_074A: // Incoming jump from 0x0745, if !msg.value // Inputs[1] { @0752 msg.data.length } 074A 5B JUMPDEST 074B 50 POP 074C 61 PUSH2 0x0341 074F 61 PUSH2 0x0759 0752 36 CALLDATASIZE 0753 60 PUSH1 0x04 0755 61 PUSH2 0x242f 0758 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @074C stack[-1] = 0x0341 // @074F stack[0] = 0x0759 // @0752 stack[1] = msg.data.length // @0753 stack[2] = 0x04 // } // Block ends with call to 0x242f, returns to 0x0759 label_0759: // Incoming return from call to 0x242F at 0x0758 0759 5B JUMPDEST 075A 61 PUSH2 0x164a 075D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x164a label_075E: // Incoming jump from 0x00AB, if 0xa22cb465 == stack[-1] // Inputs[1] { @075F msg.value } 075E 5B JUMPDEST 075F 34 CALLVALUE 0760 80 DUP1 0761 15 ISZERO 0762 61 PUSH2 0x076a 0765 57 *JUMPI // Stack delta = +1 // Outputs[1] { @075F stack[0] = msg.value } // Block ends with conditional jump to 0x076a, if !msg.value label_0766: // Incoming jump from 0x0765, if not !msg.value // Inputs[1] { @0769 memory[0x00:0x00] } 0766 60 PUSH1 0x00 0768 80 DUP1 0769 FD *REVERT // Stack delta = +0 // Outputs[1] { @0769 revert(memory[0x00:0x00]); } // Block terminates label_076A: // Incoming jump from 0x0765, if !msg.value // Inputs[1] { @0772 msg.data.length } 076A 5B JUMPDEST 076B 50 POP 076C 61 PUSH2 0x0341 076F 61 PUSH2 0x0779 0772 36 CALLDATASIZE 0773 60 PUSH1 0x04 0775 61 PUSH2 0x265d 0778 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @076C stack[-1] = 0x0341 // @076F stack[0] = 0x0779 // @0772 stack[1] = msg.data.length // @0773 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x265d 0779 5B JUMPDEST 077A 61 PUSH2 0x1665 077D 56 *JUMP label_077E: // Incoming jump from 0x00B6, if 0xad2f852a == stack[-1] // Inputs[1] { @077F msg.value } 077E 5B JUMPDEST 077F 34 CALLVALUE 0780 80 DUP1 0781 15 ISZERO 0782 61 PUSH2 0x078a 0785 57 *JUMPI // Stack delta = +1 // Outputs[1] { @077F stack[0] = msg.value } // Block ends with conditional jump to 0x078a, if !msg.value label_0786: // Incoming jump from 0x0785, if not !msg.value // Inputs[1] { @0789 memory[0x00:0x00] } 0786 60 PUSH1 0x00 0788 80 DUP1 0789 FD *REVERT // Stack delta = +0 // Outputs[1] { @0789 revert(memory[0x00:0x00]); } // Block terminates label_078A: // Incoming jump from 0x0785, if !msg.value // Inputs[1] { @078E storage[0x0f] } 078A 5B JUMPDEST 078B 50 POP 078C 60 PUSH1 0x0f 078E 54 SLOAD 078F 61 PUSH2 0x0385 0792 90 SWAP1 0793 61 PUSH2 0x0100 0796 90 SWAP1 0797 04 DIV 0798 60 PUSH1 0x01 079A 60 PUSH1 0x01 079C 60 PUSH1 0xa0 079E 1B SHL 079F 03 SUB 07A0 16 AND 07A1 81 DUP2 07A2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0792 stack[-1] = 0x0385 // @07A0 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0f] / 0x0100 // } // Block ends with unconditional jump to 0x0385 label_07A3: // Incoming jump from 0x006F, if 0xb88d4fde == stack[-1] // Inputs[1] { @07AA msg.data.length } 07A3 5B JUMPDEST 07A4 61 PUSH2 0x0341 07A7 61 PUSH2 0x07b1 07AA 36 CALLDATASIZE 07AB 60 PUSH1 0x04 07AD 61 PUSH2 0x2687 07B0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07A4 stack[0] = 0x0341 // @07A7 stack[1] = 0x07b1 // @07AA stack[2] = msg.data.length // @07AB stack[3] = 0x04 // } // Block ends with call to 0x2687, returns to 0x07B1 label_07B1: // Incoming return from call to 0x2687 at 0x07B0 07B1 5B JUMPDEST 07B2 61 PUSH2 0x16d1 07B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x16d1 label_07B6: // Incoming jump from 0x007A, if 0xb8997a97 == stack[-1] // Inputs[1] { @07B7 msg.value } 07B6 5B JUMPDEST 07B7 34 CALLVALUE 07B8 80 DUP1 07B9 15 ISZERO 07BA 61 PUSH2 0x07c2 07BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07B7 stack[0] = msg.value } // Block ends with conditional jump to 0x07c2, if !msg.value label_07BE: // Incoming jump from 0x07BD, if not !msg.value // Inputs[1] { @07C1 memory[0x00:0x00] } 07BE 60 PUSH1 0x00 07C0 80 DUP1 07C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @07C1 revert(memory[0x00:0x00]); } // Block terminates label_07C2: // Incoming jump from 0x07BD, if !msg.value // Inputs[1] { @07C6 storage[0x10] } 07C2 5B JUMPDEST 07C3 50 POP 07C4 60 PUSH1 0x10 07C6 54 SLOAD 07C7 61 PUSH2 0x07db 07CA 90 SWAP1 07CB 6B PUSH12 0xffffffffffffffffffffffff 07D8 16 AND 07D9 81 DUP2 07DA 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @07CA stack[-1] = 0x07db // @07D8 stack[0] = 0xffffffffffffffffffffffff & storage[0x10] // } // Block ends with unconditional jump to 0x07db label_07DB: // Incoming jump from 0x07DA // Inputs[2] // { // @07DE memory[0x40:0x60] // @07ED stack[-1] // } 07DB 5B JUMPDEST 07DC 60 PUSH1 0x40 07DE 51 MLOAD 07DF 6B PUSH12 0xffffffffffffffffffffffff 07EC 90 SWAP1 07ED 91 SWAP2 07EE 16 AND 07EF 81 DUP2 07F0 52 MSTORE 07F1 60 PUSH1 0x20 07F3 01 ADD 07F4 61 PUSH2 0x0318 07F7 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @07F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffffffffffffffffffff // @07F3 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0318 label_07F8: // Incoming jump from 0x0085, if 0xc87b56dd == stack[-1] // Inputs[1] { @07F9 msg.value } 07F8 5B JUMPDEST 07F9 34 CALLVALUE 07FA 80 DUP1 07FB 15 ISZERO 07FC 61 PUSH2 0x0804 07FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0804, if !msg.value label_0800: // Incoming jump from 0x07FF, if not !msg.value // Inputs[1] { @0803 memory[0x00:0x00] } 0800 60 PUSH1 0x00 0802 80 DUP1 0803 FD *REVERT // Stack delta = +0 // Outputs[1] { @0803 revert(memory[0x00:0x00]); } // Block terminates label_0804: // Incoming jump from 0x07FF, if !msg.value // Inputs[1] { @080C msg.data.length } 0804 5B JUMPDEST 0805 50 POP 0806 61 PUSH2 0x0358 0809 61 PUSH2 0x0813 080C 36 CALLDATASIZE 080D 60 PUSH1 0x04 080F 61 PUSH2 0x234a 0812 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0806 stack[-1] = 0x0358 // @0809 stack[0] = 0x0813 // @080C stack[1] = msg.data.length // @080D stack[2] = 0x04 // } // Block ends with call to 0x234a, returns to 0x0813 label_0813: // Incoming return from call to 0x234A at 0x0812 0813 5B JUMPDEST 0814 61 PUSH2 0x171b 0817 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x171b label_0818: // Incoming jump from 0x0049, if 0xe334b267 == stack[-1] // Inputs[1] { @0819 msg.value } 0818 5B JUMPDEST 0819 34 CALLVALUE 081A 80 DUP1 081B 15 ISZERO 081C 61 PUSH2 0x0824 081F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0819 stack[0] = msg.value } // Block ends with conditional jump to 0x0824, if !msg.value label_0820: // Incoming jump from 0x081F, if not !msg.value // Inputs[1] { @0823 memory[0x00:0x00] } 0820 60 PUSH1 0x00 0822 80 DUP1 0823 FD *REVERT // Stack delta = +0 // Outputs[1] { @0823 revert(memory[0x00:0x00]); } // Block terminates label_0824: // Incoming jump from 0x081F, if !msg.value // Inputs[1] { @082C msg.data.length } 0824 5B JUMPDEST 0825 50 POP 0826 61 PUSH2 0x030c 0829 61 PUSH2 0x0833 082C 36 CALLDATASIZE 082D 60 PUSH1 0x04 082F 61 PUSH2 0x239c 0832 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0826 stack[-1] = 0x030c // @0829 stack[0] = 0x0833 // @082C stack[1] = msg.data.length // @082D stack[2] = 0x04 // } // Block ends with call to 0x239c, returns to 0x0833 label_0833: // Incoming return from call to 0x239C at 0x0832 // Inputs[4] // { // @083B stack[-1] // @0841 memory[0x00:0x40] // @0842 storage[keccak256(memory[0x00:0x40])] // @0846 stack[-2] // } 0833 5B JUMPDEST 0834 60 PUSH1 0x12 0836 60 PUSH1 0x20 0838 52 MSTORE 0839 60 PUSH1 0x00 083B 90 SWAP1 083C 81 DUP2 083D 52 MSTORE 083E 60 PUSH1 0x40 0840 90 SWAP1 0841 20 SHA3 0842 54 SLOAD 0843 60 PUSH1 0xff 0845 16 AND 0846 81 DUP2 0847 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0838 memory[0x20:0x40] = 0x12 // @083D memory[0x00:0x20] = stack[-1] // @0845 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0848: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0849 msg.value } 0848 5B JUMPDEST 0849 34 CALLVALUE 084A 80 DUP1 084B 15 ISZERO 084C 61 PUSH2 0x0854 084F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0849 stack[0] = msg.value } // Block ends with conditional jump to 0x0854, if !msg.value label_0850: // Incoming jump from 0x084F, if not !msg.value // Inputs[1] { @0853 memory[0x00:0x00] } 0850 60 PUSH1 0x00 0852 80 DUP1 0853 FD *REVERT // Stack delta = +0 // Outputs[1] { @0853 revert(memory[0x00:0x00]); } // Block terminates label_0854: // Incoming jump from 0x084F, if !msg.value // Inputs[1] { @085C msg.data.length } 0854 5B JUMPDEST 0855 50 POP 0856 61 PUSH2 0x030c 0859 61 PUSH2 0x0863 085C 36 CALLDATASIZE 085D 60 PUSH1 0x04 085F 61 PUSH2 0x2703 0862 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0856 stack[-1] = 0x030c // @0859 stack[0] = 0x0863 // @085C stack[1] = msg.data.length // @085D stack[2] = 0x04 // } // Block ends with unconditional jump to 0x2703 0863 5B JUMPDEST 0864 60 PUSH1 0x01 0866 60 PUSH1 0x01 0868 60 PUSH1 0xa0 086A 1B SHL 086B 03 SUB 086C 91 SWAP2 086D 82 DUP3 086E 16 AND 086F 60 PUSH1 0x00 0871 90 SWAP1 0872 81 DUP2 0873 52 MSTORE 0874 60 PUSH1 0x07 0876 60 PUSH1 0x20 0878 90 SWAP1 0879 81 DUP2 087A 52 MSTORE 087B 60 PUSH1 0x40 087D 80 DUP1 087E 83 DUP4 087F 20 SHA3 0880 93 SWAP4 0881 90 SWAP1 0882 94 SWAP5 0883 16 AND 0884 82 DUP3 0885 52 MSTORE 0886 91 SWAP2 0887 90 SWAP1 0888 91 SWAP2 0889 52 MSTORE 088A 20 SHA3 088B 54 SLOAD 088C 60 PUSH1 0xff 088E 16 AND 088F 90 SWAP1 0890 56 *JUMP label_0891: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @0892 msg.value } 0891 5B JUMPDEST 0892 34 CALLVALUE 0893 80 DUP1 0894 15 ISZERO 0895 61 PUSH2 0x089d 0898 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0892 stack[0] = msg.value } // Block ends with conditional jump to 0x089d, if !msg.value label_0899: // Incoming jump from 0x0898, if not !msg.value // Inputs[1] { @089C memory[0x00:0x00] } 0899 60 PUSH1 0x00 089B 80 DUP1 089C FD *REVERT // Stack delta = +0 // Outputs[1] { @089C revert(memory[0x00:0x00]); } // Block terminates label_089D: // Incoming jump from 0x0898, if !msg.value // Inputs[1] { @08A5 msg.data.length } 089D 5B JUMPDEST 089E 50 POP 089F 61 PUSH2 0x0341 08A2 61 PUSH2 0x08ac 08A5 36 CALLDATASIZE 08A6 60 PUSH1 0x04 08A8 61 PUSH2 0x22cc 08AB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @089F stack[-1] = 0x0341 // @08A2 stack[0] = 0x08ac // @08A5 stack[1] = msg.data.length // @08A6 stack[2] = 0x04 // } // Block ends with call to 0x22cc, returns to 0x08AC label_08AC: // Incoming return from call to 0x22CC at 0x08AB 08AC 5B JUMPDEST 08AD 61 PUSH2 0x1783 08B0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1783 label_08B1: // Incoming jump from 0x030B // Inputs[1] { @08B7 stack[-1] } 08B1 5B JUMPDEST 08B2 60 PUSH1 0x00 08B4 61 PUSH2 0x08bc 08B7 82 DUP3 08B8 61 PUSH2 0x1810 08BB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08B2 stack[0] = 0x00 // @08B4 stack[1] = 0x08bc // @08B7 stack[2] = stack[-1] // } // Block ends with call to 0x1810, returns to 0x08BC label_08BC: // Incoming return from call to 0x1810 at 0x08BB // Inputs[1] { @08BD stack[-1] } 08BC 5B JUMPDEST 08BD 80 DUP1 08BE 61 PUSH2 0x08cb 08C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08cb, if stack[-1] label_08C2: // Incoming jump from 0x08C1, if not stack[-1] // Inputs[1] { @08C6 stack[-3] } 08C2 50 POP 08C3 61 PUSH2 0x08cb 08C6 82 DUP3 08C7 61 PUSH2 0x1890 08CA 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @08C3 stack[-1] = 0x08cb // @08C6 stack[0] = stack[-3] // } // Block ends with call to 0x1890, returns to 0x08CB label_08CB: // Incoming jump from 0x1A6C, if !stack[-1] // Incoming return from call to 0x1890 at 0x08CA // Incoming jump from 0x185F, if stack[-1] // Incoming jump from 0x185F, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x18C4, if 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x18DD // Incoming jump from 0x08C1, if stack[-1] // Incoming jump from 0x2794, if (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] // Incoming jump from 0x1A6C, if !(stack[-3] < storage[0x00]) // Incoming return from call to 0x1A87 at 0x1531 // Incoming jump from 0x27C9, if !(stack[-1] > stack[-2] + stack[-1]) // Inputs[3] // { // @08CC stack[-1] // @08CC stack[-4] // @08CD stack[-3] // } 08CB 5B JUMPDEST 08CC 92 SWAP3 08CD 91 SWAP2 08CE 50 POP 08CF 50 POP 08D0 56 *JUMP // Stack delta = -3 // Outputs[1] { @08CC stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_08D1: // Incoming jump from 0x0340 08D1 5B JUMPDEST 08D2 61 PUSH2 0x08d9 08D5 61 PUSH2 0x18de 08D8 56 *JUMP // Stack delta = +1 // Outputs[1] { @08D2 stack[0] = 0x08d9 } // Block ends with call to 0x18de, returns to 0x08D9 label_08D9: // Incoming return from call to 0x18DE at 0x08D8 // Inputs[3] // { // @08DD storage[0x0f] // @090B stack[-1] // @091A storage[0x10] // } 08D9 5B JUMPDEST 08DA 60 PUSH1 0x0f 08DC 80 DUP1 08DD 54 SLOAD 08DE 7F PUSH32 0xffffffffffffffffffffff0000000000000000000000000000000000000000ff 08FF 16 AND 0900 61 PUSH2 0x0100 0903 60 PUSH1 0x01 0905 60 PUSH1 0x01 0907 60 PUSH1 0xa0 0909 1B SHL 090A 03 SUB 090B 84 DUP5 090C 81 DUP2 090D 16 AND 090E 82 DUP3 090F 02 MUL 0910 92 SWAP3 0911 90 SWAP1 0912 92 SWAP3 0913 17 OR 0914 92 SWAP3 0915 83 DUP4 0916 90 SWAP1 0917 55 SSTORE 0918 60 PUSH1 0x10 091A 54 SLOAD 091B 61 PUSH2 0x0939 091E 93 SWAP4 091F 91 SWAP2 0920 90 SWAP1 0921 91 SWAP2 0922 04 DIV 0923 90 SWAP1 0924 91 SWAP2 0925 16 AND 0926 90 SWAP1 0927 6B PUSH12 0xffffffffffffffffffffffff 0934 16 AND 0935 61 PUSH2 0x1938 0938 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0917 storage[0x0f] = 0x0100 * ((0x01 << 0xa0) - 0x01 & stack[-1]) | (0xffffffffffffffffffffff0000000000000000000000000000000000000000ff & storage[0x0f]) // @091E stack[0] = 0x0939 // @0926 stack[1] = (0x01 << 0xa0) - 0x01 & (0x0100 * ((0x01 << 0xa0) - 0x01 & stack[-1]) | (0xffffffffffffffffffffff0000000000000000000000000000000000000000ff & storage[0x0f])) / 0x0100 // @0934 stack[2] = 0xffffffffffffffffffffffff & storage[0x10] // } // Block ends with call to 0x1938, returns to 0x0939 label_0939: // Incoming return from call to 0x1938 at 0x1053 // Incoming return from call to 0x1938 at 0x0938 // Incoming jump from 0x228E, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1F2E at 0x180F // Inputs[1] { @093B stack[-2] } 0939 5B JUMPDEST 093A 50 POP 093B 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_093C: // Incoming call from 0x0357, returns to 0x0358 // Inputs[1] { @0942 storage[0x02] } 093C 5B JUMPDEST 093D 60 PUSH1 0x60 093F 60 PUSH1 0x02 0941 80 DUP1 0942 54 SLOAD 0943 61 PUSH2 0x094b 0946 90 SWAP1 0947 61 PUSH2 0x271f 094A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @093D stack[0] = 0x60 // @093F stack[1] = 0x02 // @0946 stack[2] = 0x094b // @0946 stack[3] = storage[0x02] // } // Block ends with call to 0x271f, returns to 0x094B label_094B: // Incoming return from call to 0x271F at 0x1649 // Incoming return from call to 0x271F at 0x220C // Incoming return from call to 0x271F at 0x094A // Inputs[4] // { // @094C stack[-1] // @095B memory[0x40:0x60] // @0963 stack[-2] // @096E storage[stack[-2]] // } 094B 5B JUMPDEST 094C 80 DUP1 094D 60 PUSH1 0x1f 094F 01 ADD 0950 60 PUSH1 0x20 0952 80 DUP1 0953 91 SWAP2 0954 04 DIV 0955 02 MUL 0956 60 PUSH1 0x20 0958 01 ADD 0959 60 PUSH1 0x40 095B 51 MLOAD 095C 90 SWAP1 095D 81 DUP2 095E 01 ADD 095F 60 PUSH1 0x40 0961 52 MSTORE 0962 80 DUP1 0963 92 SWAP3 0964 91 SWAP2 0965 90 SWAP1 0966 81 DUP2 0967 81 DUP2 0968 52 MSTORE 0969 60 PUSH1 0x20 096B 01 ADD 096C 82 DUP3 096D 80 DUP1 096E 54 SLOAD 096F 61 PUSH2 0x0977 0972 90 SWAP1 0973 61 PUSH2 0x271f 0976 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0961 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0963 stack[-2] = memory[0x40:0x60] // @0964 stack[-1] = stack[-2] // @0965 stack[0] = stack[-1] // @0968 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @096B stack[1] = 0x20 + memory[0x40:0x60] // @096C stack[2] = stack[-2] // @0972 stack[4] = storage[stack[-2]] // @0972 stack[3] = 0x0977 // } // Block ends with call to 0x271f, returns to 0x0977 label_0977: // Incoming return from call to 0x271F at 0x0976 // Inputs[1] { @0978 stack[-1] } 0977 5B JUMPDEST 0978 80 DUP1 0979 15 ISZERO 097A 61 PUSH2 0x09c4 097D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09c4, if !stack[-1] label_097E: // Incoming jump from 0x097D, if not !stack[-1] // Inputs[1] { @097E stack[-1] } 097E 80 DUP1 097F 60 PUSH1 0x1f 0981 10 LT 0982 61 PUSH2 0x0999 0985 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0999, if 0x1f < stack[-1] label_0986: // Incoming jump from 0x0985, if not 0x1f < stack[-1] // Inputs[4] // { // @098A stack[-2] // @098B storage[stack[-2]] // @098E stack[-3] // @0990 stack[-1] // } 0986 61 PUSH2 0x0100 0989 80 DUP1 098A 83 DUP4 098B 54 SLOAD 098C 04 DIV 098D 02 MUL 098E 83 DUP4 098F 52 MSTORE 0990 91 SWAP2 0991 60 PUSH1 0x20 0993 01 ADD 0994 91 SWAP2 0995 61 PUSH2 0x09c4 0998 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @098F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0994 stack[-1] = stack[-1] // @0994 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x09c4 label_0999: // Incoming jump from 0x0985, if 0x1f < stack[-1] // Inputs[5] // { // @099A stack[-3] // @099B stack[-1] // @099D stack[-2] // @09A5 memory[0x00:0x20] // @09A9 storage[keccak256(memory[0x00:0x20])] // } 0999 5B JUMPDEST 099A 82 DUP3 099B 01 ADD 099C 91 SWAP2 099D 90 SWAP1 099E 60 PUSH1 0x00 09A0 52 MSTORE 09A1 60 PUSH1 0x20 09A3 60 PUSH1 0x00 09A5 20 SHA3 09A6 90 SWAP1 09A7 5B JUMPDEST 09A8 81 DUP2 09A9 54 SLOAD 09AA 81 DUP2 09AB 52 MSTORE 09AC 90 SWAP1 09AD 60 PUSH1 0x01 09AF 01 ADD 09B0 90 SWAP1 09B1 60 PUSH1 0x20 09B3 01 ADD 09B4 80 DUP1 09B5 83 DUP4 09B6 11 GT 09B7 61 PUSH2 0x09a7 09BA 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @099C stack[-3] = stack[-3] + stack[-1] // @09A0 memory[0x00:0x20] = stack[-2] // @09AB memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @09B0 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @09B3 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x09a7, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_09BB: // Incoming jump from 0x09BA, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x09BA, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @09BB stack[-3] // @09BC stack[-1] // } 09BB 82 DUP3 09BC 90 SWAP1 09BD 03 SUB 09BE 60 PUSH1 0x1f 09C0 16 AND 09C1 82 DUP3 09C2 01 ADD 09C3 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @09C3 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @09C3 stack[-1] = stack[-3] // } // Block continues label_09C4: // Incoming jump from 0x097D, if !stack[-1] // Incoming jump from 0x09C3 // Incoming jump from 0x0998 // Inputs[3] // { // @09CA stack[-6] // @09CA stack[-7] // @09CC stack[-8] // } 09C4 5B JUMPDEST 09C5 50 POP 09C6 50 POP 09C7 50 POP 09C8 50 POP 09C9 50 POP 09CA 90 SWAP1 09CB 50 POP 09CC 90 SWAP1 09CD 56 *JUMP // Stack delta = -7 // Outputs[1] { @09CC stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_09CE: // Incoming jump from 0x0384 // Inputs[1] { @09D4 stack[-1] } 09CE 5B JUMPDEST 09CF 60 PUSH1 0x00 09D1 61 PUSH2 0x09d9 09D4 82 DUP3 09D5 61 PUSH2 0x1a52 09D8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09CF stack[0] = 0x00 // @09D1 stack[1] = 0x09d9 // @09D4 stack[2] = stack[-1] // } // Block ends with call to 0x1a52, returns to 0x09D9 label_09D9: // Incoming return from call to 0x1A52 at 0x09D8 // Inputs[1] { @09DD stack[-1] } 09D9 5B JUMPDEST 09DA 61 PUSH2 0x0a0f 09DD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a0f, if stack[-1] label_09DE: // Incoming jump from 0x09DD, if not stack[-1] // Inputs[3] // { // @09E0 memory[0x40:0x60] // @0A09 memory[0x40:0x60] // @0A0E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09DE 60 PUSH1 0x40 09E0 51 MLOAD 09E1 7F PUSH32 0xcf4700e400000000000000000000000000000000000000000000000000000000 0A02 81 DUP2 0A03 52 MSTORE 0A04 60 PUSH1 0x04 0A06 01 ADD 0A07 60 PUSH1 0x40 0A09 51 MLOAD 0A0A 80 DUP1 0A0B 91 SWAP2 0A0C 03 SUB 0A0D 90 SWAP1 0A0E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A03 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcf4700e400000000000000000000000000000000000000000000000000000000 // @0A0E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A0F: // Incoming jump from 0x09DD, if stack[-1] // Inputs[4] // { // @0A13 stack[-2] // @0A1E memory[0x00:0x40] // @0A1F storage[keccak256(memory[0x00:0x40])] // @0A29 stack[-3] // } 0A0F 5B JUMPDEST 0A10 50 POP 0A11 60 PUSH1 0x00 0A13 90 SWAP1 0A14 81 DUP2 0A15 52 MSTORE 0A16 60 PUSH1 0x06 0A18 60 PUSH1 0x20 0A1A 52 MSTORE 0A1B 60 PUSH1 0x40 0A1D 90 SWAP1 0A1E 20 SHA3 0A1F 54 SLOAD 0A20 60 PUSH1 0x01 0A22 60 PUSH1 0x01 0A24 60 PUSH1 0xa0 0A26 1B SHL 0A27 03 SUB 0A28 16 AND 0A29 90 SWAP1 0A2A 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0A15 memory[0x00:0x20] = stack[-2] // @0A1A memory[0x20:0x40] = 0x06 // @0A29 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0A2B: // Incoming jump from 0x03AF // Inputs[1] { @0A31 stack[-1] } 0A2B 5B JUMPDEST 0A2C 60 PUSH1 0x00 0A2E 61 PUSH2 0x0a36 0A31 82 DUP3 0A32 61 PUSH2 0x1527 0A35 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A2C stack[0] = 0x00 // @0A2E stack[1] = 0x0a36 // @0A31 stack[2] = stack[-1] // } // Block ends with call to 0x1527, returns to 0x0A36 label_0A36: // Incoming return from call to 0x1527 at 0x0A35 // Inputs[3] // { // @0A37 stack[-2] // @0A37 stack[-1] // @0A39 msg.sender // } 0A36 5B JUMPDEST 0A37 90 SWAP1 0A38 50 POP 0A39 33 CALLER 0A3A 60 PUSH1 0x01 0A3C 60 PUSH1 0x01 0A3E 60 PUSH1 0xa0 0A40 1B SHL 0A41 03 SUB 0A42 82 DUP3 0A43 16 AND 0A44 14 EQ 0A45 61 PUSH2 0x0aa5 0A48 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0A37 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0aa5, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0A49: // Incoming jump from 0x0A48, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[5] // { // @0A51 stack[-1] // @0A63 memory[0x00:0x40] // @0A64 msg.sender // @0A6B memory[0x00:0x40] // @0A6C storage[keccak256(memory[0x00:0x40])] // } 0A49 60 PUSH1 0x01 0A4B 60 PUSH1 0x01 0A4D 60 PUSH1 0xa0 0A4F 1B SHL 0A50 03 SUB 0A51 81 DUP2 0A52 16 AND 0A53 60 PUSH1 0x00 0A55 90 SWAP1 0A56 81 DUP2 0A57 52 MSTORE 0A58 60 PUSH1 0x07 0A5A 60 PUSH1 0x20 0A5C 90 SWAP1 0A5D 81 DUP2 0A5E 52 MSTORE 0A5F 60 PUSH1 0x40 0A61 80 DUP1 0A62 83 DUP4 0A63 20 SHA3 0A64 33 CALLER 0A65 84 DUP5 0A66 52 MSTORE 0A67 90 SWAP1 0A68 91 SWAP2 0A69 52 MSTORE 0A6A 90 SWAP1 0A6B 20 SHA3 0A6C 54 SLOAD 0A6D 60 PUSH1 0xff 0A6F 16 AND 0A70 61 PUSH2 0x0aa5 0A73 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0A57 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0A5E memory[0x20:0x40] = 0x07 // @0A66 memory[0x00:0x20] = msg.sender // @0A69 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0aa5, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0A74: // Incoming jump from 0x0A73, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0A76 memory[0x40:0x60] // @0A9F memory[0x40:0x60] // @0AA4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A74 60 PUSH1 0x40 0A76 51 MLOAD 0A77 7F PUSH32 0xcfb3b94200000000000000000000000000000000000000000000000000000000 0A98 81 DUP2 0A99 52 MSTORE 0A9A 60 PUSH1 0x04 0A9C 01 ADD 0A9D 60 PUSH1 0x40 0A9F 51 MLOAD 0AA0 80 DUP1 0AA1 91 SWAP2 0AA2 03 SUB 0AA3 90 SWAP1 0AA4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A99 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcfb3b94200000000000000000000000000000000000000000000000000000000 // @0AA4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0AA5: // Incoming jump from 0x0A73, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0A48, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[8] // { // @0AA8 stack[-2] // @0AB4 memory[0x00:0x40] // @0AB6 storage[keccak256(memory[0x00:0x40])] // @0AD6 stack[-3] // @0AE0 memory[0x40:0x60] // @0AE4 stack[-1] // @0B09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0B0D stack[-4] // } 0AA5 5B JUMPDEST 0AA6 60 PUSH1 0x00 0AA8 82 DUP3 0AA9 81 DUP2 0AAA 52 MSTORE 0AAB 60 PUSH1 0x06 0AAD 60 PUSH1 0x20 0AAF 52 MSTORE 0AB0 60 PUSH1 0x40 0AB2 80 DUP1 0AB3 82 DUP3 0AB4 20 SHA3 0AB5 80 DUP1 0AB6 54 SLOAD 0AB7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ACC 19 NOT 0ACD 16 AND 0ACE 60 PUSH1 0x01 0AD0 60 PUSH1 0x01 0AD2 60 PUSH1 0xa0 0AD4 1B SHL 0AD5 03 SUB 0AD6 87 DUP8 0AD7 81 DUP2 0AD8 16 AND 0AD9 91 SWAP2 0ADA 82 DUP3 0ADB 17 OR 0ADC 90 SWAP1 0ADD 92 SWAP3 0ADE 55 SSTORE 0ADF 91 SWAP2 0AE0 51 MLOAD 0AE1 85 DUP6 0AE2 93 SWAP4 0AE3 91 SWAP2 0AE4 85 DUP6 0AE5 16 AND 0AE6 91 SWAP2 0AE7 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 0B08 91 SWAP2 0B09 A4 LOG4 0B0A 50 POP 0B0B 50 POP 0B0C 50 POP 0B0D 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @0AAA memory[0x00:0x20] = stack[-2] // @0AAF memory[0x20:0x40] = 0x06 // @0ADE storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @0B09 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_0B0E: // Incoming jump from 0x040A 0B0E 5B JUMPDEST 0B0F 61 PUSH2 0x0b16 0B12 61 PUSH2 0x18de 0B15 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B0F stack[0] = 0x0b16 } // Block ends with call to 0x18de, returns to 0x0B16 label_0B16: // Incoming return from call to 0x18DE at 0x0B15 // Inputs[2] // { // @0B17 stack[-2] // @0B1C stack[-1] // } 0B16 5B JUMPDEST 0B17 81 DUP2 0B18 60 PUSH1 0x11 0B1A 60 PUSH1 0x00 0B1C 83 DUP4 0B1D 60 PUSH1 0x02 0B1F 81 DUP2 0B20 11 GT 0B21 15 ISZERO 0B22 61 PUSH2 0x0b2d 0B25 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0B17 stack[0] = stack[-2] // @0B18 stack[1] = 0x11 // @0B1A stack[2] = 0x00 // @0B1C stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0b2d, if !(stack[-1] > 0x02) label_0B26: // Incoming jump from 0x0B25, if not !(stack[-1] > 0x02) 0B26 61 PUSH2 0x0b2d 0B29 61 PUSH2 0x2759 0B2C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B26 stack[0] = 0x0b2d } // Block ends with unconditional jump to 0x2759 label_0B2D: // Incoming jump from 0x0B25, if !(stack[-1] > 0x02) // Incoming jump from 0x1549, if !(stack[-1] > 0x02) // Inputs[1] { @0B30 stack[-1] } 0B2D 5B JUMPDEST 0B2E 60 PUSH1 0x02 0B30 81 DUP2 0B31 11 GT 0B32 15 ISZERO 0B33 61 PUSH2 0x0b3e 0B36 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b3e, if !(stack[-1] > 0x02) label_0B37: // Incoming jump from 0x0B36, if not !(stack[-1] > 0x02) 0B37 61 PUSH2 0x0b3e 0B3A 61 PUSH2 0x2759 0B3D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B37 stack[0] = 0x0b3e } // Block ends with unconditional jump to 0x2759 label_0B3E: // Incoming jump from 0x0B36, if !(stack[-1] > 0x02) // Inputs[6] // { // @0B3F stack[-2] // @0B40 stack[-1] // @0B45 stack[-3] // @0B4E memory[0x00:0x00 + 0x40 + stack[-2]] // @0B4F stack[-4] // @0B52 stack[-7] // } 0B3E 5B JUMPDEST 0B3F 81 DUP2 0B40 52 MSTORE 0B41 60 PUSH1 0x20 0B43 81 DUP2 0B44 01 ADD 0B45 91 SWAP2 0B46 90 SWAP1 0B47 91 SWAP2 0B48 52 MSTORE 0B49 60 PUSH1 0x40 0B4B 01 ADD 0B4C 60 PUSH1 0x00 0B4E 20 SHA3 0B4F 55 SSTORE 0B50 50 POP 0B51 50 POP 0B52 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @0B40 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @0B48 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @0B4F storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_0B53: // Incoming call from 0x16DB, returns to 0x16DC // Incoming jump from 0x043A // Inputs[1] { @0B59 stack[-1] } 0B53 5B JUMPDEST 0B54 60 PUSH1 0x00 0B56 61 PUSH2 0x0b5e 0B59 82 DUP3 0B5A 61 PUSH2 0x1a87 0B5D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B54 stack[0] = 0x00 // @0B56 stack[1] = 0x0b5e // @0B59 stack[2] = stack[-1] // } // Block ends with call to 0x1a87, returns to 0x0B5E label_0B5E: // Incoming return from call to 0x1A87 at 0x0B5D // Inputs[3] // { // @0B5F stack[-1] // @0B5F stack[-2] // @0B61 stack[-5] // } 0B5E 5B JUMPDEST 0B5F 90 SWAP1 0B60 50 POP 0B61 83 DUP4 0B62 60 PUSH1 0x01 0B64 60 PUSH1 0x01 0B66 60 PUSH1 0xa0 0B68 1B SHL 0B69 03 SUB 0B6A 16 AND 0B6B 81 DUP2 0B6C 60 PUSH1 0x01 0B6E 60 PUSH1 0x01 0B70 60 PUSH1 0xa0 0B72 1B SHL 0B73 03 SUB 0B74 16 AND 0B75 14 EQ 0B76 61 PUSH2 0x0bab 0B79 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0B5F stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0bab, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] label_0B7A: // Incoming jump from 0x0B79, if not (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @0B7C memory[0x40:0x60] // @0BA5 memory[0x40:0x60] // @0BAA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0B7A 60 PUSH1 0x40 0B7C 51 MLOAD 0B7D 7F PUSH32 0xa114810000000000000000000000000000000000000000000000000000000000 0B9E 81 DUP2 0B9F 52 MSTORE 0BA0 60 PUSH1 0x04 0BA2 01 ADD 0BA3 60 PUSH1 0x40 0BA5 51 MLOAD 0BA6 80 DUP1 0BA7 91 SWAP2 0BA8 03 SUB 0BA9 90 SWAP1 0BAA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B9F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa114810000000000000000000000000000000000000000000000000000000000 // @0BAA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0BAB: // Incoming jump from 0x0B79, if (0x01 << 0xa0) - 0x01 & stack[-1] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[5] // { // @0BAE stack[-2] // @0BB9 memory[0x00:0x40] // @0BBB storage[keccak256(memory[0x00:0x40])] // @0BBC msg.sender // @0BC8 stack[-4] // } 0BAB 5B JUMPDEST 0BAC 60 PUSH1 0x00 0BAE 82 DUP3 0BAF 81 DUP2 0BB0 52 MSTORE 0BB1 60 PUSH1 0x06 0BB3 60 PUSH1 0x20 0BB5 52 MSTORE 0BB6 60 PUSH1 0x40 0BB8 90 SWAP1 0BB9 20 SHA3 0BBA 80 DUP1 0BBB 54 SLOAD 0BBC 33 CALLER 0BBD 80 DUP1 0BBE 82 DUP3 0BBF 14 EQ 0BC0 60 PUSH1 0x01 0BC2 60 PUSH1 0x01 0BC4 60 PUSH1 0xa0 0BC6 1B SHL 0BC7 03 SUB 0BC8 88 DUP9 0BC9 16 AND 0BCA 90 SWAP1 0BCB 91 SWAP2 0BCC 14 EQ 0BCD 17 OR 0BCE 61 PUSH2 0x0c2e 0BD1 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0BB0 memory[0x00:0x20] = stack[-2] // @0BB5 memory[0x20:0x40] = 0x06 // @0BB9 stack[0] = keccak256(memory[0x00:0x40]) // @0BBB stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0c2e, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_0BD2: // Incoming jump from 0x0BD1, if not (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[5] // { // @0BDA stack[-6] // @0BEC memory[0x00:0x40] // @0BED msg.sender // @0BF4 memory[0x00:0x40] // @0BF5 storage[keccak256(memory[0x00:0x40])] // } 0BD2 60 PUSH1 0x01 0BD4 60 PUSH1 0x01 0BD6 60 PUSH1 0xa0 0BD8 1B SHL 0BD9 03 SUB 0BDA 86 DUP7 0BDB 16 AND 0BDC 60 PUSH1 0x00 0BDE 90 SWAP1 0BDF 81 DUP2 0BE0 52 MSTORE 0BE1 60 PUSH1 0x07 0BE3 60 PUSH1 0x20 0BE5 90 SWAP1 0BE6 81 DUP2 0BE7 52 MSTORE 0BE8 60 PUSH1 0x40 0BEA 80 DUP1 0BEB 83 DUP4 0BEC 20 SHA3 0BED 33 CALLER 0BEE 84 DUP5 0BEF 52 MSTORE 0BF0 90 SWAP1 0BF1 91 SWAP2 0BF2 52 MSTORE 0BF3 90 SWAP1 0BF4 20 SHA3 0BF5 54 SLOAD 0BF6 60 PUSH1 0xff 0BF8 16 AND 0BF9 61 PUSH2 0x0c2e 0BFC 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @0BE0 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0BE7 memory[0x20:0x40] = 0x07 // @0BEF memory[0x00:0x20] = msg.sender // @0BF2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0c2e, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0BFD: // Incoming jump from 0x0BFC, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @0BFF memory[0x40:0x60] // @0C28 memory[0x40:0x60] // @0C2D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BFD 60 PUSH1 0x40 0BFF 51 MLOAD 0C00 7F PUSH32 0x59c896be00000000000000000000000000000000000000000000000000000000 0C21 81 DUP2 0C22 52 MSTORE 0C23 60 PUSH1 0x04 0C25 01 ADD 0C26 60 PUSH1 0x40 0C28 51 MLOAD 0C29 80 DUP1 0C2A 91 SWAP2 0C2B 03 SUB 0C2C 90 SWAP1 0C2D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x59c896be00000000000000000000000000000000000000000000000000000000 // @0C2D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C2E: // Incoming jump from 0x0BFC, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0BD1, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[1] { @0C37 stack[-5] } 0C2E 5B JUMPDEST 0C2F 60 PUSH1 0x01 0C31 60 PUSH1 0x01 0C33 60 PUSH1 0xa0 0C35 1B SHL 0C36 03 SUB 0C37 85 DUP6 0C38 16 AND 0C39 61 PUSH2 0x0c6e 0C3C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c6e, if stack[-5] & (0x01 << 0xa0) - 0x01 label_0C3D: // Incoming jump from 0x0C3C, if not stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0C3F memory[0x40:0x60] // @0C68 memory[0x40:0x60] // @0C6D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C3D 60 PUSH1 0x40 0C3F 51 MLOAD 0C40 7F PUSH32 0xea553b3400000000000000000000000000000000000000000000000000000000 0C61 81 DUP2 0C62 52 MSTORE 0C63 60 PUSH1 0x04 0C65 01 ADD 0C66 60 PUSH1 0x40 0C68 51 MLOAD 0C69 80 DUP1 0C6A 91 SWAP2 0C6B 03 SUB 0C6C 90 SWAP1 0C6D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C62 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000 // @0C6D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C6E: // Incoming jump from 0x0C3C, if stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C6F stack[-1] } 0C6E 5B JUMPDEST 0C6F 80 DUP1 0C70 15 ISZERO 0C71 61 PUSH2 0x0c79 0C74 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c79, if !stack[-1] label_0C75: // Incoming jump from 0x0C74, if not !stack[-1] // Inputs[11] // { // @0C77 stack[-2] // @0C82 stack[-6] // @0C93 memory[0x00:0x40] // @0C95 storage[keccak256(memory[0x00:0x40])] // @0C9D stack[-5] // @0CA4 memory[0x00:0x40] // @0CA6 storage[keccak256(memory[0x00:0x40])] // @0CAC block.timestamp // @0CB9 stack[-4] // @0CC4 memory[0x00:0x40] // @0CCE stack[-3] // } 0C75 60 PUSH1 0x00 0C77 82 DUP3 0C78 55 SSTORE 0C79 5B JUMPDEST 0C7A 60 PUSH1 0x01 0C7C 60 PUSH1 0x01 0C7E 60 PUSH1 0xa0 0C80 1B SHL 0C81 03 SUB 0C82 86 DUP7 0C83 81 DUP2 0C84 16 AND 0C85 60 PUSH1 0x00 0C87 90 SWAP1 0C88 81 DUP2 0C89 52 MSTORE 0C8A 60 PUSH1 0x05 0C8C 60 PUSH1 0x20 0C8E 52 MSTORE 0C8F 60 PUSH1 0x40 0C91 80 DUP1 0C92 82 DUP3 0C93 20 SHA3 0C94 80 DUP1 0C95 54 SLOAD 0C96 60 PUSH1 0x00 0C98 19 NOT 0C99 01 ADD 0C9A 90 SWAP1 0C9B 55 SSTORE 0C9C 91 SWAP2 0C9D 87 DUP8 0C9E 16 AND 0C9F 80 DUP1 0CA0 82 DUP3 0CA1 52 MSTORE 0CA2 91 SWAP2 0CA3 90 SWAP1 0CA4 20 SHA3 0CA5 80 DUP1 0CA6 54 SLOAD 0CA7 60 PUSH1 0x01 0CA9 01 ADD 0CAA 90 SWAP1 0CAB 55 SSTORE 0CAC 42 TIMESTAMP 0CAD 60 PUSH1 0xa0 0CAF 1B SHL 0CB0 17 OR 0CB1 60 PUSH1 0x01 0CB3 60 PUSH1 0xe1 0CB5 1B SHL 0CB6 17 OR 0CB7 60 PUSH1 0x00 0CB9 85 DUP6 0CBA 81 DUP2 0CBB 52 MSTORE 0CBC 60 PUSH1 0x04 0CBE 60 PUSH1 0x20 0CC0 52 MSTORE 0CC1 60 PUSH1 0x40 0CC3 81 DUP2 0CC4 20 SHA3 0CC5 91 SWAP2 0CC6 90 SWAP1 0CC7 91 SWAP2 0CC8 55 SSTORE 0CC9 60 PUSH1 0x01 0CCB 60 PUSH1 0xe1 0CCD 1B SHL 0CCE 84 DUP5 0CCF 16 AND 0CD0 90 SWAP1 0CD1 03 SUB 0CD2 61 PUSH2 0x0d0b 0CD5 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0C78 storage[stack[-2]] = 0x00 // @0C89 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @0C8E memory[0x20:0x40] = 0x05 // @0C9B storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @0CA1 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0CAB storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @0CBB memory[0x00:0x20] = stack[-4] // @0CC0 memory[0x20:0x40] = 0x04 // @0CC8 storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe1) | (block.timestamp << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x0d0b, if 0x00 - (stack[-3] & (0x01 << 0xe1)) label_0CD6: // Incoming jump from 0x0CD5, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x0CD5, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[3] // { // @0CD8 stack[-4] // @0CE7 memory[0x00:0x40] // @0CE8 storage[keccak256(memory[0x00:0x40])] // } 0CD6 60 PUSH1 0x01 0CD8 84 DUP5 0CD9 01 ADD 0CDA 60 PUSH1 0x00 0CDC 81 DUP2 0CDD 81 DUP2 0CDE 52 MSTORE 0CDF 60 PUSH1 0x04 0CE1 60 PUSH1 0x20 0CE3 52 MSTORE 0CE4 60 PUSH1 0x40 0CE6 81 DUP2 0CE7 20 SHA3 0CE8 54 SLOAD 0CE9 90 SWAP1 0CEA 03 SUB 0CEB 61 PUSH2 0x0d09 0CEE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0CD9 stack[0] = stack[-4] + 0x01 // @0CDE memory[0x00:0x20] = stack[-4] + 0x01 // @0CE3 memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x0d09, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_0CEF: // Incoming jump from 0x0CEE, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @0CF1 storage[0x00] // @0CF2 stack[-1] // } 0CEF 60 PUSH1 0x00 0CF1 54 SLOAD 0CF2 81 DUP2 0CF3 14 EQ 0CF4 61 PUSH2 0x0d09 0CF7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d09, if stack[-1] == storage[0x00] label_0CF8: // Incoming jump from 0x0CF7, if not stack[-1] == storage[0x00] // Inputs[3] // { // @0CFA stack[-1] // @0D05 memory[0x00:0x40] // @0D06 stack[-4] // } 0CF8 60 PUSH1 0x00 0CFA 81 DUP2 0CFB 81 DUP2 0CFC 52 MSTORE 0CFD 60 PUSH1 0x04 0CFF 60 PUSH1 0x20 0D01 52 MSTORE 0D02 60 PUSH1 0x40 0D04 90 SWAP1 0D05 20 SHA3 0D06 84 DUP5 0D07 90 SWAP1 0D08 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @0CFC memory[0x00:0x20] = stack[-1] // @0D01 memory[0x20:0x40] = 0x04 // @0D08 storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_0D09: // Incoming jump from 0x0CEE, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x0D08 // Incoming jump from 0x0CF7, if stack[-1] == storage[0x00] 0D09 5B JUMPDEST 0D0A 50 POP // Stack delta = -1 // Block continues label_0D0B: // Incoming jump from 0x0CD5, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x0CD5, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x0D0A // Inputs[7] // { // @0D0C stack[-4] // @0D0D stack[-5] // @0D17 stack[-6] // @0D44 memory[0x40:0x60] // @0D47 memory[0x40:0x60] // @0D4C memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0D54 stack[-7] // } 0D0B 5B JUMPDEST 0D0C 83 DUP4 0D0D 85 DUP6 0D0E 60 PUSH1 0x01 0D10 60 PUSH1 0x01 0D12 60 PUSH1 0xa0 0D14 1B SHL 0D15 03 SUB 0D16 16 AND 0D17 87 DUP8 0D18 60 PUSH1 0x01 0D1A 60 PUSH1 0x01 0D1C 60 PUSH1 0xa0 0D1E 1B SHL 0D1F 03 SUB 0D20 16 AND 0D21 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 0D42 60 PUSH1 0x40 0D44 51 MLOAD 0D45 60 PUSH1 0x40 0D47 51 MLOAD 0D48 80 DUP1 0D49 91 SWAP2 0D4A 03 SUB 0D4B 90 SWAP1 0D4C A4 LOG4 0D4D 5B JUMPDEST 0D4E 50 POP 0D4F 50 POP 0D50 50 POP 0D51 50 POP 0D52 50 POP 0D53 50 POP 0D54 56 *JUMP // Stack delta = -7 // Outputs[1] { @0D4C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_0D55: // Incoming jump from 0x045A 0D55 5B JUMPDEST 0D56 61 PUSH2 0x0d5d 0D59 61 PUSH2 0x18de 0D5C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D56 stack[0] = 0x0d5d } // Block ends with call to 0x18de, returns to 0x0D5D label_0D5D: // Incoming return from call to 0x18DE at 0x0D5C // Inputs[3] // { // @0D61 storage[0x0f] // @0D66 stack[-1] // @0D6F stack[-2] // } 0D5D 5B JUMPDEST 0D5E 60 PUSH1 0x0f 0D60 80 DUP1 0D61 54 SLOAD 0D62 60 PUSH1 0xff 0D64 19 NOT 0D65 16 AND 0D66 91 SWAP2 0D67 15 ISZERO 0D68 15 ISZERO 0D69 91 SWAP2 0D6A 90 SWAP1 0D6B 91 SWAP2 0D6C 17 OR 0D6D 90 SWAP1 0D6E 55 SSTORE 0D6F 56 *JUMP // Stack delta = -2 // Outputs[1] { @0D6E storage[0x0f] = !!stack[-1] | (~0xff & storage[0x0f]) } // Block ends with unconditional jump to stack[-2] label_0D70: // Incoming jump from 0x047A // Inputs[4] // { // @0D73 stack[-2] // @0D81 memory[0x00:0x40] // @0D83 memory[0x40:0x60] // @0D8A storage[keccak256(memory[0x00:0x40])] // } 0D70 5B JUMPDEST 0D71 60 PUSH1 0x00 0D73 82 DUP3 0D74 81 DUP2 0D75 52 MSTORE 0D76 60 PUSH1 0x09 0D78 60 PUSH1 0x20 0D7A 90 SWAP1 0D7B 81 DUP2 0D7C 52 MSTORE 0D7D 60 PUSH1 0x40 0D7F 80 DUP1 0D80 83 DUP4 0D81 20 SHA3 0D82 81 DUP2 0D83 51 MLOAD 0D84 80 DUP1 0D85 83 DUP4 0D86 01 ADD 0D87 90 SWAP1 0D88 92 SWAP3 0D89 52 MSTORE 0D8A 54 SLOAD 0D8B 60 PUSH1 0x01 0D8D 60 PUSH1 0x01 0D8F 60 PUSH1 0xa0 0D91 1B SHL 0D92 03 SUB 0D93 81 DUP2 0D94 16 AND 0D95 80 DUP1 0D96 83 DUP4 0D97 52 MSTORE 0D98 60 PUSH1 0x01 0D9A 60 PUSH1 0xa0 0D9C 1B SHL 0D9D 90 SWAP1 0D9E 91 SWAP2 0D9F 04 DIV 0DA0 6B PUSH12 0xffffffffffffffffffffffff 0DAD 16 AND 0DAE 92 SWAP3 0DAF 82 DUP3 0DB0 01 ADD 0DB1 92 SWAP3 0DB2 90 SWAP1 0DB3 92 SWAP3 0DB4 52 MSTORE 0DB5 82 DUP3 0DB6 91 SWAP2 0DB7 61 PUSH2 0x0def 0DBA 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @0D71 stack[0] = 0x00 // @0D75 memory[0x00:0x20] = stack[-2] // @0D7C memory[0x20:0x40] = 0x09 // @0D88 stack[2] = memory[0x40:0x60] // @0D89 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0D97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0DB4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0DB6 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0def, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_0DBB: // Incoming jump from 0x0DBA, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0DBF memory[0x40:0x60] // @0DC8 storage[0x08] // @0DF4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0E0E stack[-4] // } 0DBB 50 POP 0DBC 60 PUSH1 0x40 0DBE 80 DUP1 0DBF 51 MLOAD 0DC0 80 DUP1 0DC1 82 DUP3 0DC2 01 ADD 0DC3 90 SWAP1 0DC4 91 SWAP2 0DC5 52 MSTORE 0DC6 60 PUSH1 0x08 0DC8 54 SLOAD 0DC9 60 PUSH1 0x01 0DCB 60 PUSH1 0x01 0DCD 60 PUSH1 0xa0 0DCF 1B SHL 0DD0 03 SUB 0DD1 81 DUP2 0DD2 16 AND 0DD3 82 DUP3 0DD4 52 MSTORE 0DD5 60 PUSH1 0x01 0DD7 60 PUSH1 0xa0 0DD9 1B SHL 0DDA 90 SWAP1 0DDB 04 DIV 0DDC 6B PUSH12 0xffffffffffffffffffffffff 0DE9 16 AND 0DEA 60 PUSH1 0x20 0DEC 82 DUP3 0DED 01 ADD 0DEE 52 MSTORE 0DEF 5B JUMPDEST 0DF0 60 PUSH1 0x20 0DF2 81 DUP2 0DF3 01 ADD 0DF4 51 MLOAD 0DF5 60 PUSH1 0x00 0DF7 90 SWAP1 0DF8 61 PUSH2 0x2710 0DFB 90 SWAP1 0DFC 61 PUSH2 0x0e13 0DFF 90 SWAP1 0E00 6B PUSH12 0xffffffffffffffffffffffff 0E0D 16 AND 0E0E 87 DUP8 0E0F 61 PUSH2 0x2785 0E12 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0DC4 stack[-1] = memory[0x40:0x60] // @0DC5 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0DD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x08] & (0x01 << 0xa0) - 0x01 // @0DEE memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffff & storage[0x08] / (0x01 << 0xa0) // @0DF7 stack[0] = 0x00 // @0DFB stack[1] = 0x2710 // @0DFF stack[2] = 0x0e13 // @0E0D stack[3] = 0xffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0E0E stack[4] = stack[-4] // } // Block ends with call to 0x2785, returns to 0x0E13 label_0E13: // Incoming return from call to 0x2785 at 0x0E12 // Incoming return from call to 0x2785 at 0x0E12 // Inputs[2] // { // @0E17 stack[-2] // @0E18 stack[-1] // } 0E13 5B JUMPDEST 0E14 61 PUSH2 0x0e1d 0E17 91 SWAP2 0E18 90 SWAP1 0E19 61 PUSH2 0x279c 0E1C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E17 stack[-2] = 0x0e1d // @0E18 stack[-1] = stack[-2] // @0E18 stack[0] = stack[-1] // } // Block ends with call to 0x279c, returns to 0x0E1D label_0E1D: // Incoming return from call to 0x279C at 0x0E1C // Inputs[7] // { // @0E1E stack[-3] // @0E1E stack[-1] // @0E1F memory[stack[-3]:stack[-3] + 0x20] // @0E20 stack[-8] // @0E22 stack[-7] // @0E24 stack[-2] // @0E25 stack[-6] // } 0E1D 5B JUMPDEST 0E1E 91 SWAP2 0E1F 51 MLOAD 0E20 96 SWAP7 0E21 91 SWAP2 0E22 95 SWAP6 0E23 50 POP 0E24 90 SWAP1 0E25 93 SWAP4 0E26 50 POP 0E27 50 POP 0E28 50 POP 0E29 50 POP 0E2A 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0E20 stack[-8] = memory[stack[-3]:stack[-3] + 0x20] // @0E22 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_0E2B: // Incoming jump from 0x04AC 0E2B 5B JUMPDEST 0E2C 61 PUSH2 0x0e33 0E2F 61 PUSH2 0x1b16 0E32 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E2C stack[0] = 0x0e33 } // Block ends with call to 0x1b16, returns to 0x0E33 label_0E33: // Incoming return from call to 0x1B16 at 0x0E32 // Inputs[1] { @0E36 storage[0x0f] } 0E33 5B JUMPDEST 0E34 60 PUSH1 0x0f 0E36 54 SLOAD 0E37 60 PUSH1 0xff 0E39 16 AND 0E3A 15 ISZERO 0E3B 15 ISZERO 0E3C 60 PUSH1 0x01 0E3E 14 EQ 0E3F 61 PUSH2 0x0e8f 0E42 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e8f, if 0x01 == !!(0xff & storage[0x0f]) label_0E43: // Incoming jump from 0x0E42, if not 0x01 == !!(0xff & storage[0x0f]) // Inputs[1] { @0E45 memory[0x40:0x60] } 0E43 60 PUSH1 0x40 0E45 51 MLOAD 0E46 62 PUSH3 0x461bcd 0E4A 60 PUSH1 0xe5 0E4C 1B SHL 0E4D 81 DUP2 0E4E 52 MSTORE 0E4F 60 PUSH1 0x20 0E51 60 PUSH1 0x04 0E53 82 DUP3 0E54 01 ADD 0E55 52 MSTORE 0E56 60 PUSH1 0x10 0E58 60 PUSH1 0x24 0E5A 82 DUP3 0E5B 01 ADD 0E5C 52 MSTORE 0E5D 7F PUSH32 0x4d696e7461626c653a2070617573656400000000000000000000000000000000 0E7E 60 PUSH1 0x44 0E80 82 DUP3 0E81 01 ADD 0E82 52 MSTORE 0E83 60 PUSH1 0x64 0E85 01 ADD // Stack delta = +1 // Outputs[5] // { // @0E4E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E55 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E5C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0E82 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d696e7461626c653a2070617573656400000000000000000000000000000000 // @0E85 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0E86: // Incoming jump from 0x1C78 // Incoming jump from 0x1153 // Incoming jump from 0x11F1 // Incoming jump from 0x0EDD // Incoming jump from 0x141F // Incoming jump from 0x1C28 // Incoming jump from 0x1E0F // Incoming jump from 0x1A13 // Incoming jump from 0x1B6F // Incoming jump from 0x1937 // Incoming jump from 0x10F9 // Incoming jump from 0x0E85 // Incoming jump from 0x1ED8 // Incoming jump from 0x1380 // Incoming jump from 0x1BBF // Incoming jump from 0x1282 // Incoming jump from 0x19BD // Incoming jump from 0x1806 // Incoming jump from 0x21FD // Incoming jump from 0x0FF4 // Incoming jump from 0x0F2F // Incoming jump from 0x10AA // Incoming jump from 0x0FA3 // Inputs[3] // { // @0E89 memory[0x40:0x60] // @0E8B stack[-1] // @0E8E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0E86 5B JUMPDEST 0E87 60 PUSH1 0x40 0E89 51 MLOAD 0E8A 80 DUP1 0E8B 91 SWAP2 0E8C 03 SUB 0E8D 90 SWAP1 0E8E FD *REVERT // Stack delta = -1 // Outputs[1] { @0E8E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0E8F: // Incoming jump from 0x0E42, if 0x01 == !!(0xff & storage[0x0f]) // Inputs[2] // { // @0E90 tx.origin // @0E91 msg.sender // } 0E8F 5B JUMPDEST 0E90 32 ORIGIN 0E91 33 CALLER 0E92 14 EQ 0E93 61 PUSH2 0x0ede 0E96 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ede, if msg.sender == tx.origin label_0E97: // Incoming jump from 0x0E96, if not msg.sender == tx.origin // Inputs[1] { @0E99 memory[0x40:0x60] } 0E97 60 PUSH1 0x40 0E99 51 MLOAD 0E9A 62 PUSH3 0x461bcd 0E9E 60 PUSH1 0xe5 0EA0 1B SHL 0EA1 81 DUP2 0EA2 52 MSTORE 0EA3 60 PUSH1 0x20 0EA5 60 PUSH1 0x04 0EA7 82 DUP3 0EA8 01 ADD 0EA9 52 MSTORE 0EAA 60 PUSH1 0x1e 0EAC 60 PUSH1 0x24 0EAE 82 DUP3 0EAF 01 ADD 0EB0 52 MSTORE 0EB1 7F PUSH32 0x5468652063616c6c657220697320616e6f7468657220636f6e74726163740000 0ED2 60 PUSH1 0x44 0ED4 82 DUP3 0ED5 01 ADD 0ED6 52 MSTORE 0ED7 60 PUSH1 0x64 0ED9 01 ADD 0EDA 61 PUSH2 0x0e86 0EDD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EA9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EB0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0ED6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468652063616c6c657220697320616e6f7468657220636f6e74726163740000 // @0ED9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_0EDE: // Incoming jump from 0x0E96, if msg.sender == tx.origin // Inputs[1] { @0EE3 storage[0x0a] } 0EDE 5B JUMPDEST 0EDF 60 PUSH1 0x02 0EE1 60 PUSH1 0x0a 0EE3 54 SLOAD 0EE4 03 SUB 0EE5 61 PUSH2 0x0f30 0EE8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f30, if storage[0x0a] - 0x02 label_0EE9: // Incoming jump from 0x0EE8, if not storage[0x0a] - 0x02 // Inputs[1] { @0EEB memory[0x40:0x60] } 0EE9 60 PUSH1 0x40 0EEB 51 MLOAD 0EEC 62 PUSH3 0x461bcd 0EF0 60 PUSH1 0xe5 0EF2 1B SHL 0EF3 81 DUP2 0EF4 52 MSTORE 0EF5 60 PUSH1 0x20 0EF7 60 PUSH1 0x04 0EF9 82 DUP3 0EFA 01 ADD 0EFB 52 MSTORE 0EFC 60 PUSH1 0x1f 0EFE 60 PUSH1 0x24 0F00 82 DUP3 0F01 01 ADD 0F02 52 MSTORE 0F03 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 0F24 60 PUSH1 0x44 0F26 82 DUP3 0F27 01 ADD 0F28 52 MSTORE 0F29 60 PUSH1 0x64 0F2B 01 ADD 0F2C 61 PUSH2 0x0e86 0F2F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EFB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F02 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0F28 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @0F2B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_0F30: // Incoming jump from 0x0EE8, if storage[0x0a] - 0x02 // Inputs[2] // { // @0F38 storage[0x0e] // @0F40 stack[-1] // } 0F30 5B JUMPDEST 0F31 60 PUSH1 0x02 0F33 60 PUSH1 0x0a 0F35 55 SSTORE 0F36 60 PUSH1 0x0e 0F38 54 SLOAD 0F39 60 PUSH1 0x00 0F3B 90 SWAP1 0F3C 61 PUSH2 0x0f46 0F3F 90 SWAP1 0F40 83 DUP4 0F41 90 SWAP1 0F42 61 PUSH2 0x2785 0F45 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0F35 storage[0x0a] = 0x02 // @0F3B stack[0] = 0x00 // @0F3F stack[1] = 0x0f46 // @0F41 stack[2] = stack[-1] // @0F41 stack[3] = storage[0x0e] // } // Block ends with call to 0x2785, returns to 0x0F46 label_0F46: // Incoming return from call to 0x2785 at 0x0F45 // Inputs[3] // { // @0F47 stack[-2] // @0F47 stack[-1] // @0F4C stack[-3] // } 0F46 5B JUMPDEST 0F47 90 SWAP1 0F48 50 POP 0F49 61 PUSH2 0x0f52 0F4C 82 DUP3 0F4D 82 DUP3 0F4E 61 PUSH2 0x1b70 0F51 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0F47 stack[-2] = stack[-1] // @0F49 stack[-1] = 0x0f52 // @0F4C stack[0] = stack[-3] // @0F4D stack[1] = stack[-1] // } // Block ends with call to 0x1b70, returns to 0x0F52 label_0F52: // Incoming return from call to 0x1B70 at 0x0F51 // Inputs[1] { @0F55 storage[0x0d] } 0F52 5B JUMPDEST 0F53 60 PUSH1 0x0d 0F55 54 SLOAD 0F56 60 PUSH1 0xff 0F58 16 AND 0F59 61 PUSH2 0x0fa4 0F5C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fa4, if 0xff & storage[0x0d] label_0F5D: // Incoming jump from 0x0F5C, if not 0xff & storage[0x0d] // Inputs[1] { @0F5F memory[0x40:0x60] } 0F5D 60 PUSH1 0x40 0F5F 51 MLOAD 0F60 62 PUSH3 0x461bcd 0F64 60 PUSH1 0xe5 0F66 1B SHL 0F67 81 DUP2 0F68 52 MSTORE 0F69 60 PUSH1 0x20 0F6B 60 PUSH1 0x04 0F6D 82 DUP3 0F6E 01 ADD 0F6F 52 MSTORE 0F70 60 PUSH1 0x1a 0F72 60 PUSH1 0x24 0F74 82 DUP3 0F75 01 ADD 0F76 52 MSTORE 0F77 7F PUSH32 0x5075626c69632053616c65206973206e6f74204163746976652e000000000000 0F98 60 PUSH1 0x44 0F9A 82 DUP3 0F9B 01 ADD 0F9C 52 MSTORE 0F9D 60 PUSH1 0x64 0F9F 01 ADD 0FA0 61 PUSH2 0x0e86 0FA3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F68 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F6F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F76 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @0F9C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5075626c69632053616c65206973206e6f74204163746976652e000000000000 // @0F9F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_0FA4: // Incoming jump from 0x0F5C, if 0xff & storage[0x0d] // Inputs[1] { @0FA7 stack[-2] } 0FA4 5B JUMPDEST 0FA5 60 PUSH1 0x0a 0FA7 82 DUP3 0FA8 11 GT 0FA9 15 ISZERO 0FAA 61 PUSH2 0x0ff5 0FAD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ff5, if !(stack[-2] > 0x0a) label_0FAE: // Incoming jump from 0x0FAD, if not !(stack[-2] > 0x0a) // Inputs[1] { @0FB0 memory[0x40:0x60] } 0FAE 60 PUSH1 0x40 0FB0 51 MLOAD 0FB1 62 PUSH3 0x461bcd 0FB5 60 PUSH1 0xe5 0FB7 1B SHL 0FB8 81 DUP2 0FB9 52 MSTORE 0FBA 60 PUSH1 0x20 0FBC 60 PUSH1 0x04 0FBE 82 DUP3 0FBF 01 ADD 0FC0 52 MSTORE 0FC1 60 PUSH1 0x10 0FC3 60 PUSH1 0x24 0FC5 82 DUP3 0FC6 01 ADD 0FC7 52 MSTORE 0FC8 7F PUSH32 0x4d696e7420616d6f756e74206f76657200000000000000000000000000000000 0FE9 60 PUSH1 0x44 0FEB 82 DUP3 0FEC 01 ADD 0FED 52 MSTORE 0FEE 60 PUSH1 0x64 0FF0 01 ADD 0FF1 61 PUSH2 0x0e86 0FF4 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0FB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FC0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0FC7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @0FED memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d696e7420616d6f756e74206f76657200000000000000000000000000000000 // @0FF0 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_0FF5: // Incoming jump from 0x0FAD, if !(stack[-2] > 0x0a) // Inputs[2] // { // @0FF9 msg.sender // @0FFA stack[-2] // } 0FF5 5B JUMPDEST 0FF6 61 PUSH2 0x0fff 0FF9 33 CALLER 0FFA 83 DUP4 0FFB 61 PUSH2 0x1c79 0FFE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FF6 stack[0] = 0x0fff // @0FF9 stack[1] = msg.sender // @0FFA stack[2] = stack[-2] // } // Block ends with call to 0x1c79, returns to 0x0FFF label_0FFF: // Incoming return from call to 0x1C79 at 0x0FFE // Inputs[1] { @1007 stack[-3] } 0FFF 5B JUMPDEST 1000 50 POP 1001 50 POP 1002 60 PUSH1 0x01 1004 60 PUSH1 0x0a 1006 55 SSTORE 1007 56 *JUMP // Stack delta = -3 // Outputs[1] { @1006 storage[0x0a] = 0x01 } // Block ends with unconditional jump to stack[-3] label_1008: // Incoming jump from 0x04CC 1008 5B JUMPDEST 1009 61 PUSH2 0x1010 100C 61 PUSH2 0x18de 100F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1009 stack[0] = 0x1010 } // Block ends with call to 0x18de, returns to 0x1010 label_1010: // Incoming return from call to 0x18DE at 0x100F // Inputs[3] // { // @1014 storage[0x10] // @1031 stack[-1] // @103B storage[0x0f] // } 1010 5B JUMPDEST 1011 60 PUSH1 0x10 1013 80 DUP1 1014 54 SLOAD 1015 6B PUSH12 0xffffffffffffffffffffffff 1022 19 NOT 1023 16 AND 1024 6B PUSH12 0xffffffffffffffffffffffff 1031 83 DUP4 1032 16 AND 1033 90 SWAP1 1034 81 DUP2 1035 17 OR 1036 90 SWAP1 1037 91 SWAP2 1038 55 SSTORE 1039 60 PUSH1 0x0f 103B 54 SLOAD 103C 61 PUSH2 0x0939 103F 91 SWAP2 1040 61 PUSH2 0x0100 1043 90 SWAP1 1044 91 SWAP2 1045 04 DIV 1046 60 PUSH1 0x01 1048 60 PUSH1 0x01 104A 60 PUSH1 0xa0 104C 1B SHL 104D 03 SUB 104E 16 AND 104F 90 SWAP1 1050 61 PUSH2 0x1938 1053 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1038 storage[0x10] = (stack[-1] & 0xffffffffffffffffffffffff) | (~0xffffffffffffffffffffffff & storage[0x10]) // @103F stack[0] = 0x0939 // @104F stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x0f] / 0x0100 // @104F stack[2] = stack[-1] & 0xffffffffffffffffffffffff // } // Block ends with call to 0x1938, returns to 0x0939 label_1054: // Incoming jump from 0x050F // Inputs[1] { @1057 storage[0x0f] } 1054 5B JUMPDEST 1055 60 PUSH1 0x0f 1057 54 SLOAD 1058 60 PUSH1 0xff 105A 16 AND 105B 15 ISZERO 105C 15 ISZERO 105D 60 PUSH1 0x01 105F 14 EQ 1060 61 PUSH2 0x10ab 1063 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10ab, if 0x01 == !!(0xff & storage[0x0f]) label_1064: // Incoming jump from 0x1063, if not 0x01 == !!(0xff & storage[0x0f]) // Inputs[1] { @1066 memory[0x40:0x60] } 1064 60 PUSH1 0x40 1066 51 MLOAD 1067 62 PUSH3 0x461bcd 106B 60 PUSH1 0xe5 106D 1B SHL 106E 81 DUP2 106F 52 MSTORE 1070 60 PUSH1 0x20 1072 60 PUSH1 0x04 1074 82 DUP3 1075 01 ADD 1076 52 MSTORE 1077 60 PUSH1 0x10 1079 60 PUSH1 0x24 107B 82 DUP3 107C 01 ADD 107D 52 MSTORE 107E 7F PUSH32 0x4d696e7461626c653a2070617573656400000000000000000000000000000000 109F 60 PUSH1 0x44 10A1 82 DUP3 10A2 01 ADD 10A3 52 MSTORE 10A4 60 PUSH1 0x64 10A6 01 ADD 10A7 61 PUSH2 0x0e86 10AA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @106F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1076 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @107D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @10A3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d696e7461626c653a2070617573656400000000000000000000000000000000 // @10A6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_10AB: // Incoming jump from 0x1063, if 0x01 == !!(0xff & storage[0x0f]) // Inputs[2] // { // @10AC tx.origin // @10AD msg.sender // } 10AB 5B JUMPDEST 10AC 32 ORIGIN 10AD 33 CALLER 10AE 14 EQ 10AF 61 PUSH2 0x10fa 10B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10fa, if msg.sender == tx.origin label_10B3: // Incoming jump from 0x10B2, if not msg.sender == tx.origin // Inputs[1] { @10B5 memory[0x40:0x60] } 10B3 60 PUSH1 0x40 10B5 51 MLOAD 10B6 62 PUSH3 0x461bcd 10BA 60 PUSH1 0xe5 10BC 1B SHL 10BD 81 DUP2 10BE 52 MSTORE 10BF 60 PUSH1 0x20 10C1 60 PUSH1 0x04 10C3 82 DUP3 10C4 01 ADD 10C5 52 MSTORE 10C6 60 PUSH1 0x1e 10C8 60 PUSH1 0x24 10CA 82 DUP3 10CB 01 ADD 10CC 52 MSTORE 10CD 7F PUSH32 0x5468652063616c6c657220697320616e6f7468657220636f6e74726163740000 10EE 60 PUSH1 0x44 10F0 82 DUP3 10F1 01 ADD 10F2 52 MSTORE 10F3 60 PUSH1 0x64 10F5 01 ADD 10F6 61 PUSH2 0x0e86 10F9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @10BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10C5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10CC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @10F2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468652063616c6c657220697320616e6f7468657220636f6e74726163740000 // @10F5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_10FA: // Incoming jump from 0x10B2, if msg.sender == tx.origin 10FA 5B JUMPDEST 10FB 61 PUSH2 0x1102 10FE 61 PUSH2 0x1b16 1101 56 *JUMP // Stack delta = +1 // Outputs[1] { @10FB stack[0] = 0x1102 } // Block ends with call to 0x1b16, returns to 0x1102 label_1102: // Incoming return from call to 0x1B16 at 0x1101 // Inputs[1] { @1107 storage[0x0a] } 1102 5B JUMPDEST 1103 60 PUSH1 0x02 1105 60 PUSH1 0x0a 1107 54 SLOAD 1108 03 SUB 1109 61 PUSH2 0x1154 110C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1154, if storage[0x0a] - 0x02 label_110D: // Incoming jump from 0x110C, if not storage[0x0a] - 0x02 // Inputs[1] { @110F memory[0x40:0x60] } 110D 60 PUSH1 0x40 110F 51 MLOAD 1110 62 PUSH3 0x461bcd 1114 60 PUSH1 0xe5 1116 1B SHL 1117 81 DUP2 1118 52 MSTORE 1119 60 PUSH1 0x20 111B 60 PUSH1 0x04 111D 82 DUP3 111E 01 ADD 111F 52 MSTORE 1120 60 PUSH1 0x1f 1122 60 PUSH1 0x24 1124 82 DUP3 1125 01 ADD 1126 52 MSTORE 1127 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 1148 60 PUSH1 0x44 114A 82 DUP3 114B 01 ADD 114C 52 MSTORE 114D 60 PUSH1 0x64 114F 01 ADD 1150 61 PUSH2 0x0e86 1153 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1118 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @111F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1126 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @114C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @114F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1154: // Incoming jump from 0x110C, if storage[0x0a] - 0x02 // Inputs[2] // { // @115F stack[-5] // @1164 stack[-1] // } 1154 5B JUMPDEST 1155 60 PUSH1 0x02 1157 60 PUSH1 0x0a 1159 81 DUP2 115A 90 SWAP1 115B 55 SSTORE 115C 50 POP 115D 60 PUSH1 0x00 115F 85 DUP6 1160 60 PUSH1 0x11 1162 60 PUSH1 0x00 1164 84 DUP5 1165 60 PUSH1 0x02 1167 81 DUP2 1168 11 GT 1169 15 ISZERO 116A 61 PUSH2 0x1175 116D 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @115B storage[0x0a] = 0x02 // @115D stack[0] = 0x00 // @115F stack[1] = stack[-5] // @1160 stack[2] = 0x11 // @1162 stack[3] = 0x00 // @1164 stack[4] = stack[-1] // } // Block ends with conditional jump to 0x1175, if !(stack[-1] > 0x02) label_116E: // Incoming jump from 0x116D, if not !(stack[-1] > 0x02) 116E 61 PUSH2 0x1175 1171 61 PUSH2 0x2759 1174 56 *JUMP // Stack delta = +1 // Outputs[1] { @116E stack[0] = 0x1175 } // Block ends with unconditional jump to 0x2759 label_1175: // Incoming jump from 0x116D, if !(stack[-1] > 0x02) // Inputs[1] { @1178 stack[-1] } 1175 5B JUMPDEST 1176 60 PUSH1 0x02 1178 81 DUP2 1179 11 GT 117A 15 ISZERO 117B 61 PUSH2 0x1186 117E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1186, if !(stack[-1] > 0x02) label_117F: // Incoming jump from 0x117E, if not !(stack[-1] > 0x02) 117F 61 PUSH2 0x1186 1182 61 PUSH2 0x2759 1185 56 *JUMP // Stack delta = +1 // Outputs[1] { @117F stack[0] = 0x1186 } // Block ends with unconditional jump to 0x2759 label_1186: // Incoming jump from 0x117E, if !(stack[-1] > 0x02) // Inputs[6] // { // @1187 stack[-2] // @1188 stack[-1] // @118C stack[-3] // @1194 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @1195 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @1199 stack[-4] // } 1186 5B JUMPDEST 1187 81 DUP2 1188 52 MSTORE 1189 60 PUSH1 0x20 118B 01 ADD 118C 90 SWAP1 118D 81 DUP2 118E 52 MSTORE 118F 60 PUSH1 0x20 1191 01 ADD 1192 60 PUSH1 0x00 1194 20 SHA3 1195 54 SLOAD 1196 61 PUSH2 0x119f 1199 91 SWAP2 119A 90 SWAP1 119B 61 PUSH2 0x2785 119E 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1188 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @118E memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @1199 stack[-4] = 0x119f // @119A stack[-2] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @119A stack[-3] = stack[-4] // } // Block ends with call to 0x2785, returns to 0x119F label_119F: // Incoming return from call to 0x2785 at 0x119E // Inputs[3] // { // @11A0 stack[-2] // @11A0 stack[-1] // @11A4 stack[-6] // } 119F 5B JUMPDEST 11A0 90 SWAP1 11A1 50 POP 11A2 60 PUSH1 0x0a 11A4 85 DUP6 11A5 11 GT 11A6 15 ISZERO 11A7 61 PUSH2 0x11f2 11AA 57 *JUMPI // Stack delta = -1 // Outputs[1] { @11A0 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x11f2, if !(stack[-6] > 0x0a) label_11AB: // Incoming jump from 0x11AA, if not !(stack[-6] > 0x0a) // Inputs[1] { @11AD memory[0x40:0x60] } 11AB 60 PUSH1 0x40 11AD 51 MLOAD 11AE 62 PUSH3 0x461bcd 11B2 60 PUSH1 0xe5 11B4 1B SHL 11B5 81 DUP2 11B6 52 MSTORE 11B7 60 PUSH1 0x20 11B9 60 PUSH1 0x04 11BB 82 DUP3 11BC 01 ADD 11BD 52 MSTORE 11BE 60 PUSH1 0x1a 11C0 60 PUSH1 0x24 11C2 82 DUP3 11C3 01 ADD 11C4 52 MSTORE 11C5 7F PUSH32 0x70726573616c65206d61782063616e206e6f7420657863656564000000000000 11E6 60 PUSH1 0x44 11E8 82 DUP3 11E9 01 ADD 11EA 52 MSTORE 11EB 60 PUSH1 0x64 11ED 01 ADD 11EE 61 PUSH2 0x0e86 11F1 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11BD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11C4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @11EA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x70726573616c65206d61782063616e206e6f7420657863656564000000000000 // @11ED stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_11F2: // Incoming jump from 0x11AA, if !(stack[-6] > 0x0a) // Inputs[2] // { // @11F6 stack[-6] // @11F7 stack[-1] // } 11F2 5B JUMPDEST 11F3 61 PUSH2 0x11fc 11F6 86 DUP7 11F7 82 DUP3 11F8 61 PUSH2 0x1b70 11FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @11F3 stack[0] = 0x11fc // @11F6 stack[1] = stack[-6] // @11F7 stack[2] = stack[-1] // } // Block ends with call to 0x1b70, returns to 0x11FC label_11FC: // Incoming return from call to 0x1B70 at 0x11FB // Inputs[1] { @1201 stack[-2] } 11FC 5B JUMPDEST 11FD 60 PUSH1 0x12 11FF 60 PUSH1 0x00 1201 83 DUP4 1202 60 PUSH1 0x02 1204 81 DUP2 1205 11 GT 1206 15 ISZERO 1207 61 PUSH2 0x1212 120A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @11FD stack[0] = 0x12 // @11FF stack[1] = 0x00 // @1201 stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1212, if !(stack[-2] > 0x02) label_120B: // Incoming jump from 0x120A, if not !(stack[-2] > 0x02) 120B 61 PUSH2 0x1212 120E 61 PUSH2 0x2759 1211 56 *JUMP // Stack delta = +1 // Outputs[1] { @120B stack[0] = 0x1212 } // Block ends with unconditional jump to 0x2759 label_1212: // Incoming jump from 0x120A, if !(stack[-2] > 0x02) // Inputs[1] { @1215 stack[-1] } 1212 5B JUMPDEST 1213 60 PUSH1 0x02 1215 81 DUP2 1216 11 GT 1217 15 ISZERO 1218 61 PUSH2 0x1223 121B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1223, if !(stack[-1] > 0x02) label_121C: // Incoming jump from 0x121B, if not !(stack[-1] > 0x02) 121C 61 PUSH2 0x1223 121F 61 PUSH2 0x2759 1222 56 *JUMP // Stack delta = +1 // Outputs[1] { @121C stack[0] = 0x1223 } // Block ends with unconditional jump to 0x2759 label_1223: // Incoming jump from 0x121B, if !(stack[-1] > 0x02) // Inputs[5] // { // @1224 stack[-2] // @1225 stack[-1] // @122A stack[-3] // @1233 memory[0x00:0x00 + 0x40 + stack[-2]] // @1234 storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] // } 1223 5B JUMPDEST 1224 81 DUP2 1225 52 MSTORE 1226 60 PUSH1 0x20 1228 81 DUP2 1229 01 ADD 122A 91 SWAP2 122B 90 SWAP1 122C 91 SWAP2 122D 52 MSTORE 122E 60 PUSH1 0x40 1230 01 ADD 1231 60 PUSH1 0x00 1233 20 SHA3 1234 54 SLOAD 1235 60 PUSH1 0xff 1237 16 AND 1238 61 PUSH2 0x1283 123B 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @1225 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @122D memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // } // Block ends with conditional jump to 0x1283, if 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] label_123C: // Incoming jump from 0x123B, if not 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] // Inputs[1] { @123E memory[0x40:0x60] } 123C 60 PUSH1 0x40 123E 51 MLOAD 123F 62 PUSH3 0x461bcd 1243 60 PUSH1 0xe5 1245 1B SHL 1246 81 DUP2 1247 52 MSTORE 1248 60 PUSH1 0x20 124A 60 PUSH1 0x04 124C 82 DUP3 124D 01 ADD 124E 52 MSTORE 124F 60 PUSH1 0x16 1251 60 PUSH1 0x24 1253 82 DUP3 1254 01 ADD 1255 52 MSTORE 1256 7F PUSH32 0x50726573616c65206973206e6f74206163746976652e00000000000000000000 1277 60 PUSH1 0x44 1279 82 DUP3 127A 01 ADD 127B 52 MSTORE 127C 60 PUSH1 0x64 127E 01 ADD 127F 61 PUSH2 0x0e86 1282 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1247 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @124E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1255 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @127B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x50726573616c65206973206e6f74206163746976652e00000000000000000000 // @127E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1283: // Incoming jump from 0x123B, if 0xff & storage[keccak256(memory[0x00:0x00 + 0x40 + stack[-2]])] // Inputs[11] // { // @1286 memory[0x40:0x60] // @1295 msg.sender // @12A3 stack[-5] // @12AE memory[0x40:0x60] // @12BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @12C1 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @12C7 stack[-4] // @12C8 stack[-3] // @12D3 memory[0x40:0x60] // @12ED msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @12FC stack[-2] // } 1283 5B JUMPDEST 1284 60 PUSH1 0x40 1286 51 MLOAD 1287 6B PUSH12 0xffffffffffffffffffffffff 1294 19 NOT 1295 33 CALLER 1296 60 PUSH1 0x60 1298 1B SHL 1299 16 AND 129A 60 PUSH1 0x20 129C 82 DUP3 129D 01 ADD 129E 52 MSTORE 129F 60 PUSH1 0x34 12A1 81 DUP2 12A2 01 ADD 12A3 86 DUP7 12A4 90 SWAP1 12A5 52 MSTORE 12A6 60 PUSH1 0x00 12A8 90 SWAP1 12A9 60 PUSH1 0x54 12AB 01 ADD 12AC 60 PUSH1 0x40 12AE 51 MLOAD 12AF 60 PUSH1 0x20 12B1 81 DUP2 12B2 83 DUP4 12B3 03 SUB 12B4 03 SUB 12B5 81 DUP2 12B6 52 MSTORE 12B7 90 SWAP1 12B8 60 PUSH1 0x40 12BA 52 MSTORE 12BB 80 DUP1 12BC 51 MLOAD 12BD 90 SWAP1 12BE 60 PUSH1 0x20 12C0 01 ADD 12C1 20 SHA3 12C2 90 SWAP1 12C3 50 POP 12C4 61 PUSH2 0x1335 12C7 85 DUP6 12C8 85 DUP6 12C9 80 DUP1 12CA 80 DUP1 12CB 60 PUSH1 0x20 12CD 02 MUL 12CE 60 PUSH1 0x20 12D0 01 ADD 12D1 60 PUSH1 0x40 12D3 51 MLOAD 12D4 90 SWAP1 12D5 81 DUP2 12D6 01 ADD 12D7 60 PUSH1 0x40 12D9 52 MSTORE 12DA 80 DUP1 12DB 93 SWAP4 12DC 92 SWAP3 12DD 91 SWAP2 12DE 90 SWAP1 12DF 81 DUP2 12E0 81 DUP2 12E1 52 MSTORE 12E2 60 PUSH1 0x20 12E4 01 ADD 12E5 83 DUP4 12E6 83 DUP4 12E7 60 PUSH1 0x20 12E9 02 MUL 12EA 80 DUP1 12EB 82 DUP3 12EC 84 DUP5 12ED 37 CALLDATACOPY 12EE 60 PUSH1 0x00 12F0 92 SWAP3 12F1 01 ADD 12F2 82 DUP3 12F3 90 SWAP1 12F4 52 MSTORE 12F5 50 POP 12F6 60 PUSH1 0x13 12F8 93 SWAP4 12F9 50 POP 12FA 91 SWAP2 12FB 50 POP 12FC 87 DUP8 12FD 90 SWAP1 12FE 50 POP 12FF 60 PUSH1 0x02 1301 81 DUP2 1302 11 GT 1303 15 ISZERO 1304 61 PUSH2 0x130f 1307 57 *JUMPI // Stack delta = +6 // Outputs[14] // { // @129E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @12A5 memory[memory[0x40:0x60] + 0x34:memory[0x40:0x60] + 0x34 + 0x20] = stack[-5] // @12B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x54 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @12BA memory[0x40:0x60] = 0x54 + memory[0x40:0x60] // @12C2 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @12C4 stack[1] = 0x1335 // @12D9 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-3] // @12DB stack[2] = memory[0x40:0x60] // @12E1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @12ED memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3]] = msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @12F4 memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-3]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3] + 0x20] = 0x00 // @12F8 stack[3] = 0x13 // @12FA stack[4] = 0x00 // @12FD stack[5] = stack[-2] // } // Block ends with conditional call to 0x130f, returns to 0x1335, if !(stack[-2] > 0x02) label_1308: // Incoming jump from 0x1307, if not !(stack[-2] > 0x02) 1308 61 PUSH2 0x130f 130B 61 PUSH2 0x2759 130E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1308 stack[0] = 0x130f } // Block ends with unconditional jump to 0x2759 label_130F: // Incoming call from 0x1307, returns to 0x1335, if !(stack[-2] > 0x02) // Inputs[1] { @1312 stack[-1] } 130F 5B JUMPDEST 1310 60 PUSH1 0x02 1312 81 DUP2 1313 11 GT 1314 15 ISZERO 1315 61 PUSH2 0x1320 1318 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1320, if !(stack[-1] > 0x02) label_1319: // Incoming jump from 0x1318, if not !(stack[-1] > 0x02) 1319 61 PUSH2 0x1320 131C 61 PUSH2 0x2759 131F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1319 stack[0] = 0x1320 } // Block ends with unconditional jump to 0x2759 label_1320: // Incoming jump from 0x1318, if !(stack[-1] > 0x02) // Inputs[6] // { // @1321 stack[-2] // @1322 stack[-1] // @1326 stack[-3] // @132E memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @132F storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @1330 stack[-6] // } 1320 5B JUMPDEST 1321 81 DUP2 1322 52 MSTORE 1323 60 PUSH1 0x20 1325 01 ADD 1326 90 SWAP1 1327 81 DUP2 1328 52 MSTORE 1329 60 PUSH1 0x20 132B 01 ADD 132C 60 PUSH1 0x00 132E 20 SHA3 132F 54 SLOAD 1330 83 DUP4 1331 61 PUSH2 0x1daa 1334 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1322 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @1328 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @132F stack[-3] = storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]])] // @1330 stack[-2] = stack[-6] // } // Block ends with unconditional jump to 0x1daa label_1335: // Incoming return from call to 0x130F at 0x1307 // Inputs[1] { @1339 stack[-1] } 1335 5B JUMPDEST 1336 61 PUSH2 0x1381 1339 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1381, if stack[-1] label_133A: // Incoming jump from 0x1339, if not stack[-1] // Inputs[1] { @133C memory[0x40:0x60] } 133A 60 PUSH1 0x40 133C 51 MLOAD 133D 62 PUSH3 0x461bcd 1341 60 PUSH1 0xe5 1343 1B SHL 1344 81 DUP2 1345 52 MSTORE 1346 60 PUSH1 0x20 1348 60 PUSH1 0x04 134A 82 DUP3 134B 01 ADD 134C 52 MSTORE 134D 60 PUSH1 0x14 134F 60 PUSH1 0x24 1351 82 DUP3 1352 01 ADD 1353 52 MSTORE 1354 7F PUSH32 0x496e76616c6964204d65726b6c652050726f6f66000000000000000000000000 1375 60 PUSH1 0x44 1377 82 DUP3 1378 01 ADD 1379 52 MSTORE 137A 60 PUSH1 0x64 137C 01 ADD 137D 61 PUSH2 0x0e86 1380 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1345 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @134C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1353 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @1379 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e76616c6964204d65726b6c652050726f6f66000000000000000000000000 // @137C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1381: // Incoming jump from 0x1339, if stack[-1] // Inputs[3] // { // @1382 stack[-6] // @1383 stack[-7] // @1388 stack[-3] // } 1381 5B JUMPDEST 1382 85 DUP6 1383 87 DUP8 1384 60 PUSH1 0x14 1386 60 PUSH1 0x00 1388 86 DUP7 1389 60 PUSH1 0x02 138B 81 DUP2 138C 11 GT 138D 15 ISZERO 138E 61 PUSH2 0x1399 1391 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1382 stack[0] = stack[-6] // @1383 stack[1] = stack[-7] // @1384 stack[2] = 0x14 // @1386 stack[3] = 0x00 // @1388 stack[4] = stack[-3] // } // Block ends with conditional jump to 0x1399, if !(stack[-3] > 0x02) label_1392: // Incoming jump from 0x1391, if not !(stack[-3] > 0x02) 1392 61 PUSH2 0x1399 1395 61 PUSH2 0x2759 1398 56 *JUMP // Stack delta = +1 // Outputs[1] { @1392 stack[0] = 0x1399 } // Block ends with unconditional jump to 0x2759 label_1399: // Incoming jump from 0x1391, if !(stack[-3] > 0x02) // Inputs[1] { @139C stack[-1] } 1399 5B JUMPDEST 139A 60 PUSH1 0x02 139C 81 DUP2 139D 11 GT 139E 15 ISZERO 139F 61 PUSH2 0x13aa 13A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13aa, if !(stack[-1] > 0x02) label_13A3: // Incoming jump from 0x13A2, if not !(stack[-1] > 0x02) 13A3 61 PUSH2 0x13aa 13A6 61 PUSH2 0x2759 13A9 56 *JUMP // Stack delta = +1 // Outputs[1] { @13A3 stack[0] = 0x13aa } // Block ends with unconditional jump to 0x2759 label_13AA: // Incoming jump from 0x13A2, if !(stack[-1] > 0x02) // Inputs[8] // { // @13AB stack[-2] // @13AC stack[-1] // @13B2 stack[-3] // @13BF memory[0x00:0x00 + 0x40 + stack[-2]] // @13C0 msg.sender // @13C7 memory[0x00:0x40] // @13C8 storage[keccak256(memory[0x00:0x40])] // @13CC stack[-4] // } 13AA 5B JUMPDEST 13AB 81 DUP2 13AC 52 MSTORE 13AD 60 PUSH1 0x20 13AF 80 DUP1 13B0 82 DUP3 13B1 01 ADD 13B2 92 SWAP3 13B3 90 SWAP1 13B4 92 SWAP3 13B5 52 MSTORE 13B6 60 PUSH1 0x40 13B8 90 SWAP1 13B9 81 DUP2 13BA 01 ADD 13BB 60 PUSH1 0x00 13BD 90 SWAP1 13BE 81 DUP2 13BF 20 SHA3 13C0 33 CALLER 13C1 82 DUP3 13C2 52 MSTORE 13C3 90 SWAP1 13C4 92 SWAP3 13C5 52 MSTORE 13C6 90 SWAP1 13C7 20 SHA3 13C8 54 SLOAD 13C9 61 PUSH2 0x13d2 13CC 91 SWAP2 13CD 90 SWAP1 13CE 61 PUSH2 0x27be 13D1 56 *JUMP // Stack delta = -1 // Outputs[7] // { // @13AC memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @13B5 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @13C2 memory[0x00:0x20] = msg.sender // @13C5 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @13CC stack[-4] = 0x13d2 // @13CD stack[-2] = storage[keccak256(memory[0x00:0x40])] // @13CD stack[-3] = stack[-4] // } // Block ends with call to 0x27be, returns to 0x13D2 label_13D2: // Incoming return from call to 0x27BE at 0x13D1 // Inputs[2] // { // @13D3 stack[-2] // @13D3 stack[-1] // } 13D2 5B JUMPDEST 13D3 11 GT 13D4 15 ISZERO 13D5 61 PUSH2 0x1420 13D8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1420, if !(stack[-1] > stack[-2]) label_13D9: // Incoming jump from 0x13D8, if not !(stack[-1] > stack[-2]) // Inputs[1] { @13DB memory[0x40:0x60] } 13D9 60 PUSH1 0x40 13DB 51 MLOAD 13DC 62 PUSH3 0x461bcd 13E0 60 PUSH1 0xe5 13E2 1B SHL 13E3 81 DUP2 13E4 52 MSTORE 13E5 60 PUSH1 0x20 13E7 60 PUSH1 0x04 13E9 82 DUP3 13EA 01 ADD 13EB 52 MSTORE 13EC 60 PUSH1 0x13 13EE 60 PUSH1 0x24 13F0 82 DUP3 13F1 01 ADD 13F2 52 MSTORE 13F3 7F PUSH32 0x416c726561647920636c61696d6564206d617800000000000000000000000000 1414 60 PUSH1 0x44 1416 82 DUP3 1417 01 ADD 1418 52 MSTORE 1419 60 PUSH1 0x64 141B 01 ADD 141C 61 PUSH2 0x0e86 141F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @13E4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13EB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13F2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @1418 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416c726561647920636c61696d6564206d617800000000000000000000000000 // @141B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1420: // Incoming jump from 0x13D8, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1424 msg.sender // @1425 stack[-7] // } 1420 5B JUMPDEST 1421 61 PUSH2 0x142a 1424 33 CALLER 1425 88 DUP9 1426 61 PUSH2 0x1c79 1429 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1421 stack[0] = 0x142a // @1424 stack[1] = msg.sender // @1425 stack[2] = stack[-7] // } // Block ends with call to 0x1c79, returns to 0x142A label_142A: // Incoming return from call to 0x1C79 at 0x1429 // Inputs[2] // { // @142B stack[-7] // @1430 stack[-3] // } 142A 5B JUMPDEST 142B 86 DUP7 142C 60 PUSH1 0x14 142E 60 PUSH1 0x00 1430 85 DUP6 1431 60 PUSH1 0x02 1433 81 DUP2 1434 11 GT 1435 15 ISZERO 1436 61 PUSH2 0x1441 1439 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @142B stack[0] = stack[-7] // @142C stack[1] = 0x14 // @142E stack[2] = 0x00 // @1430 stack[3] = stack[-3] // } // Block ends with conditional jump to 0x1441, if !(stack[-3] > 0x02) label_143A: // Incoming jump from 0x1439, if not !(stack[-3] > 0x02) 143A 61 PUSH2 0x1441 143D 61 PUSH2 0x2759 1440 56 *JUMP // Stack delta = +1 // Outputs[1] { @143A stack[0] = 0x1441 } // Block ends with unconditional jump to 0x2759 label_1441: // Incoming jump from 0x1439, if !(stack[-3] > 0x02) // Inputs[1] { @1444 stack[-1] } 1441 5B JUMPDEST 1442 60 PUSH1 0x02 1444 81 DUP2 1445 11 GT 1446 15 ISZERO 1447 61 PUSH2 0x1452 144A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1452, if !(stack[-1] > 0x02) label_144B: // Incoming jump from 0x144A, if not !(stack[-1] > 0x02) 144B 61 PUSH2 0x1452 144E 61 PUSH2 0x2759 1451 56 *JUMP // Stack delta = +1 // Outputs[1] { @144B stack[0] = 0x1452 } // Block ends with unconditional jump to 0x2759 label_1452: // Incoming jump from 0x144A, if !(stack[-1] > 0x02) // Inputs[8] // { // @1453 stack[-2] // @1454 stack[-1] // @1458 stack[-3] // @1460 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @1463 msg.sender // @1483 memory[0x00:0x40] // @1486 stack[-4] // @1488 storage[keccak256(memory[0x00:0x40])] // } 1452 5B JUMPDEST 1453 81 DUP2 1454 52 MSTORE 1455 60 PUSH1 0x20 1457 01 ADD 1458 90 SWAP1 1459 81 DUP2 145A 52 MSTORE 145B 60 PUSH1 0x20 145D 01 ADD 145E 60 PUSH1 0x00 1460 20 SHA3 1461 60 PUSH1 0x00 1463 33 CALLER 1464 60 PUSH1 0x01 1466 60 PUSH1 0x01 1468 60 PUSH1 0xa0 146A 1B SHL 146B 03 SUB 146C 16 AND 146D 60 PUSH1 0x01 146F 60 PUSH1 0x01 1471 60 PUSH1 0xa0 1473 1B SHL 1474 03 SUB 1475 16 AND 1476 81 DUP2 1477 52 MSTORE 1478 60 PUSH1 0x20 147A 01 ADD 147B 90 SWAP1 147C 81 DUP2 147D 52 MSTORE 147E 60 PUSH1 0x20 1480 01 ADD 1481 60 PUSH1 0x00 1483 20 SHA3 1484 60 PUSH1 0x00 1486 82 DUP3 1487 82 DUP3 1488 54 SLOAD 1489 61 PUSH2 0x1492 148C 91 SWAP2 148D 90 SWAP1 148E 61 PUSH2 0x27be 1491 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @1454 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @145A memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @1477 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & msg.sender // @147D memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @1483 stack[-3] = keccak256(memory[0x00:0x40]) // @1484 stack[-2] = 0x00 // @148C stack[-1] = 0x1492 // @148D stack[1] = storage[keccak256(memory[0x00:0x40])] // @148D stack[0] = stack[-4] // } // Block ends with call to 0x27be, returns to 0x1492 label_1492: // Incoming return from call to 0x27BE at 0x1491 // Inputs[4] // { // @1493 stack[-1] // @1493 stack[-2] // @1494 stack[-3] // @14A4 stack[-12] // } 1492 5B JUMPDEST 1493 90 SWAP1 1494 91 SWAP2 1495 55 SSTORE 1496 50 POP 1497 50 POP 1498 60 PUSH1 0x01 149A 60 PUSH1 0x0a 149C 55 SSTORE 149D 50 POP 149E 50 POP 149F 50 POP 14A0 50 POP 14A1 50 POP 14A2 50 POP 14A3 50 POP 14A4 56 *JUMP // Stack delta = -12 // Outputs[2] // { // @1495 storage[stack[-3]] = stack[-1] // @149C storage[0x0a] = 0x01 // } // Block ends with unconditional jump to stack[-12] label_14A5: // Incoming jump from 0x0524 14A5 5B JUMPDEST 14A6 61 PUSH2 0x14ad 14A9 61 PUSH2 0x18de 14AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @14A6 stack[0] = 0x14ad } // Block ends with call to 0x18de, returns to 0x14AD label_14AD: // Incoming return from call to 0x18DE at 0x14AC // Inputs[2] // { // @14C6 address(this) // @14C6 address(this).balance // } 14AD 5B JUMPDEST 14AE 61 PUSH2 0x14cb 14B1 73 PUSH20 0x6ce6f6fcbab24d5b7ee4190eb8f38ba167e0dc48 14C6 47 SELFBALANCE 14C7 61 PUSH2 0x1dc0 14CA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14AE stack[0] = 0x14cb // @14B1 stack[1] = 0x6ce6f6fcbab24d5b7ee4190eb8f38ba167e0dc48 // @14C6 stack[2] = address(this).balance // } // Block ends with call to 0x1dc0, returns to 0x14CB label_14CB: // Incoming jump from 0x21B6, if 0xff & storage[0x0b] / (0x01 << 0xa0) // Incoming return from call to 0x1F2E at 0x161D // Incoming jump from 0x18F0, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] // Incoming jump from 0x1B28, if !(0xff & storage[0x0b] / (0x01 << 0xa0)) // Incoming return from call to 0x1DC0 at 0x14CA // Incoming return from call to 0x1ED9 at 0x14DC // Incoming return from call to 0x1F8D at 0x163A // Inputs[1] { @14CC stack[-1] } 14CB 5B JUMPDEST 14CC 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_14CD: // Incoming jump from 0x0539 14CD 5B JUMPDEST 14CE 61 PUSH2 0x14d5 14D1 61 PUSH2 0x18de 14D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @14CE stack[0] = 0x14d5 } // Block ends with call to 0x18de, returns to 0x14D5 label_14D5: // Incoming return from call to 0x18DE at 0x14D4 14D5 5B JUMPDEST 14D6 61 PUSH2 0x14cb 14D9 61 PUSH2 0x1ed9 14DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @14D6 stack[0] = 0x14cb } // Block ends with call to 0x1ed9, returns to 0x14CB label_14DD: // Incoming jump from 0x054C // Inputs[4] // { // @14E1 stack[-3] // @14E2 stack[-2] // @14E3 stack[-1] // @14E6 memory[0x40:0x60] // } 14DD 5B JUMPDEST 14DE 61 PUSH2 0x14f8 14E1 83 DUP4 14E2 83 DUP4 14E3 83 DUP4 14E4 60 PUSH1 0x40 14E6 51 MLOAD 14E7 80 DUP1 14E8 60 PUSH1 0x20 14EA 01 ADD 14EB 60 PUSH1 0x40 14ED 52 MSTORE 14EE 80 DUP1 14EF 60 PUSH1 0x00 14F1 81 DUP2 14F2 52 MSTORE 14F3 50 POP 14F4 61 PUSH2 0x16d1 14F7 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @14DE stack[0] = 0x14f8 // @14E1 stack[1] = stack[-3] // @14E2 stack[2] = stack[-2] // @14E3 stack[3] = stack[-1] // @14E6 stack[4] = memory[0x40:0x60] // @14ED memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @14F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x16d1, returns to 0x14F8 label_14F8: // Incoming jump from 0x27DA, if !(stack[-2] > 0x1f) // Incoming return from call to 0x16D1 at 0x14F7 // Incoming jump from 0x1E6B, if stack[-3] // Incoming jump from 0x1E6B, if stack[-3] // Inputs[1] { @14FC stack[-4] } 14F8 5B JUMPDEST 14F9 50 POP 14FA 50 POP 14FB 50 POP 14FC 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_14FD: // Incoming jump from 0x056C 14FD 5B JUMPDEST 14FE 61 PUSH2 0x1505 1501 61 PUSH2 0x18de 1504 56 *JUMP // Stack delta = +1 // Outputs[1] { @14FE stack[0] = 0x1505 } // Block ends with call to 0x18de, returns to 0x1505 label_1505: // Incoming return from call to 0x18DE at 0x1504 // Inputs[2] // { // @1509 stack[-2] // @150A stack[-1] // } 1505 5B JUMPDEST 1506 61 PUSH2 0x150f 1509 82 DUP3 150A 82 DUP3 150B 61 PUSH2 0x1c79 150E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1506 stack[0] = 0x150f // @1509 stack[1] = stack[-2] // @150A stack[2] = stack[-1] // } // Block ends with call to 0x1c79, returns to 0x150F label_150F: // Incoming return from call to 0x1C79 at 0x150E // Incoming return from call to 0x2817 at 0x1526 // Incoming jump from 0x1C31, if !(msg.value < stack[-1]) // Inputs[1] { @1512 stack[-3] } 150F 5B JUMPDEST 1510 50 POP 1511 50 POP 1512 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1513: // Incoming jump from 0x05A6 1513 5B JUMPDEST 1514 61 PUSH2 0x151b 1517 61 PUSH2 0x18de 151A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1514 stack[0] = 0x151b } // Block ends with call to 0x18de, returns to 0x151B label_151B: // Incoming return from call to 0x18DE at 0x151A // Inputs[1] { @1521 stack[-1] } 151B 5B JUMPDEST 151C 60 PUSH1 0x0c 151E 61 PUSH2 0x150f 1521 82 DUP3 1522 82 DUP3 1523 61 PUSH2 0x2817 1526 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @151C stack[0] = 0x0c // @151E stack[1] = 0x150f // @1521 stack[2] = stack[-1] // @1522 stack[3] = 0x0c // } // Block ends with call to 0x2817, returns to 0x150F label_1527: // Incoming jump from 0x05E5 // Incoming call from 0x0A35, returns to 0x0A36 // Inputs[1] { @152D stack[-1] } 1527 5B JUMPDEST 1528 60 PUSH1 0x00 152A 61 PUSH2 0x08cb 152D 82 DUP3 152E 61 PUSH2 0x1a87 1531 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1528 stack[0] = 0x00 // @152A stack[1] = 0x08cb // @152D stack[2] = stack[-1] // } // Block ends with call to 0x1a87, returns to 0x08CB label_1532: // Incoming jump from 0x0605 1532 5B JUMPDEST 1533 61 PUSH2 0x153a 1536 61 PUSH2 0x18de 1539 56 *JUMP // Stack delta = +1 // Outputs[1] { @1533 stack[0] = 0x153a } // Block ends with call to 0x18de, returns to 0x153A label_153A: // Incoming return from call to 0x18DE at 0x1539 // Inputs[2] // { // @153B stack[-2] // @1540 stack[-1] // } 153A 5B JUMPDEST 153B 81 DUP2 153C 60 PUSH1 0x13 153E 60 PUSH1 0x00 1540 83 DUP4 1541 60 PUSH1 0x02 1543 81 DUP2 1544 11 GT 1545 15 ISZERO 1546 61 PUSH2 0x0b2d 1549 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @153B stack[0] = stack[-2] // @153C stack[1] = 0x13 // @153E stack[2] = 0x00 // @1540 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0b2d, if !(stack[-1] > 0x02) label_154A: // Incoming jump from 0x1549, if not !(stack[-1] > 0x02) 154A 61 PUSH2 0x0b2d 154D 61 PUSH2 0x2759 1550 56 *JUMP // Stack delta = +1 // Outputs[1] { @154A stack[0] = 0x0b2d } // Block ends with unconditional jump to 0x2759 label_1551: // Incoming jump from 0x0625 // Inputs[1] { @155C stack[-1] } 1551 5B JUMPDEST 1552 60 PUSH1 0x00 1554 60 PUSH1 0x01 1556 60 PUSH1 0x01 1558 60 PUSH1 0xa0 155A 1B SHL 155B 03 SUB 155C 82 DUP3 155D 16 AND 155E 61 PUSH2 0x1593 1561 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1552 stack[0] = 0x00 } // Block ends with conditional jump to 0x1593, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1562: // Incoming jump from 0x1561, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1564 memory[0x40:0x60] // @158D memory[0x40:0x60] // @1592 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1562 60 PUSH1 0x40 1564 51 MLOAD 1565 7F PUSH32 0x8f4eb60400000000000000000000000000000000000000000000000000000000 1586 81 DUP2 1587 52 MSTORE 1588 60 PUSH1 0x04 158A 01 ADD 158B 60 PUSH1 0x40 158D 51 MLOAD 158E 80 DUP1 158F 91 SWAP2 1590 03 SUB 1591 90 SWAP1 1592 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1587 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8f4eb60400000000000000000000000000000000000000000000000000000000 // @1592 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1593: // Incoming jump from 0x1561, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @159D stack[-2] // @15AB memory[0x00:0x40] // @15AC storage[keccak256(memory[0x00:0x40])] // @15B7 stack[-3] // } 1593 5B JUMPDEST 1594 50 POP 1595 60 PUSH1 0x01 1597 60 PUSH1 0x01 1599 60 PUSH1 0xa0 159B 1B SHL 159C 03 SUB 159D 16 AND 159E 60 PUSH1 0x00 15A0 90 SWAP1 15A1 81 DUP2 15A2 52 MSTORE 15A3 60 PUSH1 0x05 15A5 60 PUSH1 0x20 15A7 52 MSTORE 15A8 60 PUSH1 0x40 15AA 90 SWAP1 15AB 20 SHA3 15AC 54 SLOAD 15AD 67 PUSH8 0xffffffffffffffff 15B6 16 AND 15B7 90 SWAP1 15B8 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @15A2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @15A7 memory[0x20:0x40] = 0x05 // @15B7 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 15B9 5B JUMPDEST 15BA 61 PUSH2 0x15c1 15BD 61 PUSH2 0x18de 15C0 56 *JUMP 15C1 5B JUMPDEST 15C2 81 DUP2 15C3 60 PUSH1 0x12 15C5 60 PUSH1 0x00 15C7 83 DUP4 15C8 60 PUSH1 0x02 15CA 81 DUP2 15CB 11 GT 15CC 15 ISZERO 15CD 61 PUSH2 0x15d8 15D0 57 *JUMPI 15D1 61 PUSH2 0x15d8 15D4 61 PUSH2 0x2759 15D7 56 *JUMP 15D8 5B JUMPDEST 15D9 60 PUSH1 0x02 15DB 81 DUP2 15DC 11 GT 15DD 15 ISZERO 15DE 61 PUSH2 0x15e9 15E1 57 *JUMPI 15E2 61 PUSH2 0x15e9 15E5 61 PUSH2 0x2759 15E8 56 *JUMP 15E9 5B JUMPDEST 15EA 81 DUP2 15EB 52 MSTORE 15EC 60 PUSH1 0x20 15EE 81 DUP2 15EF 01 ADD 15F0 91 SWAP2 15F1 90 SWAP1 15F2 91 SWAP2 15F3 52 MSTORE 15F4 60 PUSH1 0x40 15F6 01 ADD 15F7 60 PUSH1 0x00 15F9 20 SHA3 15FA 80 DUP1 15FB 54 SLOAD 15FC 60 PUSH1 0xff 15FE 19 NOT 15FF 16 AND 1600 91 SWAP2 1601 15 ISZERO 1602 15 ISZERO 1603 91 SWAP2 1604 90 SWAP1 1605 91 SWAP2 1606 17 OR 1607 90 SWAP1 1608 55 SSTORE 1609 50 POP 160A 50 POP 160B 56 *JUMP label_160C: // Incoming jump from 0x065A 160C 5B JUMPDEST 160D 61 PUSH2 0x1614 1610 61 PUSH2 0x18de 1613 56 *JUMP // Stack delta = +1 // Outputs[1] { @160D stack[0] = 0x1614 } // Block ends with call to 0x18de, returns to 0x1614 label_1614: // Incoming return from call to 0x18DE at 0x1613 1614 5B JUMPDEST 1615 61 PUSH2 0x14cb 1618 60 PUSH1 0x00 161A 61 PUSH2 0x1f2e 161D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1615 stack[0] = 0x14cb // @1618 stack[1] = 0x00 // } // Block ends with call to 0x1f2e, returns to 0x14CB label_161E: // Incoming jump from 0x06A7 161E 5B JUMPDEST 161F 61 PUSH2 0x1626 1622 61 PUSH2 0x18de 1625 56 *JUMP // Stack delta = +1 // Outputs[1] { @161F stack[0] = 0x1626 } // Block ends with call to 0x18de, returns to 0x1626 label_1626: // Incoming return from call to 0x18DE at 0x1625 // Inputs[2] // { // @1629 stack[-1] // @162A stack[-2] // } 1626 5B JUMPDEST 1627 60 PUSH1 0x0e 1629 55 SSTORE 162A 56 *JUMP // Stack delta = -2 // Outputs[1] { @1629 storage[0x0e] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_162B: // Incoming jump from 0x06BC 162B 5B JUMPDEST 162C 61 PUSH2 0x1633 162F 61 PUSH2 0x18de 1632 56 *JUMP // Stack delta = +1 // Outputs[1] { @162C stack[0] = 0x1633 } // Block ends with call to 0x18de, returns to 0x1633 label_1633: // Incoming return from call to 0x18DE at 0x1632 1633 5B JUMPDEST 1634 61 PUSH2 0x14cb 1637 61 PUSH2 0x1f8d 163A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1634 stack[0] = 0x14cb } // Block ends with call to 0x1f8d, returns to 0x14CB label_163B: // Incoming call from 0x0705, returns to 0x0358 // Inputs[1] { @1641 storage[0x03] } 163B 5B JUMPDEST 163C 60 PUSH1 0x60 163E 60 PUSH1 0x03 1640 80 DUP1 1641 54 SLOAD 1642 61 PUSH2 0x094b 1645 90 SWAP1 1646 61 PUSH2 0x271f 1649 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @163C stack[0] = 0x60 // @163E stack[1] = 0x03 // @1645 stack[2] = 0x094b // @1645 stack[3] = storage[0x03] // } // Block ends with call to 0x271f, returns to 0x094B label_164A: // Incoming jump from 0x075D 164A 5B JUMPDEST 164B 61 PUSH2 0x1652 164E 61 PUSH2 0x18de 1651 56 *JUMP // Stack delta = +1 // Outputs[1] { @164B stack[0] = 0x1652 } // Block ends with call to 0x18de, returns to 0x1652 label_1652: // Incoming return from call to 0x18DE at 0x1651 // Inputs[3] // { // @1656 storage[0x0d] // @165B stack[-1] // @1664 stack[-2] // } 1652 5B JUMPDEST 1653 60 PUSH1 0x0d 1655 80 DUP1 1656 54 SLOAD 1657 60 PUSH1 0xff 1659 19 NOT 165A 16 AND 165B 91 SWAP2 165C 15 ISZERO 165D 15 ISZERO 165E 91 SWAP2 165F 90 SWAP1 1660 91 SWAP2 1661 17 OR 1662 90 SWAP1 1663 55 SSTORE 1664 56 *JUMP // Stack delta = -2 // Outputs[1] { @1663 storage[0x0d] = !!stack[-1] | (~0xff & storage[0x0d]) } // Block ends with unconditional jump to stack[-2] 1665 5B JUMPDEST 1666 33 CALLER 1667 60 PUSH1 0x00 1669 81 DUP2 166A 81 DUP2 166B 52 MSTORE 166C 60 PUSH1 0x07 166E 60 PUSH1 0x20 1670 90 SWAP1 1671 81 DUP2 1672 52 MSTORE 1673 60 PUSH1 0x40 1675 80 DUP1 1676 83 DUP4 1677 20 SHA3 1678 60 PUSH1 0x01 167A 60 PUSH1 0x01 167C 60 PUSH1 0xa0 167E 1B SHL 167F 03 SUB 1680 87 DUP8 1681 16 AND 1682 80 DUP1 1683 85 DUP6 1684 52 MSTORE 1685 90 SWAP1 1686 83 DUP4 1687 52 MSTORE 1688 92 SWAP3 1689 81 DUP2 168A 90 SWAP1 168B 20 SHA3 168C 80 DUP1 168D 54 SLOAD 168E 60 PUSH1 0xff 1690 19 NOT 1691 16 AND 1692 86 DUP7 1693 15 ISZERO 1694 15 ISZERO 1695 90 SWAP1 1696 81 DUP2 1697 17 OR 1698 90 SWAP1 1699 91 SWAP2 169A 55 SSTORE 169B 90 SWAP1 169C 51 MLOAD 169D 90 SWAP1 169E 81 DUP2 169F 52 MSTORE 16A0 91 SWAP2 16A1 92 SWAP3 16A2 91 SWAP2 16A3 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 16C4 91 SWAP2 16C5 01 ADD 16C6 60 PUSH1 0x40 16C8 51 MLOAD 16C9 80 DUP1 16CA 91 SWAP2 16CB 03 SUB 16CC 90 SWAP1 16CD A3 LOG3 16CE 50 POP 16CF 50 POP 16D0 56 *JUMP label_16D1: // Incoming jump from 0x07B5 // Incoming call from 0x14F7, returns to 0x14F8 // Inputs[3] // { // @16D5 stack[-4] // @16D6 stack[-3] // @16D7 stack[-2] // } 16D1 5B JUMPDEST 16D2 61 PUSH2 0x16dc 16D5 84 DUP5 16D6 84 DUP5 16D7 84 DUP5 16D8 61 PUSH2 0x0b53 16DB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @16D2 stack[0] = 0x16dc // @16D5 stack[1] = stack[-4] // @16D6 stack[2] = stack[-3] // @16D7 stack[3] = stack[-2] // } // Block ends with call to 0x0b53, returns to 0x16DC label_16DC: // Incoming return from call to 0x0B53 at 0x16DB // Inputs[2] // { // @16E5 stack[-3] // @16E7 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 16DC 5B JUMPDEST 16DD 60 PUSH1 0x01 16DF 60 PUSH1 0x01 16E1 60 PUSH1 0xa0 16E3 1B SHL 16E4 03 SUB 16E5 83 DUP4 16E6 16 AND 16E7 3B EXTCODESIZE 16E8 15 ISZERO 16E9 61 PUSH2 0x1715 16EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1715, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_16ED: // Incoming jump from 0x16EC, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @16F0 stack[-4] // @16F1 stack[-3] // @16F2 stack[-2] // @16F3 stack[-1] // } 16ED 61 PUSH2 0x16f8 16F0 84 DUP5 16F1 84 DUP5 16F2 84 DUP5 16F3 84 DUP5 16F4 61 PUSH2 0x1fd0 16F7 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @16ED stack[0] = 0x16f8 // @16F0 stack[1] = stack[-4] // @16F1 stack[2] = stack[-3] // @16F2 stack[3] = stack[-2] // @16F3 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1fd0 16F8 5B JUMPDEST 16F9 61 PUSH2 0x1715 16FC 57 *JUMPI 16FD 60 PUSH1 0x40 16FF 51 MLOAD 1700 63 PUSH4 0x68d2bf6b 1705 60 PUSH1 0xe1 1707 1B SHL 1708 81 DUP2 1709 52 MSTORE 170A 60 PUSH1 0x04 170C 01 ADD 170D 60 PUSH1 0x40 170F 51 MLOAD 1710 80 DUP1 1711 91 SWAP2 1712 03 SUB 1713 90 SWAP1 1714 FD *REVERT label_1715: // Incoming jump from 0x16EC, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @171A stack[-5] } 1715 5B JUMPDEST 1716 50 POP 1717 50 POP 1718 50 POP 1719 50 POP 171A 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_171B: // Incoming jump from 0x0817 // Inputs[1] { @1721 stack[-1] } 171B 5B JUMPDEST 171C 60 PUSH1 0x60 171E 61 PUSH2 0x1726 1721 82 DUP3 1722 61 PUSH2 0x20bc 1725 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @171C stack[0] = 0x60 // @171E stack[1] = 0x1726 // @1721 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x20bc 1726 5B JUMPDEST 1727 60 PUSH1 0x40 1729 51 MLOAD 172A 80 DUP1 172B 60 PUSH1 0x40 172D 01 ADD 172E 60 PUSH1 0x40 1730 52 MSTORE 1731 80 DUP1 1732 60 PUSH1 0x05 1734 81 DUP2 1735 52 MSTORE 1736 60 PUSH1 0x20 1738 01 ADD 1739 7F PUSH32 0x2e6a736f6e000000000000000000000000000000000000000000000000000000 175A 81 DUP2 175B 52 MSTORE 175C 50 POP 175D 60 PUSH1 0x40 175F 51 MLOAD 1760 60 PUSH1 0x20 1762 01 ADD 1763 61 PUSH2 0x176d 1766 92 SWAP3 1767 91 SWAP2 1768 90 SWAP1 1769 61 PUSH2 0x28d7 176C 56 *JUMP 176D 5B JUMPDEST 176E 60 PUSH1 0x40 1770 51 MLOAD 1771 60 PUSH1 0x20 1773 81 DUP2 1774 83 DUP4 1775 03 SUB 1776 03 SUB 1777 81 DUP2 1778 52 MSTORE 1779 90 SWAP1 177A 60 PUSH1 0x40 177C 52 MSTORE 177D 90 SWAP1 177E 50 POP 177F 91 SWAP2 1780 90 SWAP1 1781 50 POP 1782 56 *JUMP label_1783: // Incoming jump from 0x08B0 1783 5B JUMPDEST 1784 61 PUSH2 0x178b 1787 61 PUSH2 0x18de 178A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1784 stack[0] = 0x178b } // Block ends with call to 0x18de, returns to 0x178B label_178B: // Incoming return from call to 0x18DE at 0x178A // Inputs[1] { @1794 stack[-1] } 178B 5B JUMPDEST 178C 60 PUSH1 0x01 178E 60 PUSH1 0x01 1790 60 PUSH1 0xa0 1792 1B SHL 1793 03 SUB 1794 81 DUP2 1795 16 AND 1796 61 PUSH2 0x1807 1799 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1807, if stack[-1] & (0x01 << 0xa0) - 0x01 label_179A: // Incoming jump from 0x1799, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @179C memory[0x40:0x60] } 179A 60 PUSH1 0x40 179C 51 MLOAD 179D 62 PUSH3 0x461bcd 17A1 60 PUSH1 0xe5 17A3 1B SHL 17A4 81 DUP2 17A5 52 MSTORE 17A6 60 PUSH1 0x20 17A8 60 PUSH1 0x04 17AA 82 DUP3 17AB 01 ADD 17AC 52 MSTORE 17AD 60 PUSH1 0x26 17AF 60 PUSH1 0x24 17B1 82 DUP3 17B2 01 ADD 17B3 52 MSTORE 17B4 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 17D5 60 PUSH1 0x44 17D7 82 DUP3 17D8 01 ADD 17D9 52 MSTORE 17DA 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 17FB 60 PUSH1 0x64 17FD 82 DUP3 17FE 01 ADD 17FF 52 MSTORE 1800 60 PUSH1 0x84 1802 01 ADD 1803 61 PUSH2 0x0e86 1806 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @17A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17AC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @17B3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @17D9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @17FF memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @1802 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1807: // Incoming jump from 0x1799, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @180B stack[-1] } 1807 5B JUMPDEST 1808 61 PUSH2 0x0939 180B 81 DUP2 180C 61 PUSH2 0x1f2e 180F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1808 stack[0] = 0x0939 // @180B stack[1] = stack[-1] // } // Block ends with call to 0x1f2e, returns to 0x0939 label_1810: // Incoming call from 0x08BB, returns to 0x08BC // Inputs[1] { @1824 stack[-1] } 1810 5B JUMPDEST 1811 60 PUSH1 0x00 1813 63 PUSH4 0x01ffc9a7 1818 60 PUSH1 0xe0 181A 1B SHL 181B 60 PUSH1 0x01 181D 60 PUSH1 0x01 181F 60 PUSH1 0xe0 1821 1B SHL 1822 03 SUB 1823 19 NOT 1824 83 DUP4 1825 16 AND 1826 14 EQ 1827 80 DUP1 1828 61 PUSH2 0x185a 182B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1811 stack[0] = 0x00 // @1826 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x185a, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_182C: // Incoming jump from 0x182B, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @1857 stack[-3] } 182C 50 POP 182D 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 184E 60 PUSH1 0x01 1850 60 PUSH1 0x01 1852 60 PUSH1 0xe0 1854 1B SHL 1855 03 SUB 1856 19 NOT 1857 83 DUP4 1858 16 AND 1859 14 EQ 185A 5B JUMPDEST 185B 80 DUP1 185C 61 PUSH2 0x08cb 185F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1859 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x08cb, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000 label_1860: // Incoming jump from 0x185F, if not stack[-1] // Incoming jump from 0x185F, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000 // Inputs[2] // { // @186B stack[-3] // @188E stack[-4] // } 1860 50 POP 1861 50 POP 1862 60 PUSH1 0x01 1864 60 PUSH1 0x01 1866 60 PUSH1 0xe0 1868 1B SHL 1869 03 SUB 186A 19 NOT 186B 16 AND 186C 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 188D 14 EQ 188E 90 SWAP1 188F 56 *JUMP // Stack delta = -3 // Outputs[1] { @188E stack[-4] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == ~((0x01 << 0xe0) - 0x01) & stack[-3] } // Block ends with unconditional jump to stack[-4] label_1890: // Incoming call from 0x08CA, returns to 0x08CB // Inputs[1] { @189C stack[-1] } 1890 5B JUMPDEST 1891 60 PUSH1 0x00 1893 60 PUSH1 0x01 1895 60 PUSH1 0x01 1897 60 PUSH1 0xe0 1899 1B SHL 189A 03 SUB 189B 19 NOT 189C 82 DUP3 189D 16 AND 189E 7F PUSH32 0x2a55205a00000000000000000000000000000000000000000000000000000000 18BF 14 EQ 18C0 80 DUP1 18C1 61 PUSH2 0x08cb 18C4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1891 stack[0] = 0x00 // @18BF stack[1] = 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x08cb, if 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_18C5: // Incoming jump from 0x18C4, if not 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @18D7 stack[-3] } 18C5 50 POP 18C6 63 PUSH4 0x01ffc9a7 18CB 60 PUSH1 0xe0 18CD 1B SHL 18CE 60 PUSH1 0x01 18D0 60 PUSH1 0x01 18D2 60 PUSH1 0xe0 18D4 1B SHL 18D5 03 SUB 18D6 19 NOT 18D7 83 DUP4 18D8 16 AND 18D9 14 EQ 18DA 61 PUSH2 0x08cb 18DD 56 *JUMP // Stack delta = +0 // Outputs[1] { @18D9 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x08cb label_18DE: // Incoming call from 0x14AC, returns to 0x14AD // Incoming call from 0x100F, returns to 0x1010 // Incoming call from 0x1632, returns to 0x1633 // Incoming call from 0x1504, returns to 0x1505 // Incoming call from 0x1651, returns to 0x1652 // Incoming call from 0x14D4, returns to 0x14D5 // Incoming call from 0x1625, returns to 0x1626 // Incoming call from 0x1539, returns to 0x153A // Incoming call from 0x1613, returns to 0x1614 // Incoming call from 0x151A, returns to 0x151B // Incoming call from 0x0D5C, returns to 0x0D5D // Incoming call from 0x178A, returns to 0x178B // Incoming call from 0x0B15, returns to 0x0B16 // Incoming call from 0x08D8, returns to 0x08D9 // Inputs[2] // { // @18E1 storage[0x0b] // @18EB msg.sender // } 18DE 5B JUMPDEST 18DF 60 PUSH1 0x0b 18E1 54 SLOAD 18E2 60 PUSH1 0x01 18E4 60 PUSH1 0x01 18E6 60 PUSH1 0xa0 18E8 1B SHL 18E9 03 SUB 18EA 16 AND 18EB 33 CALLER 18EC 14 EQ 18ED 61 PUSH2 0x14cb 18F0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14cb, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] label_18F1: // Incoming jump from 0x18F0, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0b] // Inputs[1] { @18F3 memory[0x40:0x60] } 18F1 60 PUSH1 0x40 18F3 51 MLOAD 18F4 62 PUSH3 0x461bcd 18F8 60 PUSH1 0xe5 18FA 1B SHL 18FB 81 DUP2 18FC 52 MSTORE 18FD 60 PUSH1 0x20 18FF 60 PUSH1 0x04 1901 82 DUP3 1902 01 ADD 1903 81 DUP2 1904 90 SWAP1 1905 52 MSTORE 1906 60 PUSH1 0x24 1908 82 DUP3 1909 01 ADD 190A 52 MSTORE 190B 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 192C 60 PUSH1 0x44 192E 82 DUP3 192F 01 ADD 1930 52 MSTORE 1931 60 PUSH1 0x64 1933 01 ADD 1934 61 PUSH2 0x0e86 1937 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @18FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1905 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @190A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1930 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1933 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1938: // Incoming call from 0x1053, returns to 0x0939 // Incoming call from 0x0938, returns to 0x0939 // Inputs[1] { @1949 stack[-1] } 1938 5B JUMPDEST 1939 61 PUSH2 0x2710 193C 6B PUSH12 0xffffffffffffffffffffffff 1949 82 DUP3 194A 16 AND 194B 11 GT 194C 15 ISZERO 194D 61 PUSH2 0x19be 1950 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19be, if !(stack[-1] & 0xffffffffffffffffffffffff > 0x2710) label_1951: // Incoming jump from 0x1950, if not !(stack[-1] & 0xffffffffffffffffffffffff > 0x2710) // Inputs[1] { @1953 memory[0x40:0x60] } 1951 60 PUSH1 0x40 1953 51 MLOAD 1954 62 PUSH3 0x461bcd 1958 60 PUSH1 0xe5 195A 1B SHL 195B 81 DUP2 195C 52 MSTORE 195D 60 PUSH1 0x20 195F 60 PUSH1 0x04 1961 82 DUP3 1962 01 ADD 1963 52 MSTORE 1964 60 PUSH1 0x2a 1966 60 PUSH1 0x24 1968 82 DUP3 1969 01 ADD 196A 52 MSTORE 196B 7F PUSH32 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 198C 60 PUSH1 0x44 198E 82 DUP3 198F 01 ADD 1990 52 MSTORE 1991 7F PUSH32 0x2073616c65507269636500000000000000000000000000000000000000000000 19B2 60 PUSH1 0x64 19B4 82 DUP3 19B5 01 ADD 19B6 52 MSTORE 19B7 60 PUSH1 0x84 19B9 01 ADD 19BA 61 PUSH2 0x0e86 19BD 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @195C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1963 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @196A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @1990 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 // @19B6 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2073616c65507269636500000000000000000000000000000000000000000000 // @19B9 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_19BE: // Incoming jump from 0x1950, if !(stack[-1] & 0xffffffffffffffffffffffff > 0x2710) // Inputs[1] { @19C7 stack[-2] } 19BE 5B JUMPDEST 19BF 60 PUSH1 0x01 19C1 60 PUSH1 0x01 19C3 60 PUSH1 0xa0 19C5 1B SHL 19C6 03 SUB 19C7 82 DUP3 19C8 16 AND 19C9 61 PUSH2 0x1a14 19CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a14, if stack[-2] & (0x01 << 0xa0) - 0x01 label_19CD: // Incoming jump from 0x19CC, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @19CF memory[0x40:0x60] } 19CD 60 PUSH1 0x40 19CF 51 MLOAD 19D0 62 PUSH3 0x461bcd 19D4 60 PUSH1 0xe5 19D6 1B SHL 19D7 81 DUP2 19D8 52 MSTORE 19D9 60 PUSH1 0x20 19DB 60 PUSH1 0x04 19DD 82 DUP3 19DE 01 ADD 19DF 52 MSTORE 19E0 60 PUSH1 0x19 19E2 60 PUSH1 0x24 19E4 82 DUP3 19E5 01 ADD 19E6 52 MSTORE 19E7 7F PUSH32 0x455243323938313a20696e76616c696420726563656976657200000000000000 1A08 60 PUSH1 0x44 1A0A 82 DUP3 1A0B 01 ADD 1A0C 52 MSTORE 1A0D 60 PUSH1 0x64 1A0F 01 ADD 1A10 61 PUSH2 0x0e86 1A13 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @19D8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @19DF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @19E6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @1A0C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20696e76616c696420726563656976657200000000000000 // @1A0F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1A14: // Incoming jump from 0x19CC, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1A18 memory[0x40:0x60] // @1A28 stack[-2] // @1A3B stack[-1] // @1A51 stack[-3] // } 1A14 5B JUMPDEST 1A15 60 PUSH1 0x40 1A17 80 DUP1 1A18 51 MLOAD 1A19 80 DUP1 1A1A 82 DUP3 1A1B 01 ADD 1A1C 90 SWAP1 1A1D 91 SWAP2 1A1E 52 MSTORE 1A1F 60 PUSH1 0x01 1A21 60 PUSH1 0x01 1A23 60 PUSH1 0xa0 1A25 1B SHL 1A26 03 SUB 1A27 90 SWAP1 1A28 92 SWAP3 1A29 16 AND 1A2A 80 DUP1 1A2B 83 DUP4 1A2C 52 MSTORE 1A2D 6B PUSH12 0xffffffffffffffffffffffff 1A3A 90 SWAP1 1A3B 91 SWAP2 1A3C 16 AND 1A3D 60 PUSH1 0x20 1A3F 90 SWAP1 1A40 92 SWAP3 1A41 01 ADD 1A42 82 DUP3 1A43 90 SWAP1 1A44 52 MSTORE 1A45 60 PUSH1 0x01 1A47 60 PUSH1 0xa0 1A49 1B SHL 1A4A 90 SWAP1 1A4B 91 SWAP2 1A4C 02 MUL 1A4D 17 OR 1A4E 60 PUSH1 0x08 1A50 55 SSTORE 1A51 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @1A1E memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1A2C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1A44 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & 0xffffffffffffffffffffffff // @1A50 storage[0x08] = (stack[-1] & 0xffffffffffffffffffffffff) * (0x01 << 0xa0) | (stack[-2] & (0x01 << 0xa0) - 0x01) // } // Block ends with unconditional jump to stack[-3] label_1A52: // Incoming call from 0x09D8, returns to 0x09D9 // Incoming call from 0x20C6, returns to 0x20C7 // Inputs[1] { @1A55 stack[-1] } 1A52 5B JUMPDEST 1A53 60 PUSH1 0x00 1A55 81 DUP2 1A56 60 PUSH1 0x01 1A58 11 GT 1A59 15 ISZERO 1A5A 80 DUP1 1A5B 15 ISZERO 1A5C 61 PUSH2 0x1a66 1A5F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A53 stack[0] = 0x00 // @1A59 stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x1a66, if !!(0x01 > stack[-1]) label_1A60: // Incoming jump from 0x1A5F, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @1A63 storage[0x00] // @1A64 stack[-3] // } 1A60 50 POP 1A61 60 PUSH1 0x00 1A63 54 SLOAD 1A64 82 DUP3 1A65 10 LT 1A66 5B JUMPDEST 1A67 80 DUP1 1A68 15 ISZERO 1A69 61 PUSH2 0x08cb 1A6C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A65 stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x08cb, if !(stack[-3] < storage[0x00]) label_1A6D: // Incoming jump from 0x1A6C, if not !stack[-1] // Incoming jump from 0x1A6C, if not !(stack[-3] < storage[0x00]) // Inputs[4] // { // @1A71 stack[-3] // @1A7C memory[0x00:0x40] // @1A7D storage[keccak256(memory[0x00:0x40])] // @1A85 stack[-4] // } 1A6D 50 POP 1A6E 50 POP 1A6F 60 PUSH1 0x00 1A71 90 SWAP1 1A72 81 DUP2 1A73 52 MSTORE 1A74 60 PUSH1 0x04 1A76 60 PUSH1 0x20 1A78 52 MSTORE 1A79 60 PUSH1 0x40 1A7B 90 SWAP1 1A7C 20 SHA3 1A7D 54 SLOAD 1A7E 60 PUSH1 0x01 1A80 60 PUSH1 0xe0 1A82 1B SHL 1A83 16 AND 1A84 15 ISZERO 1A85 90 SWAP1 1A86 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1A73 memory[0x00:0x20] = stack[-3] // @1A78 memory[0x20:0x40] = 0x04 // @1A85 stack[-4] = !((0x01 << 0xe0) & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_1A87: // Incoming call from 0x1531, returns to 0x08CB // Incoming call from 0x0B5D, returns to 0x0B5E // Inputs[1] { @1A8A stack[-1] } 1A87 5B JUMPDEST 1A88 60 PUSH1 0x00 1A8A 81 DUP2 1A8B 80 DUP1 1A8C 60 PUSH1 0x01 1A8E 11 GT 1A8F 61 PUSH2 0x1ae4 1A92 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A88 stack[0] = 0x00 // @1A8A stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1ae4, if 0x01 > stack[-1] label_1A93: // Incoming jump from 0x1A92, if not 0x01 > stack[-1] // Inputs[2] // { // @1A95 storage[0x00] // @1A96 stack[-1] // } 1A93 60 PUSH1 0x00 1A95 54 SLOAD 1A96 81 DUP2 1A97 10 LT 1A98 15 ISZERO 1A99 61 PUSH2 0x1ae4 1A9C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ae4, if !(stack[-1] < storage[0x00]) label_1A9D: // Incoming jump from 0x1A9C, if not !(stack[-1] < storage[0x00]) // Inputs[3] // { // @1A9F stack[-1] // @1AAA memory[0x00:0x40] // @1AAB storage[keccak256(memory[0x00:0x40])] // } 1A9D 60 PUSH1 0x00 1A9F 81 DUP2 1AA0 81 DUP2 1AA1 52 MSTORE 1AA2 60 PUSH1 0x04 1AA4 60 PUSH1 0x20 1AA6 52 MSTORE 1AA7 60 PUSH1 0x40 1AA9 81 DUP2 1AAA 20 SHA3 1AAB 54 SLOAD 1AAC 90 SWAP1 1AAD 60 PUSH1 0x01 1AAF 60 PUSH1 0xe0 1AB1 1B SHL 1AB2 82 DUP3 1AB3 16 AND 1AB4 90 SWAP1 1AB5 03 SUB 1AB6 61 PUSH2 0x1ae2 1AB9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1AA1 memory[0x00:0x20] = stack[-1] // @1AA6 memory[0x20:0x40] = 0x04 // @1AAC stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1ae2, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) label_1ABA: // Incoming jump from 0x1AB9, if not 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // Incoming jump from 0x1ADA // Inputs[1] { @1ABB stack[-1] } 1ABA 5B JUMPDEST 1ABB 80 DUP1 1ABC 60 PUSH1 0x00 1ABE 03 SUB 1ABF 61 PUSH2 0x1adb 1AC2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1adb, if 0x00 - stack[-1] label_1AC3: // Incoming jump from 0x1AC2, if not 0x00 - stack[-1] // Inputs[3] // { // @1AC7 stack[-2] // @1AD5 memory[0x00:0x40] // @1AD6 storage[keccak256(memory[0x00:0x40])] // } 1AC3 50 POP 1AC4 60 PUSH1 0x00 1AC6 19 NOT 1AC7 01 ADD 1AC8 60 PUSH1 0x00 1ACA 81 DUP2 1ACB 81 DUP2 1ACC 52 MSTORE 1ACD 60 PUSH1 0x04 1ACF 60 PUSH1 0x20 1AD1 52 MSTORE 1AD2 60 PUSH1 0x40 1AD4 90 SWAP1 1AD5 20 SHA3 1AD6 54 SLOAD 1AD7 61 PUSH2 0x1aba 1ADA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1AC7 stack[-2] = ~0x00 + stack[-2] // @1ACC memory[0x00:0x20] = ~0x00 + stack[-2] // @1AD1 memory[0x20:0x40] = 0x04 // @1AD6 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x1aba label_1ADB: // Incoming jump from 0x2495, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffff // Incoming return from call to 0x241F at 0x2449 // Incoming return from call to 0x238D at 0x23B6 // Incoming return from call to 0x230B at 0x2349 // Incoming return from call to 0x227D at 0x22AF // Incoming return from call to 0x227D at 0x295E // Incoming jump from 0x1AC2, if 0x00 - stack[-1] // Incoming jump from 0x226C // Incoming return from call to 0x22B0 at 0x22E6 // Inputs[3] // { // @1ADC stack[-5] // @1ADC stack[-1] // @1ADD stack[-4] // } 1ADB 5B JUMPDEST 1ADC 93 SWAP4 1ADD 92 SWAP3 1ADE 50 POP 1ADF 50 POP 1AE0 50 POP 1AE1 56 *JUMP // Stack delta = -4 // Outputs[1] { @1ADC stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1AE2: // Incoming jump from 0x1AB9, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) 1AE2 5B JUMPDEST 1AE3 50 POP // Stack delta = -1 // Block continues label_1AE4: // Incoming jump from 0x1A92, if 0x01 > stack[-1] // Incoming jump from 0x1A9C, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x1AE3 // Inputs[3] // { // @1AE7 memory[0x40:0x60] // @1B10 memory[0x40:0x60] // @1B15 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AE4 5B JUMPDEST 1AE5 60 PUSH1 0x40 1AE7 51 MLOAD 1AE8 7F PUSH32 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 1B09 81 DUP2 1B0A 52 MSTORE 1B0B 60 PUSH1 0x04 1B0D 01 ADD 1B0E 60 PUSH1 0x40 1B10 51 MLOAD 1B11 80 DUP1 1B12 91 SWAP2 1B13 03 SUB 1B14 90 SWAP1 1B15 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B0A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 // @1B15 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B16: // Incoming call from 0x0E32, returns to 0x0E33 // Incoming call from 0x1F94, returns to 0x1F95 // Incoming call from 0x1101, returns to 0x1102 // Inputs[1] { @1B19 storage[0x0b] } 1B16 5B JUMPDEST 1B17 60 PUSH1 0x0b 1B19 54 SLOAD 1B1A 60 PUSH1 0x01 1B1C 60 PUSH1 0xa0 1B1E 1B SHL 1B1F 90 SWAP1 1B20 04 DIV 1B21 60 PUSH1 0xff 1B23 16 AND 1B24 15 ISZERO 1B25 61 PUSH2 0x14cb 1B28 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14cb, if !(0xff & storage[0x0b] / (0x01 << 0xa0)) label_1B29: // Incoming jump from 0x1B28, if not !(0xff & storage[0x0b] / (0x01 << 0xa0)) // Inputs[1] { @1B2B memory[0x40:0x60] } 1B29 60 PUSH1 0x40 1B2B 51 MLOAD 1B2C 62 PUSH3 0x461bcd 1B30 60 PUSH1 0xe5 1B32 1B SHL 1B33 81 DUP2 1B34 52 MSTORE 1B35 60 PUSH1 0x20 1B37 60 PUSH1 0x04 1B39 82 DUP3 1B3A 01 ADD 1B3B 52 MSTORE 1B3C 60 PUSH1 0x10 1B3E 60 PUSH1 0x24 1B40 82 DUP3 1B41 01 ADD 1B42 52 MSTORE 1B43 7F PUSH32 0x5061757361626c653a2070617573656400000000000000000000000000000000 1B64 60 PUSH1 0x44 1B66 82 DUP3 1B67 01 ADD 1B68 52 MSTORE 1B69 60 PUSH1 0x64 1B6B 01 ADD 1B6C 61 PUSH2 0x0e86 1B6F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1B34 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B3B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B42 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1B68 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5061757361626c653a2070617573656400000000000000000000000000000000 // @1B6B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1B70: // Incoming call from 0x11FB, returns to 0x11FC // Incoming call from 0x0F51, returns to 0x0F52 // Inputs[1] { @1B73 stack[-2] } 1B70 5B JUMPDEST 1B71 60 PUSH1 0x00 1B73 82 DUP3 1B74 11 GT 1B75 61 PUSH2 0x1bc0 1B78 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1bc0, if stack[-2] > 0x00 label_1B79: // Incoming jump from 0x1B78, if not stack[-2] > 0x00 // Inputs[1] { @1B7B memory[0x40:0x60] } 1B79 60 PUSH1 0x40 1B7B 51 MLOAD 1B7C 62 PUSH3 0x461bcd 1B80 60 PUSH1 0xe5 1B82 1B SHL 1B83 81 DUP2 1B84 52 MSTORE 1B85 60 PUSH1 0x20 1B87 60 PUSH1 0x04 1B89 82 DUP3 1B8A 01 ADD 1B8B 52 MSTORE 1B8C 60 PUSH1 0x1a 1B8E 60 PUSH1 0x24 1B90 82 DUP3 1B91 01 ADD 1B92 52 MSTORE 1B93 7F PUSH32 0x4d696e7420616d6f756e742063616e6e6f74206265207a65726f000000000000 1BB4 60 PUSH1 0x44 1BB6 82 DUP3 1BB7 01 ADD 1BB8 52 MSTORE 1BB9 60 PUSH1 0x64 1BBB 01 ADD 1BBC 61 PUSH2 0x0e86 1BBF 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1B84 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1B8B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B92 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1a // @1BB8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d696e7420616d6f756e742063616e6e6f74206265207a65726f000000000000 // @1BBB stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1BC0: // Incoming jump from 0x1B78, if stack[-2] > 0x00 // Inputs[3] // { // @1BC3 storage[0x01] // @1BC6 storage[0x00] // @1BCB stack[-2] // } 1BC0 5B JUMPDEST 1BC1 60 PUSH1 0x01 1BC3 54 SLOAD 1BC4 60 PUSH1 0x00 1BC6 54 SLOAD 1BC7 61 PUSH2 0x1770 1BCA 91 SWAP2 1BCB 84 DUP5 1BCC 91 SWAP2 1BCD 03 SUB 1BCE 60 PUSH1 0x00 1BD0 19 NOT 1BD1 01 ADD 1BD2 61 PUSH2 0x1bdb 1BD5 91 SWAP2 1BD6 90 SWAP1 1BD7 61 PUSH2 0x27be 1BDA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BCA stack[0] = 0x1770 // @1BD5 stack[1] = 0x1bdb // @1BD6 stack[2] = stack[-2] // @1BD6 stack[3] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with call to 0x27be, returns to 0x1BDB label_1BDB: // Incoming return from call to 0x27BE at 0x1BDA // Inputs[2] // { // @1BDC stack[-1] // @1BDC stack[-2] // } 1BDB 5B JUMPDEST 1BDC 11 GT 1BDD 15 ISZERO 1BDE 61 PUSH2 0x1c29 1BE1 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1c29, if !(stack[-1] > stack[-2]) label_1BE2: // Incoming jump from 0x1BE1, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1BE4 memory[0x40:0x60] } 1BE2 60 PUSH1 0x40 1BE4 51 MLOAD 1BE5 62 PUSH3 0x461bcd 1BE9 60 PUSH1 0xe5 1BEB 1B SHL 1BEC 81 DUP2 1BED 52 MSTORE 1BEE 60 PUSH1 0x20 1BF0 60 PUSH1 0x04 1BF2 82 DUP3 1BF3 01 ADD 1BF4 52 MSTORE 1BF5 60 PUSH1 0x0e 1BF7 60 PUSH1 0x24 1BF9 82 DUP3 1BFA 01 ADD 1BFB 52 MSTORE 1BFC 7F PUSH32 0x4d4158535550504c59206f766572000000000000000000000000000000000000 1C1D 60 PUSH1 0x44 1C1F 82 DUP3 1C20 01 ADD 1C21 52 MSTORE 1C22 60 PUSH1 0x64 1C24 01 ADD 1C25 61 PUSH2 0x0e86 1C28 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1BED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1BF4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1BFB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @1C21 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d4158535550504c59206f766572000000000000000000000000000000000000 // @1C24 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1C29: // Incoming jump from 0x1BE1, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1C2A stack[-1] // @1C2B msg.value // } 1C29 5B JUMPDEST 1C2A 80 DUP1 1C2B 34 CALLVALUE 1C2C 10 LT 1C2D 15 ISZERO 1C2E 61 PUSH2 0x150f 1C31 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x150f, if !(msg.value < stack[-1]) label_1C32: // Incoming jump from 0x1C31, if not !(msg.value < stack[-1]) // Inputs[1] { @1C34 memory[0x40:0x60] } 1C32 60 PUSH1 0x40 1C34 51 MLOAD 1C35 62 PUSH3 0x461bcd 1C39 60 PUSH1 0xe5 1C3B 1B SHL 1C3C 81 DUP2 1C3D 52 MSTORE 1C3E 60 PUSH1 0x20 1C40 60 PUSH1 0x04 1C42 82 DUP3 1C43 01 ADD 1C44 52 MSTORE 1C45 60 PUSH1 0x10 1C47 60 PUSH1 0x24 1C49 82 DUP3 1C4A 01 ADD 1C4B 52 MSTORE 1C4C 7F PUSH32 0x4e6f7420656e6f7567682066756e647300000000000000000000000000000000 1C6D 60 PUSH1 0x44 1C6F 82 DUP3 1C70 01 ADD 1C71 52 MSTORE 1C72 60 PUSH1 0x64 1C74 01 ADD 1C75 61 PUSH2 0x0e86 1C78 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1C3D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1C44 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1C4B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x10 // @1C71 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f7420656e6f7567682066756e647300000000000000000000000000000000 // @1C74 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1C79: // Incoming call from 0x0FFE, returns to 0x0FFF // Incoming call from 0x150E, returns to 0x150F // Incoming call from 0x1429, returns to 0x142A // Inputs[2] // { // @1C7D storage[0x00] // @1C7F stack[-1] // } 1C79 5B JUMPDEST 1C7A 60 PUSH1 0x00 1C7C 80 DUP1 1C7D 54 SLOAD 1C7E 90 SWAP1 1C7F 82 DUP3 1C80 90 SWAP1 1C81 03 SUB 1C82 61 PUSH2 0x1cb7 1C85 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C7E stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1cb7, if 0x00 - stack[-1] label_1C86: // Incoming jump from 0x1C85, if not 0x00 - stack[-1] // Inputs[3] // { // @1C88 memory[0x40:0x60] // @1CB1 memory[0x40:0x60] // @1CB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1C86 60 PUSH1 0x40 1C88 51 MLOAD 1C89 7F PUSH32 0xb562e8dd00000000000000000000000000000000000000000000000000000000 1CAA 81 DUP2 1CAB 52 MSTORE 1CAC 60 PUSH1 0x04 1CAE 01 ADD 1CAF 60 PUSH1 0x40 1CB1 51 MLOAD 1CB2 80 DUP1 1CB3 91 SWAP2 1CB4 03 SUB 1CB5 90 SWAP1 1CB6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1CAB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000 // @1CB6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1CB7: // Incoming jump from 0x1C85, if 0x00 - stack[-1] // Inputs[8] // { // @1CC0 stack[-3] // @1CD2 memory[0x00:0x40] // @1CD4 storage[keccak256(memory[0x00:0x40])] // @1CDF stack[-2] // @1CE4 stack[-1] // @1CED memory[0x00:0x40] // @1CF5 block.timestamp // @1D29 memory[0x00:0x00] // } 1CB7 5B JUMPDEST 1CB8 60 PUSH1 0x01 1CBA 60 PUSH1 0x01 1CBC 60 PUSH1 0xa0 1CBE 1B SHL 1CBF 03 SUB 1CC0 83 DUP4 1CC1 16 AND 1CC2 60 PUSH1 0x00 1CC4 81 DUP2 1CC5 81 DUP2 1CC6 52 MSTORE 1CC7 60 PUSH1 0x05 1CC9 60 PUSH1 0x20 1CCB 90 SWAP1 1CCC 81 DUP2 1CCD 52 MSTORE 1CCE 60 PUSH1 0x40 1CD0 80 DUP1 1CD1 83 DUP4 1CD2 20 SHA3 1CD3 80 DUP1 1CD4 54 SLOAD 1CD5 68 PUSH9 0x010000000000000001 1CDF 88 DUP9 1CE0 02 MUL 1CE1 01 ADD 1CE2 90 SWAP1 1CE3 55 SSTORE 1CE4 84 DUP5 1CE5 83 DUP4 1CE6 52 MSTORE 1CE7 60 PUSH1 0x04 1CE9 90 SWAP1 1CEA 91 SWAP2 1CEB 52 MSTORE 1CEC 81 DUP2 1CED 20 SHA3 1CEE 60 PUSH1 0x01 1CF0 85 DUP6 1CF1 14 EQ 1CF2 60 PUSH1 0xe1 1CF4 1B SHL 1CF5 42 TIMESTAMP 1CF6 60 PUSH1 0xa0 1CF8 1B SHL 1CF9 17 OR 1CFA 83 DUP4 1CFB 17 OR 1CFC 90 SWAP1 1CFD 55 SSTORE 1CFE 82 DUP3 1CFF 84 DUP5 1D00 01 ADD 1D01 90 SWAP1 1D02 83 DUP4 1D03 90 SWAP1 1D04 83 DUP4 1D05 90 SWAP1 1D06 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1D27 81 DUP2 1D28 80 DUP1 1D29 A4 LOG4 1D2A 60 PUSH1 0x01 1D2C 83 DUP4 1D2D 01 ADD 1D2E 5B JUMPDEST 1D2F 81 DUP2 1D30 81 DUP2 1D31 14 EQ 1D32 61 PUSH2 0x1d66 1D35 57 *JUMPI // Stack delta = +3 // Outputs[10] // { // @1CC1 stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1CC6 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1CCD memory[0x20:0x40] = 0x05 // @1CE3 storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @1CE6 memory[0x00:0x20] = stack[-1] // @1CEB memory[0x20:0x40] = 0x04 // @1CFD storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (block.timestamp << 0xa0) | ((stack[-2] == 0x01) << 0xe1) // @1D01 stack[1] = stack[-2] + stack[-1] // @1D29 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-1]]); // @1D2D stack[2] = stack[-1] + 0x01 // } // Block ends with conditional jump to 0x1d66, if stack[-1] + 0x01 == stack[-2] + stack[-1] label_1D36: // Incoming jump from 0x1D35, if not stack[-1] + 0x01 == stack[-2] + stack[-1] // Incoming jump from 0x1D35, if not stack[-1] == stack[-2] // Inputs[3] // { // @1D36 stack[-1] // @1D37 stack[-3] // @1D5E memory[0x00:0x00] // } 1D36 80 DUP1 1D37 83 DUP4 1D38 60 PUSH1 0x00 1D3A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1D5B 60 PUSH1 0x00 1D5D 80 DUP1 1D5E A4 LOG4 1D5F 60 PUSH1 0x01 1D61 01 ADD 1D62 61 PUSH2 0x1d2e 1D65 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1D5E log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3], stack[-1]]); // @1D61 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1d2e label_1D66: // Incoming jump from 0x1D35, if stack[-1] + 0x01 == stack[-2] + stack[-1] // Incoming jump from 0x1D35, if stack[-1] == stack[-2] // Inputs[1] { @1D68 stack[-3] } 1D66 5B JUMPDEST 1D67 50 POP 1D68 81 DUP2 1D69 60 PUSH1 0x00 1D6B 03 SUB 1D6C 61 PUSH2 0x1da1 1D6F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1da1, if 0x00 - stack[-3] label_1D70: // Incoming jump from 0x1D6F, if not 0x00 - stack[-3] // Inputs[3] // { // @1D72 memory[0x40:0x60] // @1D9B memory[0x40:0x60] // @1DA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1D70 60 PUSH1 0x40 1D72 51 MLOAD 1D73 7F PUSH32 0x2e07630000000000000000000000000000000000000000000000000000000000 1D94 81 DUP2 1D95 52 MSTORE 1D96 60 PUSH1 0x04 1D98 01 ADD 1D99 60 PUSH1 0x40 1D9B 51 MLOAD 1D9C 80 DUP1 1D9D 91 SWAP2 1D9E 03 SUB 1D9F 90 SWAP1 1DA0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D95 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000 // @1DA0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1DA1: // Incoming jump from 0x1D6F, if 0x00 - stack[-3] // Inputs[2] // { // @1DA4 stack[-1] // @1DA9 stack[-6] // } 1DA1 5B JUMPDEST 1DA2 60 PUSH1 0x00 1DA4 55 SSTORE 1DA5 50 POP 1DA6 50 POP 1DA7 50 POP 1DA8 50 POP 1DA9 56 *JUMP // Stack delta = -6 // Outputs[1] { @1DA4 storage[0x00] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1DAA: // Incoming jump from 0x1334 // Inputs[3] // { // @1DAD stack[-2] // @1DB1 stack[-3] // @1DB2 stack[-1] // } 1DAA 5B JUMPDEST 1DAB 60 PUSH1 0x00 1DAD 82 DUP3 1DAE 61 PUSH2 0x1db7 1DB1 85 DUP6 1DB2 84 DUP5 1DB3 61 PUSH2 0x2158 1DB6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1DAB stack[0] = 0x00 // @1DAD stack[1] = stack[-2] // @1DAE stack[2] = 0x1db7 // @1DB1 stack[3] = stack[-3] // @1DB2 stack[4] = stack[-1] // } // Block ends with call to 0x2158, returns to 0x1DB7 label_1DB7: // Incoming return from call to 0x2158 at 0x1DB6 // Inputs[4] // { // @1DB8 stack[-1] // @1DB8 stack[-2] // @1DB9 stack[-7] // @1DBA stack[-6] // } 1DB7 5B JUMPDEST 1DB8 14 EQ 1DB9 94 SWAP5 1DBA 93 SWAP4 1DBB 50 POP 1DBC 50 POP 1DBD 50 POP 1DBE 50 POP 1DBF 56 *JUMP // Stack delta = -6 // Outputs[1] { @1DB9 stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1DC0: // Incoming call from 0x14CA, returns to 0x14CB // Inputs[3] // { // @1DC1 stack[-1] // @1DC2 address(this).balance // @1DC2 address(this) // } 1DC0 5B JUMPDEST 1DC1 80 DUP1 1DC2 47 SELFBALANCE 1DC3 10 LT 1DC4 15 ISZERO 1DC5 61 PUSH2 0x1e10 1DC8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e10, if !(address(this).balance < stack[-1]) label_1DC9: // Incoming jump from 0x1DC8, if not !(address(this).balance < stack[-1]) // Inputs[1] { @1DCB memory[0x40:0x60] } 1DC9 60 PUSH1 0x40 1DCB 51 MLOAD 1DCC 62 PUSH3 0x461bcd 1DD0 60 PUSH1 0xe5 1DD2 1B SHL 1DD3 81 DUP2 1DD4 52 MSTORE 1DD5 60 PUSH1 0x20 1DD7 60 PUSH1 0x04 1DD9 82 DUP3 1DDA 01 ADD 1DDB 52 MSTORE 1DDC 60 PUSH1 0x1d 1DDE 60 PUSH1 0x24 1DE0 82 DUP3 1DE1 01 ADD 1DE2 52 MSTORE 1DE3 7F PUSH32 0x416464726573733a20696e73756666696369656e742062616c616e6365000000 1E04 60 PUSH1 0x44 1E06 82 DUP3 1E07 01 ADD 1E08 52 MSTORE 1E09 60 PUSH1 0x64 1E0B 01 ADD 1E0C 61 PUSH2 0x0e86 1E0F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1DD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1DDB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1DE2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @1E08 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573733a20696e73756666696369656e742062616c616e6365000000 // @1E0B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1E10: // Incoming jump from 0x1DC8, if !(address(this).balance < stack[-1]) // Inputs[8] // { // @1E13 stack[-2] // @1E1D stack[-1] // @1E20 memory[0x40:0x60] // @1E25 memory[0x40:0x60] // @1E2C msg.gas // @1E2D memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1E2D address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1E32 returndata.length // } 1E10 5B JUMPDEST 1E11 60 PUSH1 0x00 1E13 82 DUP3 1E14 60 PUSH1 0x01 1E16 60 PUSH1 0x01 1E18 60 PUSH1 0xa0 1E1A 1B SHL 1E1B 03 SUB 1E1C 16 AND 1E1D 82 DUP3 1E1E 60 PUSH1 0x40 1E20 51 MLOAD 1E21 60 PUSH1 0x00 1E23 60 PUSH1 0x40 1E25 51 MLOAD 1E26 80 DUP1 1E27 83 DUP4 1E28 03 SUB 1E29 81 DUP2 1E2A 85 DUP6 1E2B 87 DUP8 1E2C 5A GAS 1E2D F1 CALL 1E2E 92 SWAP3 1E2F 50 POP 1E30 50 POP 1E31 50 POP 1E32 3D RETURNDATASIZE 1E33 80 DUP1 1E34 60 PUSH1 0x00 1E36 81 DUP2 1E37 14 EQ 1E38 61 PUSH2 0x1e5d 1E3B 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @1E11 stack[0] = 0x00 // @1E2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1E2E stack[1] = address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1E32 stack[2] = returndata.length // @1E33 stack[3] = returndata.length // } // Block ends with conditional jump to 0x1e5d, if returndata.length == 0x00 label_1E3C: // Incoming jump from 0x1E3B, if not returndata.length == 0x00 // Inputs[6] // { // @1E3E memory[0x40:0x60] // @1E3F stack[-2] // @1E46 returndata.length // @1E4E returndata.length // @1E51 returndata.length // @1E58 returndata[0x00:0x00 + returndata.length] // } 1E3C 60 PUSH1 0x40 1E3E 51 MLOAD 1E3F 91 SWAP2 1E40 50 POP 1E41 60 PUSH1 0x1f 1E43 19 NOT 1E44 60 PUSH1 0x3f 1E46 3D RETURNDATASIZE 1E47 01 ADD 1E48 16 AND 1E49 82 DUP3 1E4A 01 ADD 1E4B 60 PUSH1 0x40 1E4D 52 MSTORE 1E4E 3D RETURNDATASIZE 1E4F 82 DUP3 1E50 52 MSTORE 1E51 3D RETURNDATASIZE 1E52 60 PUSH1 0x00 1E54 60 PUSH1 0x20 1E56 84 DUP5 1E57 01 ADD 1E58 3E RETURNDATACOPY 1E59 61 PUSH2 0x1e62 1E5C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1E3F stack[-2] = memory[0x40:0x60] // @1E4D memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1E50 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1E58 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1e62 label_1E5D: // Incoming jump from 0x1E3B, if returndata.length == 0x00 // Inputs[3] // { // @1E60 stack[-2] // @1E65 stack[-3] // @1E65 stack[-4] // } 1E5D 5B JUMPDEST 1E5E 60 PUSH1 0x60 1E60 91 SWAP2 1E61 50 POP 1E62 5B JUMPDEST 1E63 50 POP 1E64 50 POP 1E65 90 SWAP1 1E66 50 POP 1E67 80 DUP1 1E68 61 PUSH2 0x14f8 1E6B 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1E65 stack[-4] = stack[-3] } // Block ends with conditional jump to 0x14f8, if stack[-3] label_1E6C: // Incoming jump from 0x1E6B, if not stack[-3] // Incoming jump from 0x1E6B, if not stack[-3] // Inputs[1] { @1E6E memory[0x40:0x60] } 1E6C 60 PUSH1 0x40 1E6E 51 MLOAD 1E6F 62 PUSH3 0x461bcd 1E73 60 PUSH1 0xe5 1E75 1B SHL 1E76 81 DUP2 1E77 52 MSTORE 1E78 60 PUSH1 0x20 1E7A 60 PUSH1 0x04 1E7C 82 DUP3 1E7D 01 ADD 1E7E 52 MSTORE 1E7F 60 PUSH1 0x3a 1E81 60 PUSH1 0x24 1E83 82 DUP3 1E84 01 ADD 1E85 52 MSTORE 1E86 7F PUSH32 0x416464726573733a20756e61626c6520746f2073656e642076616c75652c2072 1EA7 60 PUSH1 0x44 1EA9 82 DUP3 1EAA 01 ADD 1EAB 52 MSTORE 1EAC 7F PUSH32 0x6563697069656e74206d61792068617665207265766572746564000000000000 1ECD 60 PUSH1 0x64 1ECF 82 DUP3 1ED0 01 ADD 1ED1 52 MSTORE 1ED2 60 PUSH1 0x84 1ED4 01 ADD 1ED5 61 PUSH2 0x0e86 1ED8 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1E77 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1E7E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1E85 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x3a // @1EAB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416464726573733a20756e61626c6520746f2073656e642076616c75652c2072 // @1ED1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6563697069656e74206d61792068617665207265766572746564000000000000 // @1ED4 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_1ED9: // Incoming call from 0x14DC, returns to 0x14CB 1ED9 5B JUMPDEST 1EDA 61 PUSH2 0x1ee1 1EDD 61 PUSH2 0x21a5 1EE0 56 *JUMP // Stack delta = +1 // Outputs[1] { @1EDA stack[0] = 0x1ee1 } // Block ends with call to 0x21a5, returns to 0x1EE1 label_1EE1: // Incoming return from call to 0x21A5 at 0x1EE0 // Inputs[6] // { // @1EE5 storage[0x0b] // @1F10 msg.sender // @1F14 memory[0x40:0x60] // @1F27 memory[0x40:0x60] // @1F2C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1F2D stack[-1] // } 1EE1 5B JUMPDEST 1EE2 60 PUSH1 0x0b 1EE4 80 DUP1 1EE5 54 SLOAD 1EE6 60 PUSH1 0xff 1EE8 60 PUSH1 0xa0 1EEA 1B SHL 1EEB 19 NOT 1EEC 16 AND 1EED 90 SWAP1 1EEE 55 SSTORE 1EEF 7F PUSH32 0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa 1F10 33 CALLER 1F11 5B JUMPDEST 1F12 60 PUSH1 0x40 1F14 51 MLOAD 1F15 60 PUSH1 0x01 1F17 60 PUSH1 0x01 1F19 60 PUSH1 0xa0 1F1B 1B SHL 1F1C 03 SUB 1F1D 90 SWAP1 1F1E 91 SWAP2 1F1F 16 AND 1F20 81 DUP2 1F21 52 MSTORE 1F22 60 PUSH1 0x20 1F24 01 ADD 1F25 60 PUSH1 0x40 1F27 51 MLOAD 1F28 80 DUP1 1F29 91 SWAP2 1F2A 03 SUB 1F2B 90 SWAP1 1F2C A1 LOG1 1F2D 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1EEE storage[0x0b] = ~(0xff << 0xa0) & storage[0x0b] // @1F21 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender & (0x01 << 0xa0) - 0x01 // @1F2C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa]); // } // Block ends with unconditional jump to stack[-1] label_1F2E: // Incoming call from 0x180F, returns to 0x0939 // Incoming call from 0x161D, returns to 0x14CB // Inputs[5] // { // @1F32 storage[0x0b] // @1F3B stack[-1] // @1F5D memory[0x40:0x60] // @1F89 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1F8C stack[-2] // } 1F2E 5B JUMPDEST 1F2F 60 PUSH1 0x0b 1F31 80 DUP1 1F32 54 SLOAD 1F33 60 PUSH1 0x01 1F35 60 PUSH1 0x01 1F37 60 PUSH1 0xa0 1F39 1B SHL 1F3A 03 SUB 1F3B 83 DUP4 1F3C 81 DUP2 1F3D 16 AND 1F3E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F53 19 NOT 1F54 83 DUP4 1F55 16 AND 1F56 81 DUP2 1F57 17 OR 1F58 90 SWAP1 1F59 93 SWAP4 1F5A 55 SSTORE 1F5B 60 PUSH1 0x40 1F5D 51 MLOAD 1F5E 91 SWAP2 1F5F 16 AND 1F60 91 SWAP2 1F61 90 SWAP1 1F62 82 DUP3 1F63 90 SWAP1 1F64 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1F85 90 SWAP1 1F86 60 PUSH1 0x00 1F88 90 SWAP1 1F89 A3 LOG3 1F8A 50 POP 1F8B 50 POP 1F8C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1F5A storage[0x0b] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x0b] & ~0xffffffffffffffffffffffffffffffffffffffff) // @1F89 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_1F8D: // Incoming call from 0x163A, returns to 0x14CB 1F8D 5B JUMPDEST 1F8E 61 PUSH2 0x1f95 1F91 61 PUSH2 0x1b16 1F94 56 *JUMP // Stack delta = +1 // Outputs[1] { @1F8E stack[0] = 0x1f95 } // Block ends with call to 0x1b16, returns to 0x1F95 label_1F95: // Incoming return from call to 0x1B16 at 0x1F94 // Inputs[2] // { // @1F99 storage[0x0b] // @1FCD msg.sender // } 1F95 5B JUMPDEST 1F96 60 PUSH1 0x0b 1F98 80 DUP1 1F99 54 SLOAD 1F9A 60 PUSH1 0xff 1F9C 60 PUSH1 0xa0 1F9E 1B SHL 1F9F 19 NOT 1FA0 16 AND 1FA1 60 PUSH1 0x01 1FA3 60 PUSH1 0xa0 1FA5 1B SHL 1FA6 17 OR 1FA7 90 SWAP1 1FA8 55 SSTORE 1FA9 7F PUSH32 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 1FCA 61 PUSH2 0x1f11 1FCD 33 CALLER 1FCE 90 SWAP1 1FCF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1FA8 storage[0x0b] = (0x01 << 0xa0) | (~(0xff << 0xa0) & storage[0x0b]) // @1FA9 stack[0] = 0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258 // @1FCE stack[1] = msg.sender // } // Block ends with unconditional jump to 0x1f11 label_1FD0: // Incoming jump from 0x16F7 // Inputs[6] // { // @1FD3 memory[0x40:0x60] // @1FE9 stack[-3] // @1FF6 msg.sender // @1FF8 stack[-4] // @1FFA stack[-2] // @1FFC stack[-1] // } 1FD0 5B JUMPDEST 1FD1 60 PUSH1 0x40 1FD3 51 MLOAD 1FD4 63 PUSH4 0x0a85bd01 1FD9 60 PUSH1 0xe1 1FDB 1B SHL 1FDC 81 DUP2 1FDD 52 MSTORE 1FDE 60 PUSH1 0x00 1FE0 90 SWAP1 1FE1 60 PUSH1 0x01 1FE3 60 PUSH1 0x01 1FE5 60 PUSH1 0xa0 1FE7 1B SHL 1FE8 03 SUB 1FE9 85 DUP6 1FEA 16 AND 1FEB 90 SWAP1 1FEC 63 PUSH4 0x150b7a02 1FF1 90 SWAP1 1FF2 61 PUSH2 0x2005 1FF5 90 SWAP1 1FF6 33 CALLER 1FF7 90 SWAP1 1FF8 89 DUP10 1FF9 90 SWAP1 1FFA 88 DUP9 1FFB 90 SWAP1 1FFC 88 DUP9 1FFD 90 SWAP1 1FFE 60 PUSH1 0x04 2000 01 ADD 2001 61 PUSH2 0x2906 2004 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1FDD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1FE0 stack[0] = 0x00 // @1FEB stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1FF1 stack[2] = 0x150b7a02 // @1FF5 stack[3] = 0x2005 // @1FF7 stack[4] = msg.sender // @1FF9 stack[5] = stack[-4] // @1FFB stack[6] = stack[-2] // @1FFD stack[7] = stack[-1] // @2000 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2906, returns to 0x2005 label_2005: // Incoming return from call to 0x2906 at 0x2004 // Inputs[6] // { // @200A memory[0x40:0x60] // @200C stack[-1] // @2011 stack[-3] // @2012 msg.gas // @2013 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @2013 address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } 2005 5B JUMPDEST 2006 60 PUSH1 0x20 2008 60 PUSH1 0x40 200A 51 MLOAD 200B 80 DUP1 200C 83 DUP4 200D 03 SUB 200E 81 DUP2 200F 60 PUSH1 0x00 2011 87 DUP8 2012 5A GAS 2013 F1 CALL 2014 92 SWAP3 2015 50 POP 2016 50 POP 2017 50 POP 2018 80 DUP1 2019 15 ISZERO 201A 61 PUSH2 0x2040 201D 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2013 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @2014 stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x2040, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_201E: // Incoming jump from 0x201D, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @2022 memory[0x40:0x60] // @2025 returndata.length // } 201E 50 POP 201F 60 PUSH1 0x40 2021 80 DUP1 2022 51 MLOAD 2023 60 PUSH1 0x1f 2025 3D RETURNDATASIZE 2026 90 SWAP1 2027 81 DUP2 2028 01 ADD 2029 60 PUSH1 0x1f 202B 19 NOT 202C 16 AND 202D 82 DUP3 202E 01 ADD 202F 90 SWAP1 2030 92 SWAP3 2031 52 MSTORE 2032 61 PUSH2 0x203d 2035 91 SWAP2 2036 81 DUP2 2037 01 ADD 2038 90 SWAP1 2039 61 PUSH2 0x2942 203C 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2031 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @2035 stack[-1] = 0x203d // @2038 stack[1] = memory[0x40:0x60] // @2038 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2942 203D 5B JUMPDEST 203E 60 PUSH1 0x01 label_2040: // Incoming jump from 0x201D, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @2044 stack[-1] } 2040 5B JUMPDEST 2041 61 PUSH2 0x209e 2044 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x209e, if stack[-1] label_2045: // Incoming jump from 0x2044, if not stack[-1] // Inputs[1] { @2045 returndata.length } 2045 3D RETURNDATASIZE 2046 80 DUP1 2047 80 DUP1 2048 15 ISZERO 2049 61 PUSH2 0x206e 204C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2045 stack[0] = returndata.length // @2046 stack[1] = returndata.length // } // Block ends with conditional jump to 0x206e, if !returndata.length label_204D: // Incoming jump from 0x204C, if not !returndata.length // Inputs[6] // { // @204F memory[0x40:0x60] // @2050 stack[-2] // @2057 returndata.length // @205F returndata.length // @2062 returndata.length // @2069 returndata[0x00:0x00 + returndata.length] // } 204D 60 PUSH1 0x40 204F 51 MLOAD 2050 91 SWAP2 2051 50 POP 2052 60 PUSH1 0x1f 2054 19 NOT 2055 60 PUSH1 0x3f 2057 3D RETURNDATASIZE 2058 01 ADD 2059 16 AND 205A 82 DUP3 205B 01 ADD 205C 60 PUSH1 0x40 205E 52 MSTORE 205F 3D RETURNDATASIZE 2060 82 DUP3 2061 52 MSTORE 2062 3D RETURNDATASIZE 2063 60 PUSH1 0x00 2065 60 PUSH1 0x20 2067 84 DUP5 2068 01 ADD 2069 3E RETURNDATACOPY 206A 61 PUSH2 0x2073 206D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2050 stack[-2] = memory[0x40:0x60] // @205E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @2061 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @2069 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x2073 label_206E: // Incoming jump from 0x204C, if !returndata.length // Inputs[2] // { // @2071 stack[-2] // @2076 memory[0x60:0x80] // } 206E 5B JUMPDEST 206F 60 PUSH1 0x60 2071 91 SWAP2 2072 50 POP 2073 5B JUMPDEST 2074 50 POP 2075 80 DUP1 2076 51 MLOAD 2077 60 PUSH1 0x00 2079 03 SUB 207A 61 PUSH2 0x2096 207D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2071 stack[-2] = 0x60 } // Block ends with conditional jump to 0x2096, if 0x00 - memory[0x60:0x80] label_207E: // Incoming jump from 0x207D, if not 0x00 - memory[0x60:0x80] // Incoming jump from 0x207D, if not 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @2080 memory[0x40:0x60] // @2090 memory[0x40:0x60] // @2095 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 207E 60 PUSH1 0x40 2080 51 MLOAD 2081 63 PUSH4 0x68d2bf6b 2086 60 PUSH1 0xe1 2088 1B SHL 2089 81 DUP2 208A 52 MSTORE 208B 60 PUSH1 0x04 208D 01 ADD 208E 60 PUSH1 0x40 2090 51 MLOAD 2091 80 DUP1 2092 91 SWAP2 2093 03 SUB 2094 90 SWAP1 2095 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @208A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @2095 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2096: // Incoming jump from 0x207D, if 0x00 - memory[0x60:0x80] // Incoming jump from 0x207D, if 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @2097 stack[-1] // @2098 memory[stack[-1]:stack[-1] + 0x20] // @209D memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 2096 5B JUMPDEST 2097 80 DUP1 2098 51 MLOAD 2099 81 DUP2 209A 60 PUSH1 0x20 209C 01 ADD 209D FD *REVERT // Stack delta = +0 // Outputs[1] { @209D revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_209E: // Incoming jump from 0x2044, if stack[-1] // Inputs[2] // { // @20A8 stack[-1] // @20B2 stack[-2] // } 209E 5B JUMPDEST 209F 60 PUSH1 0x01 20A1 60 PUSH1 0x01 20A3 60 PUSH1 0xe0 20A5 1B SHL 20A6 03 SUB 20A7 19 NOT 20A8 16 AND 20A9 63 PUSH4 0x0a85bd01 20AE 60 PUSH1 0xe1 20B0 1B SHL 20B1 14 EQ 20B2 90 SWAP1 20B3 50 POP // Stack delta = -1 // Outputs[1] { @20B2 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_20B4: // Incoming return from call to 0x254A at 0x2608 // Incoming jump from 0x20B3 // Inputs[3] // { // @20B5 stack[-6] // @20B5 stack[-1] // @20B6 stack[-5] // } 20B4 5B JUMPDEST 20B5 94 SWAP5 20B6 93 SWAP4 20B7 50 POP 20B8 50 POP 20B9 50 POP 20BA 50 POP 20BB 56 *JUMP // Stack delta = -5 // Outputs[1] { @20B5 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_20BC: // Incoming jump from 0x1725 // Inputs[1] { @20C2 stack[-1] } 20BC 5B JUMPDEST 20BD 60 PUSH1 0x60 20BF 61 PUSH2 0x20c7 20C2 82 DUP3 20C3 61 PUSH2 0x1a52 20C6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20BD stack[0] = 0x60 // @20BF stack[1] = 0x20c7 // @20C2 stack[2] = stack[-1] // } // Block ends with call to 0x1a52, returns to 0x20C7 label_20C7: // Incoming return from call to 0x1A52 at 0x20C6 // Inputs[1] { @20CB stack[-1] } 20C7 5B JUMPDEST 20C8 61 PUSH2 0x20fd 20CB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x20fd, if stack[-1] label_20CC: // Incoming jump from 0x20CB, if not stack[-1] // Inputs[3] // { // @20CE memory[0x40:0x60] // @20F7 memory[0x40:0x60] // @20FC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 20CC 60 PUSH1 0x40 20CE 51 MLOAD 20CF 7F PUSH32 0xa14c4b5000000000000000000000000000000000000000000000000000000000 20F0 81 DUP2 20F1 52 MSTORE 20F2 60 PUSH1 0x04 20F4 01 ADD 20F5 60 PUSH1 0x40 20F7 51 MLOAD 20F8 80 DUP1 20F9 91 SWAP2 20FA 03 SUB 20FB 90 SWAP1 20FC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @20F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa14c4b5000000000000000000000000000000000000000000000000000000000 // @20FC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_20FD: // Incoming jump from 0x20CB, if stack[-1] 20FD 5B JUMPDEST 20FE 60 PUSH1 0x00 2100 61 PUSH2 0x2107 2103 61 PUSH2 0x21fe 2106 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20FE stack[0] = 0x00 // @2100 stack[1] = 0x2107 // } // Block ends with unconditional jump to 0x21fe 2107 5B JUMPDEST 2108 90 SWAP1 2109 50 POP 210A 80 DUP1 210B 51 MLOAD 210C 60 PUSH1 0x00 210E 03 SUB 210F 61 PUSH2 0x2127 2112 57 *JUMPI 2113 60 PUSH1 0x40 2115 51 MLOAD 2116 80 DUP1 2117 60 PUSH1 0x20 2119 01 ADD 211A 60 PUSH1 0x40 211C 52 MSTORE 211D 80 DUP1 211E 60 PUSH1 0x00 2120 81 DUP2 2121 52 MSTORE 2122 50 POP 2123 61 PUSH2 0x1adb 2126 56 *JUMP 2127 5B JUMPDEST 2128 80 DUP1 2129 61 PUSH2 0x2131 212C 84 DUP5 212D 61 PUSH2 0x220d 2130 56 *JUMP 2131 5B JUMPDEST 2132 60 PUSH1 0x40 2134 51 MLOAD 2135 60 PUSH1 0x20 2137 01 ADD 2138 61 PUSH2 0x2142 213B 92 SWAP3 213C 91 SWAP2 213D 90 SWAP1 213E 61 PUSH2 0x28d7 2141 56 *JUMP 2142 5B JUMPDEST 2143 60 PUSH1 0x40 2145 51 MLOAD 2146 60 PUSH1 0x20 2148 81 DUP2 2149 83 DUP4 214A 03 SUB 214B 03 SUB 214C 81 DUP2 214D 52 MSTORE 214E 90 SWAP1 214F 60 PUSH1 0x40 2151 52 MSTORE 2152 93 SWAP4 2153 92 SWAP3 2154 50 POP 2155 50 POP 2156 50 POP 2157 56 *JUMP label_2158: // Incoming call from 0x1DB6, returns to 0x1DB7 // Inputs[3] // { // @215B stack[-1] // @215E stack[-2] // @215F memory[stack[-2]:stack[-2] + 0x20] // } 2158 5B JUMPDEST 2159 60 PUSH1 0x00 215B 81 DUP2 215C 81 DUP2 215D 5B JUMPDEST 215E 84 DUP5 215F 51 MLOAD 2160 81 DUP2 2161 10 LT 2162 15 ISZERO 2163 61 PUSH2 0x219d 2166 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2159 stack[0] = 0x00 // @215B stack[1] = stack[-1] // @215C stack[2] = 0x00 // } // Block ends with conditional jump to 0x219d, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_2167: // Incoming jump from 0x2166, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2166, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[4] // { // @216A stack[-2] // @216B stack[-5] // @216C stack[-1] // @216E memory[stack[-5]:stack[-5] + 0x20] // } 2167 61 PUSH2 0x2189 216A 82 DUP3 216B 86 DUP7 216C 83 DUP4 216D 81 DUP2 216E 51 MLOAD 216F 81 DUP2 2170 10 LT 2171 61 PUSH2 0x217c 2174 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2167 stack[0] = 0x2189 // @216A stack[1] = stack[-2] // @216B stack[2] = stack[-5] // @216C stack[3] = stack[-1] // } // Block ends with conditional call to 0x217c, returns to 0x2189, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_2175: // Incoming jump from 0x2174, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 2175 61 PUSH2 0x217c 2178 61 PUSH2 0x295f 217B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2175 stack[0] = 0x217c } // Block ends with unconditional jump to 0x295f label_217C: // Incoming call from 0x2174, returns to 0x2189, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @217F stack[-1] // @2183 stack[-2] // @2184 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 217C 5B JUMPDEST 217D 60 PUSH1 0x20 217F 02 MUL 2180 60 PUSH1 0x20 2182 01 ADD 2183 01 ADD 2184 51 MLOAD 2185 61 PUSH2 0x2251 2188 56 *JUMP // Stack delta = -1 // Outputs[1] { @2184 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2251 label_2189: // Incoming return from call to 0x217C at 0x2174 // Inputs[3] // { // @218A stack[-1] // @218A stack[-3] // @218C stack[-2] // } 2189 5B JUMPDEST 218A 91 SWAP2 218B 50 POP 218C 80 DUP1 218D 61 PUSH2 0x2195 2190 81 DUP2 2191 61 PUSH2 0x2975 2194 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @218A stack[-3] = stack[-1] // @218C stack[-1] = stack[-2] // @218D stack[0] = 0x2195 // @2190 stack[1] = stack[-2] // } // Block ends with call to 0x2975, returns to 0x2195 label_2195: // Incoming return from call to 0x2975 at 0x2194 // Inputs[2] // { // @2196 stack[-3] // @2196 stack[-1] // } 2195 5B JUMPDEST 2196 91 SWAP2 2197 50 POP 2198 50 POP 2199 61 PUSH2 0x215d 219C 56 *JUMP // Stack delta = -2 // Outputs[1] { @2196 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x215d label_219D: // Incoming jump from 0x2166, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2166, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @219F stack[-6] // @219F stack[-2] // @21A0 stack[-5] // } 219D 5B JUMPDEST 219E 50 POP 219F 93 SWAP4 21A0 92 SWAP3 21A1 50 POP 21A2 50 POP 21A3 50 POP 21A4 56 *JUMP // Stack delta = -5 // Outputs[1] { @219F stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_21A5: // Incoming call from 0x1EE0, returns to 0x1EE1 // Inputs[1] { @21A8 storage[0x0b] } 21A5 5B JUMPDEST 21A6 60 PUSH1 0x0b 21A8 54 SLOAD 21A9 60 PUSH1 0x01 21AB 60 PUSH1 0xa0 21AD 1B SHL 21AE 90 SWAP1 21AF 04 DIV 21B0 60 PUSH1 0xff 21B2 16 AND 21B3 61 PUSH2 0x14cb 21B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14cb, if 0xff & storage[0x0b] / (0x01 << 0xa0) label_21B7: // Incoming jump from 0x21B6, if not 0xff & storage[0x0b] / (0x01 << 0xa0) // Inputs[1] { @21B9 memory[0x40:0x60] } 21B7 60 PUSH1 0x40 21B9 51 MLOAD 21BA 62 PUSH3 0x461bcd 21BE 60 PUSH1 0xe5 21C0 1B SHL 21C1 81 DUP2 21C2 52 MSTORE 21C3 60 PUSH1 0x20 21C5 60 PUSH1 0x04 21C7 82 DUP3 21C8 01 ADD 21C9 52 MSTORE 21CA 60 PUSH1 0x14 21CC 60 PUSH1 0x24 21CE 82 DUP3 21CF 01 ADD 21D0 52 MSTORE 21D1 7F PUSH32 0x5061757361626c653a206e6f7420706175736564000000000000000000000000 21F2 60 PUSH1 0x44 21F4 82 DUP3 21F5 01 ADD 21F6 52 MSTORE 21F7 60 PUSH1 0x64 21F9 01 ADD 21FA 61 PUSH2 0x0e86 21FD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @21C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @21C9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @21D0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @21F6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5061757361626c653a206e6f7420706175736564000000000000000000000000 // @21F9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0e86 label_21FE: // Incoming jump from 0x2106 // Inputs[1] { @2204 storage[0x0c] } 21FE 5B JUMPDEST 21FF 60 PUSH1 0x60 2201 60 PUSH1 0x0c 2203 80 DUP1 2204 54 SLOAD 2205 61 PUSH2 0x094b 2208 90 SWAP1 2209 61 PUSH2 0x271f 220C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @21FF stack[0] = 0x60 // @2201 stack[1] = 0x0c // @2208 stack[2] = 0x094b // @2208 stack[3] = storage[0x0c] // } // Block ends with call to 0x271f, returns to 0x094B 220D 5B JUMPDEST 220E 60 PUSH1 0x60 2210 60 PUSH1 0xa0 2212 60 PUSH1 0x40 2214 51 MLOAD 2215 01 ADD 2216 80 DUP1 2217 60 PUSH1 0x40 2219 52 MSTORE 221A 60 PUSH1 0x20 221C 81 DUP2 221D 03 SUB 221E 91 SWAP2 221F 50 POP 2220 50 POP 2221 60 PUSH1 0x00 2223 81 DUP2 2224 52 MSTORE 2225 80 DUP1 2226 82 DUP3 2227 5B JUMPDEST 2228 60 PUSH1 0x01 222A 83 DUP4 222B 03 SUB 222C 92 SWAP3 222D 50 POP 222E 60 PUSH1 0x0a 2230 81 DUP2 2231 06 MOD 2232 60 PUSH1 0x30 2234 01 ADD 2235 83 DUP4 2236 53 MSTORE8 2237 60 PUSH1 0x0a 2239 90 SWAP1 223A 04 DIV 223B 80 DUP1 223C 61 PUSH2 0x2227 223F 57 *JUMPI 2240 50 POP 2241 81 DUP2 2242 90 SWAP1 2243 03 SUB 2244 60 PUSH1 0x1f 2246 19 NOT 2247 90 SWAP1 2248 91 SWAP2 2249 01 ADD 224A 90 SWAP1 224B 81 DUP2 224C 52 MSTORE 224D 91 SWAP2 224E 90 SWAP1 224F 50 POP 2250 56 *JUMP label_2251: // Incoming jump from 0x2188 // Inputs[2] // { // @2254 stack[-1] // @2255 stack[-2] // } 2251 5B JUMPDEST 2252 60 PUSH1 0x00 2254 81 DUP2 2255 83 DUP4 2256 10 LT 2257 61 PUSH2 0x226d 225A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2252 stack[0] = 0x00 } // Block ends with conditional jump to 0x226d, if stack[-2] < stack[-1] label_225B: // Incoming jump from 0x225A, if not stack[-2] < stack[-1] // Inputs[3] // { // @225D stack[-2] // @2262 stack[-3] // @2268 memory[0x00:0x40] // } 225B 60 PUSH1 0x00 225D 82 DUP3 225E 81 DUP2 225F 52 MSTORE 2260 60 PUSH1 0x20 2262 84 DUP5 2263 90 SWAP1 2264 52 MSTORE 2265 60 PUSH1 0x40 2267 90 SWAP1 2268 20 SHA3 2269 61 PUSH2 0x1adb 226C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @225F memory[0x00:0x20] = stack[-2] // @2264 memory[0x20:0x40] = stack[-3] // @2268 stack[0] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x1adb label_226D: // Incoming jump from 0x225A, if stack[-2] < stack[-1] // Inputs[4] // { // @2271 stack[-3] // @2276 stack[-2] // @227A memory[0x00:0x40] // @227B stack[-4] // } 226D 5B JUMPDEST 226E 50 POP 226F 60 PUSH1 0x00 2271 91 SWAP2 2272 82 DUP3 2273 52 MSTORE 2274 60 PUSH1 0x20 2276 52 MSTORE 2277 60 PUSH1 0x40 2279 90 SWAP1 227A 20 SHA3 227B 90 SWAP1 227C 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2273 memory[0x00:0x20] = stack[-3] // @2276 memory[0x20:0x40] = stack[-2] // @227B stack[-4] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to stack[-4] label_227D: // Incoming call from 0x295E, returns to 0x1ADB // Incoming call from 0x22AF, returns to 0x1ADB // Inputs[1] { @2287 stack[-1] } 227D 5B JUMPDEST 227E 60 PUSH1 0x01 2280 60 PUSH1 0x01 2282 60 PUSH1 0xe0 2284 1B SHL 2285 03 SUB 2286 19 NOT 2287 81 DUP2 2288 16 AND 2289 81 DUP2 228A 14 EQ 228B 61 PUSH2 0x0939 228E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0939, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_228F: // Incoming jump from 0x228E, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2292 memory[0x00:0x00] } 228F 60 PUSH1 0x00 2291 80 DUP1 2292 FD *REVERT // Stack delta = +0 // Outputs[1] { @2292 revert(memory[0x00:0x00]); } // Block terminates label_2293: // Incoming call from 0x0306, returns to 0x0307 // Inputs[2] // { // @2298 stack[-1] // @2299 stack[-2] // } 2293 5B JUMPDEST 2294 60 PUSH1 0x00 2296 60 PUSH1 0x20 2298 82 DUP3 2299 84 DUP5 229A 03 SUB 229B 12 SLT 229C 15 ISZERO 229D 61 PUSH2 0x22a5 22A0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2294 stack[0] = 0x00 } // Block ends with conditional jump to 0x22a5, if !(stack[-2] - stack[-1] i< 0x20) label_22A1: // Incoming jump from 0x22A0, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22A4 memory[0x00:0x00] } 22A1 60 PUSH1 0x00 22A3 80 DUP1 22A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @22A4 revert(memory[0x00:0x00]); } // Block terminates label_22A5: // Incoming jump from 0x22A0, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @22A6 stack[-2] // @22A7 msg.data[stack[-2]:stack[-2] + 0x20] // } 22A5 5B JUMPDEST 22A6 81 DUP2 22A7 35 CALLDATALOAD 22A8 61 PUSH2 0x1adb 22AB 81 DUP2 22AC 61 PUSH2 0x227d 22AF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22A7 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @22A8 stack[1] = 0x1adb // @22AB stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x227d, returns to 0x1ADB label_22B0: // Incoming call from 0x22E6, returns to 0x1ADB // Incoming call from 0x26B3, returns to 0x26B4 // Incoming call from 0x271E, returns to 0x264F // Incoming call from 0x237E, returns to 0x237F // Incoming call from 0x2678, returns to 0x2679 // Incoming call from 0x265C, returns to 0x23DA // Incoming call from 0x240E, returns to 0x240F // Incoming call from 0x26A5, returns to 0x26A6 // Incoming call from 0x2400, returns to 0x2401 // Inputs[2] // { // @22B1 stack[-1] // @22B2 msg.data[stack[-1]:stack[-1] + 0x20] // } 22B0 5B JUMPDEST 22B1 80 DUP1 22B2 35 CALLDATALOAD 22B3 60 PUSH1 0x01 22B5 60 PUSH1 0x01 22B7 60 PUSH1 0xa0 22B9 1B SHL 22BA 03 SUB 22BB 81 DUP2 22BC 16 AND 22BD 81 DUP2 22BE 14 EQ 22BF 61 PUSH2 0x22c7 22C2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22B2 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x22c7, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_22C3: // Incoming jump from 0x22C2, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @22C6 memory[0x00:0x00] } 22C3 60 PUSH1 0x00 22C5 80 DUP1 22C6 FD *REVERT // Stack delta = +0 // Outputs[1] { @22C6 revert(memory[0x00:0x00]); } // Block terminates label_22C7: // Incoming jump from 0x22C2, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x2397, if msg.data[stack[-1]:stack[-1] + 0x20] < 0x03 // Incoming jump from 0x242A, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[3] // { // @22C8 stack[-1] // @22C8 stack[-3] // @22C9 stack[-2] // } 22C7 5B JUMPDEST 22C8 91 SWAP2 22C9 90 SWAP1 22CA 50 POP 22CB 56 *JUMP // Stack delta = -2 // Outputs[1] { @22C8 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_22CC: // Incoming call from 0x033B, returns to 0x033C // Incoming call from 0x08AB, returns to 0x08AC // Incoming call from 0x0620, returns to 0x0621 // Inputs[2] // { // @22D1 stack[-1] // @22D2 stack[-2] // } 22CC 5B JUMPDEST 22CD 60 PUSH1 0x00 22CF 60 PUSH1 0x20 22D1 82 DUP3 22D2 84 DUP5 22D3 03 SUB 22D4 12 SLT 22D5 15 ISZERO 22D6 61 PUSH2 0x22de 22D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22CD stack[0] = 0x00 } // Block ends with conditional jump to 0x22de, if !(stack[-2] - stack[-1] i< 0x20) label_22DA: // Incoming jump from 0x22D9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22DD memory[0x00:0x00] } 22DA 60 PUSH1 0x00 22DC 80 DUP1 22DD FD *REVERT // Stack delta = +0 // Outputs[1] { @22DD revert(memory[0x00:0x00]); } // Block terminates label_22DE: // Incoming jump from 0x22D9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22E2 stack[-2] } 22DE 5B JUMPDEST 22DF 61 PUSH2 0x1adb 22E2 82 DUP3 22E3 61 PUSH2 0x22b0 22E6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22DF stack[0] = 0x1adb // @22E2 stack[1] = stack[-2] // } // Block ends with call to 0x22b0, returns to 0x1ADB label_22E7: // Incoming call from 0x2322, returns to 0x2323 // Inputs[1] { @22EB stack[-3] } 22E7 5B JUMPDEST 22E8 60 PUSH1 0x00 22EA 5B JUMPDEST 22EB 83 DUP4 22EC 81 DUP2 22ED 10 LT 22EE 15 ISZERO 22EF 61 PUSH2 0x2302 22F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22E8 stack[0] = 0x00 } // Block ends with conditional jump to 0x2302, if !(0x00 < stack[-3]) label_22F3: // Incoming jump from 0x22F2, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x22F2, if not !(0x00 < stack[-3]) // Inputs[4] // { // @22F3 stack[-2] // @22F4 stack[-1] // @22F6 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @22F7 stack[-3] // } 22F3 81 DUP2 22F4 81 DUP2 22F5 01 ADD 22F6 51 MLOAD 22F7 83 DUP4 22F8 82 DUP3 22F9 01 ADD 22FA 52 MSTORE 22FB 60 PUSH1 0x20 22FD 01 ADD 22FE 61 PUSH2 0x22ea 2301 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @22FA memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @22FD stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x22ea label_2302: // Incoming jump from 0x22F2, if !(stack[-1] < stack[-4]) // Incoming jump from 0x22F2, if !(0x00 < stack[-3]) // Inputs[3] // { // @2307 stack[-4] // @2308 stack[-3] // @230A stack[-5] // } 2302 5B JUMPDEST 2303 50 POP 2304 50 POP 2305 60 PUSH1 0x00 2307 91 SWAP2 2308 01 ADD 2309 52 MSTORE 230A 56 *JUMP // Stack delta = -5 // Outputs[1] { @2309 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_230B: // Incoming call from 0x2349, returns to 0x1ADB // Incoming call from 0x2937, returns to 0x2938 // Inputs[3] // { // @230E stack[-1] // @230F memory[stack[-1]:stack[-1] + 0x20] // @2311 stack[-2] // } 230B 5B JUMPDEST 230C 60 PUSH1 0x00 230E 81 DUP2 230F 51 MLOAD 2310 80 DUP1 2311 84 DUP5 2312 52 MSTORE 2313 61 PUSH2 0x2323 2316 81 DUP2 2317 60 PUSH1 0x20 2319 86 DUP7 231A 01 ADD 231B 60 PUSH1 0x20 231D 86 DUP7 231E 01 ADD 231F 61 PUSH2 0x22e7 2322 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @230C stack[0] = 0x00 // @230F stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2312 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2313 stack[2] = 0x2323 // @2316 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @231A stack[4] = stack[-2] + 0x20 // @231E stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x22e7, returns to 0x2323 label_2323: // Incoming return from call to 0x22E7 at 0x2322 // Inputs[4] // { // @2326 stack[-1] // @232B stack[-4] // @232C stack[-2] // @2332 stack[-5] // } 2323 5B JUMPDEST 2324 60 PUSH1 0x1f 2326 01 ADD 2327 60 PUSH1 0x1f 2329 19 NOT 232A 16 AND 232B 92 SWAP3 232C 90 SWAP1 232D 92 SWAP3 232E 01 ADD 232F 60 PUSH1 0x20 2331 01 ADD 2332 92 SWAP3 2333 91 SWAP2 2334 50 POP 2335 50 POP 2336 56 *JUMP // Stack delta = -4 // Outputs[1] { @2332 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2337: // Incoming call from 0x0364, returns to 0x0318 // Inputs[2] // { // @233A stack[-1] // @2345 stack[-2] // } 2337 5B JUMPDEST 2338 60 PUSH1 0x20 233A 81 DUP2 233B 52 MSTORE 233C 60 PUSH1 0x00 233E 61 PUSH2 0x1adb 2341 60 PUSH1 0x20 2343 83 DUP4 2344 01 ADD 2345 84 DUP5 2346 61 PUSH2 0x230b 2349 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @233B memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @233C stack[0] = 0x00 // @233E stack[1] = 0x1adb // @2344 stack[2] = stack[-1] + 0x20 // @2345 stack[3] = stack[-2] // } // Block ends with call to 0x230b, returns to 0x1ADB label_234A: // Incoming call from 0x06A2, returns to 0x06A3 // Incoming call from 0x04A7, returns to 0x04A8 // Incoming call from 0x05E0, returns to 0x05E1 // Incoming call from 0x0812, returns to 0x0813 // Incoming call from 0x037F, returns to 0x0380 // Inputs[2] // { // @234F stack[-1] // @2350 stack[-2] // } 234A 5B JUMPDEST 234B 60 PUSH1 0x00 234D 60 PUSH1 0x20 234F 82 DUP3 2350 84 DUP5 2351 03 SUB 2352 12 SLT 2353 15 ISZERO 2354 61 PUSH2 0x235c 2357 57 *JUMPI // Stack delta = +1 // Outputs[1] { @234B stack[0] = 0x00 } // Block ends with conditional jump to 0x235c, if !(stack[-2] - stack[-1] i< 0x20) label_2358: // Incoming jump from 0x2357, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @235B memory[0x00:0x00] } 2358 60 PUSH1 0x00 235A 80 DUP1 235B FD *REVERT // Stack delta = +0 // Outputs[1] { @235B revert(memory[0x00:0x00]); } // Block terminates label_235C: // Incoming jump from 0x2357, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @235E msg.data[stack[-2]:stack[-2] + 0x20] // @235E stack[-2] // @235F stack[-4] // @2360 stack[-3] // } 235C 5B JUMPDEST 235D 50 POP 235E 35 CALLDATALOAD 235F 91 SWAP2 2360 90 SWAP1 2361 50 POP 2362 56 *JUMP // Stack delta = -3 // Outputs[1] { @235F stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2363: // Incoming call from 0x0567, returns to 0x0568 // Incoming call from 0x03AA, returns to 0x03AB // Inputs[2] // { // @2369 stack[-1] // @236A stack[-2] // } 2363 5B JUMPDEST 2364 60 PUSH1 0x00 2366 80 DUP1 2367 60 PUSH1 0x40 2369 83 DUP4 236A 85 DUP6 236B 03 SUB 236C 12 SLT 236D 15 ISZERO 236E 61 PUSH2 0x2376 2371 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2364 stack[0] = 0x00 // @2366 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2376, if !(stack[-2] - stack[-1] i< 0x40) label_2372: // Incoming jump from 0x2371, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2375 memory[0x00:0x00] } 2372 60 PUSH1 0x00 2374 80 DUP1 2375 FD *REVERT // Stack delta = +0 // Outputs[1] { @2375 revert(memory[0x00:0x00]); } // Block terminates label_2376: // Incoming jump from 0x2371, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @237A stack[-3] } 2376 5B JUMPDEST 2377 61 PUSH2 0x237f 237A 83 DUP4 237B 61 PUSH2 0x22b0 237E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2377 stack[0] = 0x237f // @237A stack[1] = stack[-3] // } // Block ends with call to 0x22b0, returns to 0x237F label_237F: // Incoming return from call to 0x22B0 at 0x237E // Inputs[5] // { // @2380 stack[-6] // @2380 stack[-1] // @2383 stack[-4] // @2387 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2388 stack[-5] // } 237F 5B JUMPDEST 2380 94 SWAP5 2381 60 PUSH1 0x20 2383 93 SWAP4 2384 90 SWAP1 2385 93 SWAP4 2386 01 ADD 2387 35 CALLDATALOAD 2388 93 SWAP4 2389 50 POP 238A 50 POP 238B 50 POP 238C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2380 stack[-6] = stack[-1] // @2388 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_238D: // Incoming call from 0x2527, returns to 0x2528 // Incoming call from 0x2632, returns to 0x23DA // Incoming call from 0x264E, returns to 0x264F // Incoming call from 0x23B6, returns to 0x1ADB // Incoming call from 0x23D9, returns to 0x23DA // Inputs[2] // { // @238E stack[-1] // @238F msg.data[stack[-1]:stack[-1] + 0x20] // } 238D 5B JUMPDEST 238E 80 DUP1 238F 35 CALLDATALOAD 2390 60 PUSH1 0x03 2392 81 DUP2 2393 10 LT 2394 61 PUSH2 0x22c7 2397 57 *JUMPI // Stack delta = +1 // Outputs[1] { @238F stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x22c7, if msg.data[stack[-1]:stack[-1] + 0x20] < 0x03 label_2398: // Incoming jump from 0x2397, if not msg.data[stack[-1]:stack[-1] + 0x20] < 0x03 // Inputs[1] { @239B memory[0x00:0x00] } 2398 60 PUSH1 0x00 239A 80 DUP1 239B FD *REVERT // Stack delta = +0 // Outputs[1] { @239B revert(memory[0x00:0x00]); } // Block terminates label_239C: // Incoming call from 0x0675, returns to 0x0676 // Incoming call from 0x03CA, returns to 0x03CB // Incoming call from 0x0832, returns to 0x0833 // Inputs[2] // { // @23A1 stack[-1] // @23A2 stack[-2] // } 239C 5B JUMPDEST 239D 60 PUSH1 0x00 239F 60 PUSH1 0x20 23A1 82 DUP3 23A2 84 DUP5 23A3 03 SUB 23A4 12 SLT 23A5 15 ISZERO 23A6 61 PUSH2 0x23ae 23A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @239D stack[0] = 0x00 } // Block ends with conditional jump to 0x23ae, if !(stack[-2] - stack[-1] i< 0x20) label_23AA: // Incoming jump from 0x23A9, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @23AD memory[0x00:0x00] } 23AA 60 PUSH1 0x00 23AC 80 DUP1 23AD FD *REVERT // Stack delta = +0 // Outputs[1] { @23AD revert(memory[0x00:0x00]); } // Block terminates label_23AE: // Incoming jump from 0x23A9, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @23B2 stack[-2] } 23AE 5B JUMPDEST 23AF 61 PUSH2 0x1adb 23B2 82 DUP3 23B3 61 PUSH2 0x238d 23B6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23AF stack[0] = 0x1adb // @23B2 stack[1] = stack[-2] // } // Block ends with call to 0x238d, returns to 0x1ADB label_23B7: // Incoming call from 0x0405, returns to 0x0406 // Incoming call from 0x0600, returns to 0x0601 // Inputs[2] // { // @23BD stack[-1] // @23BE stack[-2] // } 23B7 5B JUMPDEST 23B8 60 PUSH1 0x00 23BA 80 DUP1 23BB 60 PUSH1 0x40 23BD 83 DUP4 23BE 85 DUP6 23BF 03 SUB 23C0 12 SLT 23C1 15 ISZERO 23C2 61 PUSH2 0x23ca 23C5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23B8 stack[0] = 0x00 // @23BA stack[1] = 0x00 // } // Block ends with conditional jump to 0x23ca, if !(stack[-2] - stack[-1] i< 0x40) label_23C6: // Incoming jump from 0x23C5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @23C9 memory[0x00:0x00] } 23C6 60 PUSH1 0x00 23C8 80 DUP1 23C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @23C9 revert(memory[0x00:0x00]); } // Block terminates label_23CA: // Incoming jump from 0x23C5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @23CB stack[-3] // @23CC msg.data[stack[-3]:stack[-3] + 0x20] // @23CD stack[-2] // } 23CA 5B JUMPDEST 23CB 82 DUP3 23CC 35 CALLDATALOAD 23CD 91 SWAP2 23CE 50 POP 23CF 61 PUSH2 0x23da 23D2 60 PUSH1 0x20 23D4 84 DUP5 23D5 01 ADD 23D6 61 PUSH2 0x238d 23D9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @23CD stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @23CF stack[0] = 0x23da // @23D5 stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x238d, returns to 0x23DA label_23DA: // Incoming return from call to 0x22B0 at 0x265C // Incoming return from call to 0x241F at 0x2686 // Incoming return from call to 0x238D at 0x2632 // Incoming return from call to 0x238D at 0x23D9 // Inputs[6] // { // @23DB stack[-2] // @23DB stack[-1] // @23DD stack[-5] // @23DF stack[-6] // @23DF stack[-3] // @23E0 stack[-4] // } 23DA 5B JUMPDEST 23DB 90 SWAP1 23DC 50 POP 23DD 92 SWAP3 23DE 50 POP 23DF 92 SWAP3 23E0 90 SWAP1 23E1 50 POP 23E2 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @23DD stack[-5] = stack[-1] // @23DF stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_23E3: // Incoming call from 0x0547, returns to 0x0548 // Incoming call from 0x0435, returns to 0x0436 // Inputs[2] // { // @23EB stack[-1] // @23EC stack[-2] // } 23E3 5B JUMPDEST 23E4 60 PUSH1 0x00 23E6 80 DUP1 23E7 60 PUSH1 0x00 23E9 60 PUSH1 0x60 23EB 84 DUP5 23EC 86 DUP7 23ED 03 SUB 23EE 12 SLT 23EF 15 ISZERO 23F0 61 PUSH2 0x23f8 23F3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @23E4 stack[0] = 0x00 // @23E6 stack[1] = 0x00 // @23E7 stack[2] = 0x00 // } // Block ends with conditional jump to 0x23f8, if !(stack[-2] - stack[-1] i< 0x60) label_23F4: // Incoming jump from 0x23F3, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @23F7 memory[0x00:0x00] } 23F4 60 PUSH1 0x00 23F6 80 DUP1 23F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @23F7 revert(memory[0x00:0x00]); } // Block terminates label_23F8: // Incoming jump from 0x23F3, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @23FC stack[-4] } 23F8 5B JUMPDEST 23F9 61 PUSH2 0x2401 23FC 84 DUP5 23FD 61 PUSH2 0x22b0 2400 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23F9 stack[0] = 0x2401 // @23FC stack[1] = stack[-4] // } // Block ends with call to 0x22b0, returns to 0x2401 label_2401: // Incoming return from call to 0x22B0 at 0x2400 // Inputs[3] // { // @2402 stack[-4] // @2402 stack[-1] // @2409 stack[-5] // } 2401 5B JUMPDEST 2402 92 SWAP3 2403 50 POP 2404 61 PUSH2 0x240f 2407 60 PUSH1 0x20 2409 85 DUP6 240A 01 ADD 240B 61 PUSH2 0x22b0 240E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2402 stack[-4] = stack[-1] // @2404 stack[-1] = 0x240f // @240A stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x22b0, returns to 0x240F label_240F: // Incoming return from call to 0x22B0 at 0x240E // Inputs[8] // { // @2410 stack[-3] // @2410 stack[-1] // @2414 stack[-5] // @2416 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2417 stack[-2] // @241B stack[-6] // @241D stack[-7] // @241D stack[-4] // } 240F 5B JUMPDEST 2410 91 SWAP2 2411 50 POP 2412 60 PUSH1 0x40 2414 84 DUP5 2415 01 ADD 2416 35 CALLDATALOAD 2417 90 SWAP1 2418 50 POP 2419 92 SWAP3 241A 50 POP 241B 92 SWAP3 241C 50 POP 241D 92 SWAP3 241E 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2419 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @241B stack[-6] = stack[-1] // @241D stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_241F: // Incoming call from 0x2686, returns to 0x23DA // Incoming call from 0x2449, returns to 0x1ADB // Incoming call from 0x2624, returns to 0x2625 // Inputs[2] // { // @2420 stack[-1] // @2421 msg.data[stack[-1]:stack[-1] + 0x20] // } 241F 5B JUMPDEST 2420 80 DUP1 2421 35 CALLDATALOAD 2422 80 DUP1 2423 15 ISZERO 2424 15 ISZERO 2425 81 DUP2 2426 14 EQ 2427 61 PUSH2 0x22c7 242A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2421 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x22c7, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_242B: // Incoming jump from 0x242A, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @242E memory[0x00:0x00] } 242B 60 PUSH1 0x00 242D 80 DUP1 242E FD *REVERT // Stack delta = +0 // Outputs[1] { @242E revert(memory[0x00:0x00]); } // Block terminates label_242F: // Incoming call from 0x0758, returns to 0x0759 // Incoming call from 0x0455, returns to 0x0456 // Inputs[2] // { // @2434 stack[-1] // @2435 stack[-2] // } 242F 5B JUMPDEST 2430 60 PUSH1 0x00 2432 60 PUSH1 0x20 2434 82 DUP3 2435 84 DUP5 2436 03 SUB 2437 12 SLT 2438 15 ISZERO 2439 61 PUSH2 0x2441 243C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2430 stack[0] = 0x00 } // Block ends with conditional jump to 0x2441, if !(stack[-2] - stack[-1] i< 0x20) label_243D: // Incoming jump from 0x243C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2440 memory[0x00:0x00] } 243D 60 PUSH1 0x00 243F 80 DUP1 2440 FD *REVERT // Stack delta = +0 // Outputs[1] { @2440 revert(memory[0x00:0x00]); } // Block terminates label_2441: // Incoming jump from 0x243C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2445 stack[-2] } 2441 5B JUMPDEST 2442 61 PUSH2 0x1adb 2445 82 DUP3 2446 61 PUSH2 0x241f 2449 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2442 stack[0] = 0x1adb // @2445 stack[1] = stack[-2] // } // Block ends with call to 0x241f, returns to 0x1ADB label_244A: // Incoming call from 0x0475, returns to 0x0476 // Inputs[2] // { // @2450 stack[-1] // @2451 stack[-2] // } 244A 5B JUMPDEST 244B 60 PUSH1 0x00 244D 80 DUP1 244E 60 PUSH1 0x40 2450 83 DUP4 2451 85 DUP6 2452 03 SUB 2453 12 SLT 2454 15 ISZERO 2455 61 PUSH2 0x245d 2458 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @244B stack[0] = 0x00 // @244D stack[1] = 0x00 // } // Block ends with conditional jump to 0x245d, if !(stack[-2] - stack[-1] i< 0x40) label_2459: // Incoming jump from 0x2458, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @245C memory[0x00:0x00] } 2459 60 PUSH1 0x00 245B 80 DUP1 245C FD *REVERT // Stack delta = +0 // Outputs[1] { @245C revert(memory[0x00:0x00]); } // Block terminates label_245D: // Incoming jump from 0x2458, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @2460 stack[-3] // @2461 msg.data[stack[-3]:stack[-3] + 0x20] // @2462 stack[-5] // @2468 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2469 stack[-4] // } 245D 5B JUMPDEST 245E 50 POP 245F 50 POP 2460 80 DUP1 2461 35 CALLDATALOAD 2462 92 SWAP3 2463 60 PUSH1 0x20 2465 90 SWAP1 2466 91 SWAP2 2467 01 ADD 2468 35 CALLDATALOAD 2469 91 SWAP2 246A 50 POP 246B 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2462 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @2469 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_246C: // Incoming call from 0x04C7, returns to 0x04C8 // Inputs[2] // { // @2471 stack[-1] // @2472 stack[-2] // } 246C 5B JUMPDEST 246D 60 PUSH1 0x00 246F 60 PUSH1 0x20 2471 82 DUP3 2472 84 DUP5 2473 03 SUB 2474 12 SLT 2475 15 ISZERO 2476 61 PUSH2 0x247e 2479 57 *JUMPI // Stack delta = +1 // Outputs[1] { @246D stack[0] = 0x00 } // Block ends with conditional jump to 0x247e, if !(stack[-2] - stack[-1] i< 0x20) label_247A: // Incoming jump from 0x2479, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @247D memory[0x00:0x00] } 247A 60 PUSH1 0x00 247C 80 DUP1 247D FD *REVERT // Stack delta = +0 // Outputs[1] { @247D revert(memory[0x00:0x00]); } // Block terminates label_247E: // Incoming jump from 0x2479, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @247F stack[-2] // @2480 msg.data[stack[-2]:stack[-2] + 0x20] // } 247E 5B JUMPDEST 247F 81 DUP2 2480 35 CALLDATALOAD 2481 6B PUSH12 0xffffffffffffffffffffffff 248E 81 DUP2 248F 16 AND 2490 81 DUP2 2491 14 EQ 2492 61 PUSH2 0x1adb 2495 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2480 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1adb, if msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffff label_2496: // Incoming jump from 0x2495, if not msg.data[stack[-2]:stack[-2] + 0x20] == msg.data[stack[-2]:stack[-2] + 0x20] & 0xffffffffffffffffffffffff // Inputs[1] { @2499 memory[0x00:0x00] } 2496 60 PUSH1 0x00 2498 80 DUP1 2499 FD *REVERT // Stack delta = +0 // Outputs[1] { @2499 revert(memory[0x00:0x00]); } // Block terminates label_249A: // Incoming call from 0x050A, returns to 0x050B // Inputs[2] // { // @24A5 stack[-1] // @24A6 stack[-2] // } 249A 5B JUMPDEST 249B 60 PUSH1 0x00 249D 80 DUP1 249E 60 PUSH1 0x00 24A0 80 DUP1 24A1 60 PUSH1 0x00 24A3 60 PUSH1 0x80 24A5 86 DUP7 24A6 88 DUP9 24A7 03 SUB 24A8 12 SLT 24A9 15 ISZERO 24AA 61 PUSH2 0x24b2 24AD 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @249B stack[0] = 0x00 // @249D stack[1] = 0x00 // @249E stack[2] = 0x00 // @24A0 stack[3] = 0x00 // @24A1 stack[4] = 0x00 // } // Block ends with conditional jump to 0x24b2, if !(stack[-2] - stack[-1] i< 0x80) label_24AE: // Incoming jump from 0x24AD, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @24B1 memory[0x00:0x00] } 24AE 60 PUSH1 0x00 24B0 80 DUP1 24B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @24B1 revert(memory[0x00:0x00]); } // Block terminates label_24B2: // Incoming jump from 0x24AD, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[6] // { // @24B3 stack[-6] // @24B4 msg.data[stack[-6]:stack[-6] + 0x20] // @24B5 stack[-5] // @24BB msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @24BC stack[-4] // @24C2 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // } 24B2 5B JUMPDEST 24B3 85 DUP6 24B4 35 CALLDATALOAD 24B5 94 SWAP5 24B6 50 POP 24B7 60 PUSH1 0x20 24B9 86 DUP7 24BA 01 ADD 24BB 35 CALLDATALOAD 24BC 93 SWAP4 24BD 50 POP 24BE 60 PUSH1 0x40 24C0 86 DUP7 24C1 01 ADD 24C2 35 CALLDATALOAD 24C3 67 PUSH8 0xffffffffffffffff 24CC 80 DUP1 24CD 82 DUP3 24CE 11 GT 24CF 15 ISZERO 24D0 61 PUSH2 0x24d8 24D3 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @24B5 stack[-5] = msg.data[stack[-6]:stack[-6] + 0x20] // @24BC stack[-4] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @24C2 stack[0] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @24C3 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x24d8, if !(msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] > 0xffffffffffffffff) label_24D4: // Incoming jump from 0x24D3, if not !(msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @24D7 memory[0x00:0x00] } 24D4 60 PUSH1 0x00 24D6 80 DUP1 24D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @24D7 revert(memory[0x00:0x00]); } // Block terminates label_24D8: // Incoming jump from 0x24D3, if !(msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @24D9 stack[-2] // @24DA stack[-8] // @24DE stack[-9] // } 24D8 5B JUMPDEST 24D9 81 DUP2 24DA 88 DUP9 24DB 01 ADD 24DC 91 SWAP2 24DD 50 POP 24DE 88 DUP9 24DF 60 PUSH1 0x1f 24E1 83 DUP4 24E2 01 ADD 24E3 12 SLT 24E4 61 PUSH2 0x24ec 24E7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @24DC stack[-2] = stack[-8] + stack[-2] } // Block ends with conditional jump to 0x24ec, if stack[-8] + stack[-2] + 0x1f i< stack[-9] label_24E8: // Incoming jump from 0x24E7, if not stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[1] { @24EB memory[0x00:0x00] } 24E8 60 PUSH1 0x00 24EA 80 DUP1 24EB FD *REVERT // Stack delta = +0 // Outputs[1] { @24EB revert(memory[0x00:0x00]); } // Block terminates label_24EC: // Incoming jump from 0x24E7, if stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[3] // { // @24ED stack[-2] // @24EE msg.data[stack[-2]:stack[-2] + 0x20] // @24EF stack[-1] // } 24EC 5B JUMPDEST 24ED 81 DUP2 24EE 35 CALLDATALOAD 24EF 81 DUP2 24F0 81 DUP2 24F1 11 GT 24F2 15 ISZERO 24F3 61 PUSH2 0x24fb 24F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24EE stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x24fb, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_24F7: // Incoming jump from 0x24F6, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @24FA memory[0x00:0x00] } 24F7 60 PUSH1 0x00 24F9 80 DUP1 24FA FD *REVERT // Stack delta = +0 // Outputs[1] { @24FA revert(memory[0x00:0x00]); } // Block terminates label_24FB: // Incoming jump from 0x24F6, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @24FC stack[-10] // @24FF stack[-1] // @2503 stack[-3] // } 24FB 5B JUMPDEST 24FC 89 DUP10 24FD 60 PUSH1 0x20 24FF 82 DUP3 2500 60 PUSH1 0x05 2502 1B SHL 2503 85 DUP6 2504 01 ADD 2505 01 ADD 2506 11 GT 2507 15 ISZERO 2508 61 PUSH2 0x2510 250B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2510, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) label_250C: // Incoming jump from 0x250B, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) // Inputs[1] { @250F memory[0x00:0x00] } 250C 60 PUSH1 0x00 250E 80 DUP1 250F FD *REVERT // Stack delta = +0 // Outputs[1] { @250F revert(memory[0x00:0x00]); } // Block terminates label_2510: // Incoming jump from 0x250B, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-10]) // Inputs[5] // { // @2513 stack[-3] // @2515 stack[-6] // @2517 stack[-1] // @2518 stack[-5] // @2522 stack[-9] // } 2510 5B JUMPDEST 2511 60 PUSH1 0x20 2513 83 DUP4 2514 01 ADD 2515 95 SWAP6 2516 50 POP 2517 80 DUP1 2518 94 SWAP5 2519 50 POP 251A 50 POP 251B 50 POP 251C 50 POP 251D 61 PUSH2 0x2528 2520 60 PUSH1 0x60 2522 87 DUP8 2523 01 ADD 2524 61 PUSH2 0x238d 2527 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2515 stack[-6] = stack[-3] + 0x20 // @2518 stack[-5] = stack[-1] // @251D stack[-3] = 0x2528 // @2523 stack[-2] = stack[-9] + 0x60 // } // Block ends with call to 0x238d, returns to 0x2528 label_2528: // Incoming return from call to 0x238D at 0x2527 // Inputs[9] // { // @2529 stack[-2] // @2529 stack[-1] // @252B stack[-5] // @252C stack[-8] // @252E stack[-3] // @252E stack[-6] // @252F stack[-9] // @2530 stack[-4] // @2531 stack[-7] // } 2528 5B JUMPDEST 2529 90 SWAP1 252A 50 POP 252B 92 SWAP3 252C 95 SWAP6 252D 50 POP 252E 92 SWAP3 252F 95 SWAP6 2530 90 SWAP1 2531 93 SWAP4 2532 50 POP 2533 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @252B stack[-5] = stack[-1] // @252C stack[-8] = stack[-5] // @252E stack[-6] = stack[-3] // @252F stack[-9] = stack[-6] // @2531 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2534: // Incoming jump from 0x2830 // Incoming jump from 0x258C // Incoming jump from 0x2564 // Inputs[1] { @2549 memory[0x00:0x24] } 2534 5B JUMPDEST 2535 63 PUSH4 0x4e487b71 253A 60 PUSH1 0xe0 253C 1B SHL 253D 60 PUSH1 0x00 253F 52 MSTORE 2540 60 PUSH1 0x41 2542 60 PUSH1 0x04 2544 52 MSTORE 2545 60 PUSH1 0x24 2547 60 PUSH1 0x00 2549 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @253F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2544 memory[0x04:0x24] = 0x41 // @2549 revert(memory[0x00:0x24]); // } // Block terminates label_254A: // Incoming call from 0x2608, returns to 0x20B4 // Incoming call from 0x26F6, returns to 0x26F7 // Inputs[1] { @2557 stack[-2] } 254A 5B JUMPDEST 254B 60 PUSH1 0x00 254D 67 PUSH8 0xffffffffffffffff 2556 80 DUP1 2557 84 DUP5 2558 11 GT 2559 15 ISZERO 255A 61 PUSH2 0x2565 255D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @254B stack[0] = 0x00 // @254D stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2565, if !(stack[-2] > 0xffffffffffffffff) label_255E: // Incoming jump from 0x255D, if not !(stack[-2] > 0xffffffffffffffff) 255E 61 PUSH2 0x2565 2561 61 PUSH2 0x2534 2564 56 *JUMP // Stack delta = +1 // Outputs[1] { @255E stack[0] = 0x2565 } // Block ends with unconditional jump to 0x2534 label_2565: // Incoming jump from 0x255D, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @2568 memory[0x40:0x60] // @256B stack[-4] // @257A stack[-1] // } 2565 5B JUMPDEST 2566 60 PUSH1 0x40 2568 51 MLOAD 2569 60 PUSH1 0x1f 256B 85 DUP6 256C 01 ADD 256D 60 PUSH1 0x1f 256F 19 NOT 2570 90 SWAP1 2571 81 DUP2 2572 16 AND 2573 60 PUSH1 0x3f 2575 01 ADD 2576 16 AND 2577 81 DUP2 2578 01 ADD 2579 90 SWAP1 257A 82 DUP3 257B 82 DUP3 257C 11 GT 257D 81 DUP2 257E 83 DUP4 257F 10 LT 2580 17 OR 2581 15 ISZERO 2582 61 PUSH2 0x258d 2585 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2579 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @2579 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x258d, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_2586: // Incoming jump from 0x2585, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 2586 61 PUSH2 0x258d 2589 61 PUSH2 0x2534 258C 56 *JUMP // Stack delta = +1 // Outputs[1] { @2586 stack[0] = 0x258d } // Block ends with unconditional jump to 0x2534 label_258D: // Incoming jump from 0x2585, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @258E stack[-2] // @2592 stack[-1] // @2593 stack[-4] // @2595 stack[-6] // @2598 stack[-7] // @259A stack[-5] // } 258D 5B JUMPDEST 258E 81 DUP2 258F 60 PUSH1 0x40 2591 52 MSTORE 2592 80 DUP1 2593 93 SWAP4 2594 50 POP 2595 85 DUP6 2596 81 DUP2 2597 52 MSTORE 2598 86 DUP7 2599 86 DUP7 259A 86 DUP7 259B 01 ADD 259C 11 GT 259D 15 ISZERO 259E 61 PUSH2 0x25a6 25A1 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2591 memory[0x40:0x60] = stack[-2] // @2593 stack[-4] = stack[-1] // @2597 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x25a6, if !(stack[-5] + stack[-6] > stack[-7]) label_25A2: // Incoming jump from 0x25A1, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @25A5 memory[0x00:0x00] } 25A2 60 PUSH1 0x00 25A4 80 DUP1 25A5 FD *REVERT // Stack delta = +0 // Outputs[1] { @25A5 revert(memory[0x00:0x00]); } // Block terminates label_25A6: // Incoming jump from 0x25A1, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @25A7 stack[-6] // @25A8 stack[-5] // @25AB stack[-1] // @25AD msg.data[stack[-5]:stack[-5] + stack[-6]] // @25BA stack[-4] // @25BA stack[-8] // @25BB stack[-7] // } 25A6 5B JUMPDEST 25A7 85 DUP6 25A8 85 DUP6 25A9 60 PUSH1 0x20 25AB 83 DUP4 25AC 01 ADD 25AD 37 CALLDATACOPY 25AE 60 PUSH1 0x00 25B0 60 PUSH1 0x20 25B2 87 DUP8 25B3 83 DUP4 25B4 01 ADD 25B5 01 ADD 25B6 52 MSTORE 25B7 50 POP 25B8 50 POP 25B9 50 POP 25BA 93 SWAP4 25BB 92 SWAP3 25BC 50 POP 25BD 50 POP 25BE 50 POP 25BF 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @25AD memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @25B6 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @25BA stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_25C0: // Incoming call from 0x05A1, returns to 0x05A2 // Inputs[2] // { // @25C5 stack[-1] // @25C6 stack[-2] // } 25C0 5B JUMPDEST 25C1 60 PUSH1 0x00 25C3 60 PUSH1 0x20 25C5 82 DUP3 25C6 84 DUP5 25C7 03 SUB 25C8 12 SLT 25C9 15 ISZERO 25CA 61 PUSH2 0x25d2 25CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25C1 stack[0] = 0x00 } // Block ends with conditional jump to 0x25d2, if !(stack[-2] - stack[-1] i< 0x20) label_25CE: // Incoming jump from 0x25CD, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @25D1 memory[0x00:0x00] } 25CE 60 PUSH1 0x00 25D0 80 DUP1 25D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @25D1 revert(memory[0x00:0x00]); } // Block terminates label_25D2: // Incoming jump from 0x25CD, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @25D3 stack[-2] // @25D4 msg.data[stack[-2]:stack[-2] + 0x20] // } 25D2 5B JUMPDEST 25D3 81 DUP2 25D4 35 CALLDATALOAD 25D5 67 PUSH8 0xffffffffffffffff 25DE 81 DUP2 25DF 11 GT 25E0 15 ISZERO 25E1 61 PUSH2 0x25e9 25E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25D4 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x25e9, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_25E5: // Incoming jump from 0x25E4, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @25E8 memory[0x00:0x00] } 25E5 60 PUSH1 0x00 25E7 80 DUP1 25E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @25E8 revert(memory[0x00:0x00]); } // Block terminates label_25E9: // Incoming jump from 0x25E4, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @25EA stack[-3] // @25EB stack[-1] // @25F0 stack[-4] // } 25E9 5B JUMPDEST 25EA 82 DUP3 25EB 01 ADD 25EC 60 PUSH1 0x1f 25EE 81 DUP2 25EF 01 ADD 25F0 84 DUP5 25F1 13 SGT 25F2 61 PUSH2 0x25fa 25F5 57 *JUMPI // Stack delta = +0 // Outputs[1] { @25EB stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x25fa, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_25F6: // Incoming jump from 0x25F5, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @25F9 memory[0x00:0x00] } 25F6 60 PUSH1 0x00 25F8 80 DUP1 25F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @25F9 revert(memory[0x00:0x00]); } // Block terminates label_25FA: // Incoming jump from 0x25F5, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @25FE stack[-4] // @25FF stack[-1] // @2600 msg.data[stack[-1]:stack[-1] + 0x20] // } 25FA 5B JUMPDEST 25FB 61 PUSH2 0x20b4 25FE 84 DUP5 25FF 82 DUP3 2600 35 CALLDATALOAD 2601 60 PUSH1 0x20 2603 84 DUP5 2604 01 ADD 2605 61 PUSH2 0x254a 2608 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @25FB stack[0] = 0x20b4 // @25FE stack[1] = stack[-4] // @2600 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2604 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x254a, returns to 0x20B4 label_2609: // Incoming jump from 0x0640 // Inputs[2] // { // @260F stack[-1] // @2610 stack[-2] // } 2609 5B JUMPDEST 260A 60 PUSH1 0x00 260C 80 DUP1 260D 60 PUSH1 0x40 260F 83 DUP4 2610 85 DUP6 2611 03 SUB 2612 12 SLT 2613 15 ISZERO 2614 61 PUSH2 0x261c 2617 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @260A stack[0] = 0x00 // @260C stack[1] = 0x00 // } // Block ends with conditional jump to 0x261c, if !(stack[-2] - stack[-1] i< 0x40) label_2618: // Incoming jump from 0x2617, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @261B memory[0x00:0x00] } 2618 60 PUSH1 0x00 261A 80 DUP1 261B FD *REVERT // Stack delta = +0 // Outputs[1] { @261B revert(memory[0x00:0x00]); } // Block terminates label_261C: // Incoming jump from 0x2617, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2620 stack[-3] } 261C 5B JUMPDEST 261D 61 PUSH2 0x2625 2620 83 DUP4 2621 61 PUSH2 0x241f 2624 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @261D stack[0] = 0x2625 // @2620 stack[1] = stack[-3] // } // Block ends with call to 0x241f, returns to 0x2625 label_2625: // Incoming return from call to 0x241F at 0x2624 // Inputs[3] // { // @2626 stack[-3] // @2626 stack[-1] // @262D stack[-4] // } 2625 5B JUMPDEST 2626 91 SWAP2 2627 50 POP 2628 61 PUSH2 0x23da 262B 60 PUSH1 0x20 262D 84 DUP5 262E 01 ADD 262F 61 PUSH2 0x238d 2632 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2626 stack[-3] = stack[-1] // @2628 stack[-1] = 0x23da // @262E stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x238d, returns to 0x23DA label_2633: // Incoming jump from 0x0720 // Inputs[2] // { // @2639 stack[-1] // @263A stack[-2] // } 2633 5B JUMPDEST 2634 60 PUSH1 0x00 2636 80 DUP1 2637 60 PUSH1 0x40 2639 83 DUP4 263A 85 DUP6 263B 03 SUB 263C 12 SLT 263D 15 ISZERO 263E 61 PUSH2 0x2646 2641 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2634 stack[0] = 0x00 // @2636 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2646, if !(stack[-2] - stack[-1] i< 0x40) label_2642: // Incoming jump from 0x2641, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2645 memory[0x00:0x00] } 2642 60 PUSH1 0x00 2644 80 DUP1 2645 FD *REVERT // Stack delta = +0 // Outputs[1] { @2645 revert(memory[0x00:0x00]); } // Block terminates label_2646: // Incoming jump from 0x2641, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @264A stack[-3] } 2646 5B JUMPDEST 2647 61 PUSH2 0x264f 264A 83 DUP4 264B 61 PUSH2 0x238d 264E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2647 stack[0] = 0x264f // @264A stack[1] = stack[-3] // } // Block ends with call to 0x238d, returns to 0x264F label_264F: // Incoming return from call to 0x22B0 at 0x271E // Incoming return from call to 0x238D at 0x264E // Inputs[3] // { // @2650 stack[-3] // @2650 stack[-1] // @2657 stack[-4] // } 264F 5B JUMPDEST 2650 91 SWAP2 2651 50 POP 2652 61 PUSH2 0x23da 2655 60 PUSH1 0x20 2657 84 DUP5 2658 01 ADD 2659 61 PUSH2 0x22b0 265C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2650 stack[-3] = stack[-1] // @2652 stack[-1] = 0x23da // @2658 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x22b0, returns to 0x23DA label_265D: // Incoming jump from 0x0778 // Inputs[2] // { // @2663 stack[-1] // @2664 stack[-2] // } 265D 5B JUMPDEST 265E 60 PUSH1 0x00 2660 80 DUP1 2661 60 PUSH1 0x40 2663 83 DUP4 2664 85 DUP6 2665 03 SUB 2666 12 SLT 2667 15 ISZERO 2668 61 PUSH2 0x2670 266B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @265E stack[0] = 0x00 // @2660 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2670, if !(stack[-2] - stack[-1] i< 0x40) label_266C: // Incoming jump from 0x266B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @266F memory[0x00:0x00] } 266C 60 PUSH1 0x00 266E 80 DUP1 266F FD *REVERT // Stack delta = +0 // Outputs[1] { @266F revert(memory[0x00:0x00]); } // Block terminates label_2670: // Incoming jump from 0x266B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2674 stack[-3] } 2670 5B JUMPDEST 2671 61 PUSH2 0x2679 2674 83 DUP4 2675 61 PUSH2 0x22b0 2678 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2671 stack[0] = 0x2679 // @2674 stack[1] = stack[-3] // } // Block ends with call to 0x22b0, returns to 0x2679 label_2679: // Incoming return from call to 0x22B0 at 0x2678 // Inputs[3] // { // @267A stack[-3] // @267A stack[-1] // @2681 stack[-4] // } 2679 5B JUMPDEST 267A 91 SWAP2 267B 50 POP 267C 61 PUSH2 0x23da 267F 60 PUSH1 0x20 2681 84 DUP5 2682 01 ADD 2683 61 PUSH2 0x241f 2686 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @267A stack[-3] = stack[-1] // @267C stack[-1] = 0x23da // @2682 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x241f, returns to 0x23DA label_2687: // Incoming call from 0x07B0, returns to 0x07B1 // Inputs[2] // { // @2690 stack[-1] // @2691 stack[-2] // } 2687 5B JUMPDEST 2688 60 PUSH1 0x00 268A 80 DUP1 268B 60 PUSH1 0x00 268D 80 DUP1 268E 60 PUSH1 0x80 2690 85 DUP6 2691 87 DUP8 2692 03 SUB 2693 12 SLT 2694 15 ISZERO 2695 61 PUSH2 0x269d 2698 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2688 stack[0] = 0x00 // @268A stack[1] = 0x00 // @268B stack[2] = 0x00 // @268D stack[3] = 0x00 // } // Block ends with conditional jump to 0x269d, if !(stack[-2] - stack[-1] i< 0x80) label_2699: // Incoming jump from 0x2698, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @269C memory[0x00:0x00] } 2699 60 PUSH1 0x00 269B 80 DUP1 269C FD *REVERT // Stack delta = +0 // Outputs[1] { @269C revert(memory[0x00:0x00]); } // Block terminates label_269D: // Incoming jump from 0x2698, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @26A1 stack[-5] } 269D 5B JUMPDEST 269E 61 PUSH2 0x26a6 26A1 85 DUP6 26A2 61 PUSH2 0x22b0 26A5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @269E stack[0] = 0x26a6 // @26A1 stack[1] = stack[-5] // } // Block ends with call to 0x22b0, returns to 0x26A6 label_26A6: // Incoming return from call to 0x22B0 at 0x26A5 // Inputs[3] // { // @26A7 stack[-5] // @26A7 stack[-1] // @26AE stack[-6] // } 26A6 5B JUMPDEST 26A7 93 SWAP4 26A8 50 POP 26A9 61 PUSH2 0x26b4 26AC 60 PUSH1 0x20 26AE 86 DUP7 26AF 01 ADD 26B0 61 PUSH2 0x22b0 26B3 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @26A7 stack[-5] = stack[-1] // @26A9 stack[-1] = 0x26b4 // @26AF stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x22b0, returns to 0x26B4 label_26B4: // Incoming return from call to 0x22B0 at 0x26B3 // Inputs[6] // { // @26B5 stack[-4] // @26B5 stack[-1] // @26B9 stack[-6] // @26BB msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @26BC stack[-3] // @26C2 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 26B4 5B JUMPDEST 26B5 92 SWAP3 26B6 50 POP 26B7 60 PUSH1 0x40 26B9 85 DUP6 26BA 01 ADD 26BB 35 CALLDATALOAD 26BC 91 SWAP2 26BD 50 POP 26BE 60 PUSH1 0x60 26C0 85 DUP6 26C1 01 ADD 26C2 35 CALLDATALOAD 26C3 67 PUSH8 0xffffffffffffffff 26CC 81 DUP2 26CD 11 GT 26CE 15 ISZERO 26CF 61 PUSH2 0x26d7 26D2 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @26B5 stack[-4] = stack[-1] // @26BC stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @26C2 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x26d7, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_26D3: // Incoming jump from 0x26D2, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @26D6 memory[0x00:0x00] } 26D3 60 PUSH1 0x00 26D5 80 DUP1 26D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @26D6 revert(memory[0x00:0x00]); } // Block terminates label_26D7: // Incoming jump from 0x26D2, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @26D8 stack[-6] // @26D9 stack[-1] // @26DE stack[-7] // } 26D7 5B JUMPDEST 26D8 85 DUP6 26D9 01 ADD 26DA 60 PUSH1 0x1f 26DC 81 DUP2 26DD 01 ADD 26DE 87 DUP8 26DF 13 SGT 26E0 61 PUSH2 0x26e8 26E3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26D9 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x26e8, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_26E4: // Incoming jump from 0x26E3, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @26E7 memory[0x00:0x00] } 26E4 60 PUSH1 0x00 26E6 80 DUP1 26E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @26E7 revert(memory[0x00:0x00]); } // Block terminates label_26E8: // Incoming jump from 0x26E3, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @26EC stack[-7] // @26ED stack[-1] // @26EE msg.data[stack[-1]:stack[-1] + 0x20] // } 26E8 5B JUMPDEST 26E9 61 PUSH2 0x26f7 26EC 87 DUP8 26ED 82 DUP3 26EE 35 CALLDATALOAD 26EF 60 PUSH1 0x20 26F1 84 DUP5 26F2 01 ADD 26F3 61 PUSH2 0x254a 26F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @26E9 stack[0] = 0x26f7 // @26EC stack[1] = stack[-7] // @26EE stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @26F2 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x254a, returns to 0x26F7 label_26F7: // Incoming return from call to 0x254A at 0x26F6 // Inputs[8] // { // @26F8 stack[-1] // @26F8 stack[-3] // @26FB stack[-6] // @26FC stack[-9] // @26FD stack[-5] // @26FE stack[-8] // @2700 stack[-4] // @2700 stack[-7] // } 26F7 5B JUMPDEST 26F8 91 SWAP2 26F9 50 POP 26FA 50 POP 26FB 92 SWAP3 26FC 95 SWAP6 26FD 91 SWAP2 26FE 94 SWAP5 26FF 50 POP 2700 92 SWAP3 2701 50 POP 2702 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @26FB stack[-6] = stack[-1] // @26FC stack[-9] = stack[-6] // @26FE stack[-8] = stack[-5] // @2700 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2703: // Incoming jump from 0x0862 // Inputs[2] // { // @2709 stack[-1] // @270A stack[-2] // } 2703 5B JUMPDEST 2704 60 PUSH1 0x00 2706 80 DUP1 2707 60 PUSH1 0x40 2709 83 DUP4 270A 85 DUP6 270B 03 SUB 270C 12 SLT 270D 15 ISZERO 270E 61 PUSH2 0x2716 2711 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2704 stack[0] = 0x00 // @2706 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2716, if !(stack[-2] - stack[-1] i< 0x40) label_2712: // Incoming jump from 0x2711, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2715 memory[0x00:0x00] } 2712 60 PUSH1 0x00 2714 80 DUP1 2715 FD *REVERT // Stack delta = +0 // Outputs[1] { @2715 revert(memory[0x00:0x00]); } // Block terminates label_2716: // Incoming jump from 0x2711, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @271A stack[-3] } 2716 5B JUMPDEST 2717 61 PUSH2 0x264f 271A 83 DUP4 271B 61 PUSH2 0x22b0 271E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2717 stack[0] = 0x264f // @271A stack[1] = stack[-3] // } // Block ends with call to 0x22b0, returns to 0x264F label_271F: // Incoming call from 0x1649, returns to 0x094B // Incoming call from 0x094A, returns to 0x094B // Incoming call from 0x283E, returns to 0x283F // Incoming call from 0x0976, returns to 0x0977 // Incoming call from 0x220C, returns to 0x094B // Inputs[1] { @2722 stack[-1] } 271F 5B JUMPDEST 2720 60 PUSH1 0x01 2722 81 DUP2 2723 81 DUP2 2724 1C SHR 2725 90 SWAP1 2726 82 DUP3 2727 16 AND 2728 80 DUP1 2729 61 PUSH2 0x2733 272C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2725 stack[0] = stack[-1] >> 0x01 // @2727 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2733, if stack[-1] & 0x01 label_272D: // Incoming jump from 0x272C, if not stack[-1] & 0x01 // Inputs[2] // { // @272F stack[-2] // @2738 stack[-1] // } 272D 60 PUSH1 0x7f 272F 82 DUP3 2730 16 AND 2731 91 SWAP2 2732 50 POP 2733 5B JUMPDEST 2734 60 PUSH1 0x20 2736 82 DUP3 2737 10 LT 2738 81 DUP2 2739 03 SUB 273A 61 PUSH2 0x2753 273D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2731 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2753, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_273E: // Incoming jump from 0x273D, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x273D, if not stack[-1] - (stack[-2] < 0x20) // Inputs[1] { @2752 memory[0x00:0x24] } 273E 63 PUSH4 0x4e487b71 2743 60 PUSH1 0xe0 2745 1B SHL 2746 60 PUSH1 0x00 2748 52 MSTORE 2749 60 PUSH1 0x22 274B 60 PUSH1 0x04 274D 52 MSTORE 274E 60 PUSH1 0x24 2750 60 PUSH1 0x00 2752 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2748 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @274D memory[0x04:0x24] = 0x22 // @2752 revert(memory[0x00:0x24]); // } // Block terminates label_2753: // Incoming jump from 0x273D, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Incoming jump from 0x273D, if stack[-1] - (stack[-2] < 0x20) // Inputs[3] // { // @2755 stack[-4] // @2755 stack[-2] // @2756 stack[-3] // } 2753 5B JUMPDEST 2754 50 POP 2755 91 SWAP2 2756 90 SWAP1 2757 50 POP 2758 56 *JUMP // Stack delta = -3 // Outputs[1] { @2755 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2759: // Incoming jump from 0x130E // Incoming jump from 0x1211 // Incoming jump from 0x131F // Incoming jump from 0x1185 // Incoming jump from 0x1222 // Incoming jump from 0x1550 // Incoming jump from 0x1174 // Incoming jump from 0x1451 // Incoming jump from 0x13A9 // Incoming jump from 0x1398 // Incoming jump from 0x1440 // Incoming jump from 0x0B2C // Incoming jump from 0x0B3D // Inputs[1] { @276E memory[0x00:0x24] } 2759 5B JUMPDEST 275A 63 PUSH4 0x4e487b71 275F 60 PUSH1 0xe0 2761 1B SHL 2762 60 PUSH1 0x00 2764 52 MSTORE 2765 60 PUSH1 0x21 2767 60 PUSH1 0x04 2769 52 MSTORE 276A 60 PUSH1 0x24 276C 60 PUSH1 0x00 276E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2764 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2769 memory[0x04:0x24] = 0x21 // @276E revert(memory[0x00:0x24]); // } // Block terminates label_276F: // Incoming jump from 0x27D0 // Incoming jump from 0x279B // Incoming jump from 0x2986 // Inputs[1] { @2784 memory[0x00:0x24] } 276F 5B JUMPDEST 2770 63 PUSH4 0x4e487b71 2775 60 PUSH1 0xe0 2777 1B SHL 2778 60 PUSH1 0x00 277A 52 MSTORE 277B 60 PUSH1 0x11 277D 60 PUSH1 0x04 277F 52 MSTORE 2780 60 PUSH1 0x24 2782 60 PUSH1 0x00 2784 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @277A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @277F memory[0x04:0x24] = 0x11 // @2784 revert(memory[0x00:0x24]); // } // Block terminates label_2785: // Incoming call from 0x0E12, returns to 0x0E13 // Incoming call from 0x119E, returns to 0x119F // Incoming call from 0x0F45, returns to 0x0F46 // Incoming call from 0x0E12, returns to 0x0E13 // Inputs[2] // { // @2786 stack[-1] // @2787 stack[-2] // } 2785 5B JUMPDEST 2786 80 DUP1 2787 82 DUP3 2788 02 MUL 2789 81 DUP2 278A 15 ISZERO 278B 82 DUP3 278C 82 DUP3 278D 04 DIV 278E 84 DUP5 278F 14 EQ 2790 17 OR 2791 61 PUSH2 0x08cb 2794 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2788 stack[0] = stack[-2] * stack[-1] } // Block ends with conditional jump to 0x08cb, if (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] label_2795: // Incoming jump from 0x2794, if not (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] 2795 61 PUSH2 0x08cb 2798 61 PUSH2 0x276f 279B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2795 stack[0] = 0x08cb } // Block ends with unconditional jump to 0x276f label_279C: // Incoming call from 0x0E1C, returns to 0x0E1D // Inputs[1] { @279F stack[-2] } 279C 5B JUMPDEST 279D 60 PUSH1 0x00 279F 82 DUP3 27A0 61 PUSH2 0x27b9 27A3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @279D stack[0] = 0x00 } // Block ends with conditional jump to 0x27b9, if stack[-2] label_27A4: // Incoming jump from 0x27A3, if not stack[-2] // Inputs[1] { @27B8 memory[0x00:0x24] } 27A4 63 PUSH4 0x4e487b71 27A9 60 PUSH1 0xe0 27AB 1B SHL 27AC 60 PUSH1 0x00 27AE 52 MSTORE 27AF 60 PUSH1 0x12 27B1 60 PUSH1 0x04 27B3 52 MSTORE 27B4 60 PUSH1 0x24 27B6 60 PUSH1 0x00 27B8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @27AE memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @27B3 memory[0x04:0x24] = 0x12 // @27B8 revert(memory[0x00:0x24]); // } // Block terminates label_27B9: // Incoming jump from 0x27A3, if stack[-2] // Inputs[3] // { // @27BB stack[-3] // @27BB stack[-2] // @27BC stack[-4] // } 27B9 5B JUMPDEST 27BA 50 POP 27BB 04 DIV 27BC 90 SWAP1 27BD 56 *JUMP // Stack delta = -3 // Outputs[1] { @27BC stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_27BE: // Incoming call from 0x13D1, returns to 0x13D2 // Incoming call from 0x1491, returns to 0x1492 // Incoming call from 0x1BDA, returns to 0x1BDB // Inputs[2] // { // @27BF stack[-1] // @27C0 stack[-2] // } 27BE 5B JUMPDEST 27BF 80 DUP1 27C0 82 DUP3 27C1 01 ADD 27C2 80 DUP1 27C3 82 DUP3 27C4 11 GT 27C5 15 ISZERO 27C6 61 PUSH2 0x08cb 27C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27C1 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x08cb, if !(stack[-1] > stack[-2] + stack[-1]) label_27CA: // Incoming jump from 0x27C9, if not !(stack[-1] > stack[-2] + stack[-1]) 27CA 61 PUSH2 0x08cb 27CD 61 PUSH2 0x276f 27D0 56 *JUMP // Stack delta = +1 // Outputs[1] { @27CA stack[0] = 0x08cb } // Block ends with unconditional jump to 0x276f label_27D1: // Incoming jump from 0x2844 // Inputs[1] { @27D4 stack[-2] } 27D1 5B JUMPDEST 27D2 60 PUSH1 0x1f 27D4 82 DUP3 27D5 11 GT 27D6 15 ISZERO 27D7 61 PUSH2 0x14f8 27DA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14f8, if !(stack[-2] > 0x1f) label_27DB: // Incoming jump from 0x27DA, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @27DD stack[-1] // @27E3 memory[0x00:0x20] // @27E6 stack[-3] // } 27DB 60 PUSH1 0x00 27DD 81 DUP2 27DE 81 DUP2 27DF 52 MSTORE 27E0 60 PUSH1 0x20 27E2 81 DUP2 27E3 20 SHA3 27E4 60 PUSH1 0x1f 27E6 85 DUP6 27E7 01 ADD 27E8 60 PUSH1 0x05 27EA 1C SHR 27EB 81 DUP2 27EC 01 ADD 27ED 60 PUSH1 0x20 27EF 86 DUP7 27F0 10 LT 27F1 15 ISZERO 27F2 61 PUSH2 0x27f8 27F5 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @27DB stack[0] = 0x00 // @27DF memory[0x00:0x20] = stack[-1] // @27E3 stack[1] = keccak256(memory[0x00:0x20]) // @27EC stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x27f8, if !(stack[-3] < 0x20) label_27F6: // Incoming jump from 0x27F5, if not !(stack[-3] < 0x20) // Inputs[2] // { // @27F7 stack[-2] // @27FB stack[-5] // } 27F6 50 POP 27F7 80 DUP1 27F8 5B JUMPDEST 27F9 60 PUSH1 0x1f 27FB 85 DUP6 27FC 01 ADD 27FD 60 PUSH1 0x05 27FF 1C SHR 2800 82 DUP3 2801 01 ADD 2802 91 SWAP2 2803 50 POP 2804 5B JUMPDEST 2805 81 DUP2 2806 81 DUP2 2807 10 LT 2808 15 ISZERO 2809 61 PUSH2 0x0d4d 280C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @27F7 stack[-1] = stack[-2] // @2802 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x0d4d, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_280D: // Incoming jump from 0x280C, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x280C, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x280C, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @280D stack[-3] // @280E stack[-1] // } 280D 82 DUP3 280E 81 DUP2 280F 55 SSTORE 2810 60 PUSH1 0x01 2812 01 ADD 2813 61 PUSH2 0x2804 2816 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @280F storage[stack[-1]] = stack[-3] // @2812 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2804 label_2817: // Incoming call from 0x1526, returns to 0x150F // Inputs[2] // { // @2818 stack[-2] // @2819 memory[stack[-2]:stack[-2] + 0x20] // } 2817 5B JUMPDEST 2818 81 DUP2 2819 51 MLOAD 281A 67 PUSH8 0xffffffffffffffff 2823 81 DUP2 2824 11 GT 2825 15 ISZERO 2826 61 PUSH2 0x2831 2829 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2819 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2831, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_282A: // Incoming jump from 0x2829, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 282A 61 PUSH2 0x2831 282D 61 PUSH2 0x2534 2830 56 *JUMP // Stack delta = +1 // Outputs[1] { @282A stack[0] = 0x2831 } // Block ends with unconditional jump to 0x2534 label_2831: // Incoming jump from 0x2829, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2835 stack[-1] // @2839 stack[-2] // @283A storage[stack[-2]] // } 2831 5B JUMPDEST 2832 61 PUSH2 0x2845 2835 81 DUP2 2836 61 PUSH2 0x283f 2839 84 DUP5 283A 54 SLOAD 283B 61 PUSH2 0x271f 283E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2832 stack[0] = 0x2845 // @2835 stack[1] = stack[-1] // @2836 stack[2] = 0x283f // @283A stack[3] = storage[stack[-2]] // } // Block ends with call to 0x271f, returns to 0x283F label_283F: // Incoming return from call to 0x271F at 0x283E // Inputs[1] { @2840 stack[-5] } 283F 5B JUMPDEST 2840 84 DUP5 2841 61 PUSH2 0x27d1 2844 56 *JUMP // Stack delta = +1 // Outputs[1] { @2840 stack[0] = stack[-5] } // Block ends with unconditional jump to 0x27d1 label_2845: // Incoming return from call to 0x283F at 0x283E // Inputs[1] { @284B stack[-1] } 2845 5B JUMPDEST 2846 60 PUSH1 0x20 2848 80 DUP1 2849 60 PUSH1 0x1f 284B 83 DUP4 284C 11 GT 284D 60 PUSH1 0x01 284F 81 DUP2 2850 14 EQ 2851 61 PUSH2 0x287a 2854 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2846 stack[0] = 0x20 // @2848 stack[1] = 0x20 // @284C stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x287a, if (stack[-1] > 0x1f) == 0x01 label_2855: // Incoming jump from 0x2854, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @2857 stack[-4] } 2855 60 PUSH1 0x00 2857 84 DUP5 2858 15 ISZERO 2859 61 PUSH2 0x2862 285C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2855 stack[0] = 0x00 } // Block ends with conditional jump to 0x2862, if !stack[-4] label_285D: // Incoming jump from 0x285C, if not !stack[-4] // Inputs[5] // { // @285E stack[-7] // @285F stack[-4] // @2861 memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @2868 stack[-5] // @2874 stack[-6] // } 285D 50 POP 285E 85 DUP6 285F 83 DUP4 2860 01 ADD 2861 51 MLOAD 2862 5B JUMPDEST 2863 60 PUSH1 0x00 2865 19 NOT 2866 60 PUSH1 0x03 2868 86 DUP7 2869 90 SWAP1 286A 1B SHL 286B 1C SHR 286C 19 NOT 286D 16 AND 286E 60 PUSH1 0x01 2870 85 DUP6 2871 90 SWAP1 2872 1B SHL 2873 17 OR 2874 85 DUP6 2875 55 SSTORE 2876 61 PUSH2 0x0d4d 2879 56 *JUMP // Stack delta = -1 // Outputs[1] { @2875 storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x0d4d label_287A: // Incoming jump from 0x2854, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @287D stack[-5] // @2883 memory[0x00:0x20] // @2887 stack[-4] // } 287A 5B JUMPDEST 287B 60 PUSH1 0x00 287D 85 DUP6 287E 81 DUP2 287F 52 MSTORE 2880 60 PUSH1 0x20 2882 81 DUP2 2883 20 SHA3 2884 60 PUSH1 0x1f 2886 19 NOT 2887 86 DUP7 2888 16 AND 2889 91 SWAP2 288A 5B JUMPDEST 288B 82 DUP3 288C 81 DUP2 288D 10 LT 288E 15 ISZERO 288F 61 PUSH2 0x28a9 2892 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @287F memory[0x00:0x20] = stack[-5] // @2883 stack[1] = keccak256(memory[0x00:0x20]) // @2889 stack[0] = stack[-4] & ~0x1f // @2889 stack[2] = 0x00 // } // Block ends with conditional jump to 0x28a9, if !(0x00 < stack[-4] & ~0x1f) label_2893: // Incoming jump from 0x2892, if not !(0x00 < stack[-4] & ~0x1f) // Incoming jump from 0x2892, if not !(stack[-1] < stack[-3]) // Inputs[6] // { // @2893 stack[-9] // @2894 stack[-6] // @2896 memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @2897 stack[-2] // @2899 stack[-1] // @289A stack[-5] // } 2893 88 DUP9 2894 86 DUP7 2895 01 ADD 2896 51 MLOAD 2897 82 DUP3 2898 55 SSTORE 2899 94 SWAP5 289A 84 DUP5 289B 01 ADD 289C 94 SWAP5 289D 60 PUSH1 0x01 289F 90 SWAP1 28A0 91 SWAP2 28A1 01 ADD 28A2 90 SWAP1 28A3 84 DUP5 28A4 01 ADD 28A5 61 PUSH2 0x288a 28A8 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2898 storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @289C stack[-6] = stack[-5] + stack[-6] // @28A2 stack[-2] = stack[-2] + 0x01 // @28A4 stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x288a label_28A9: // Incoming jump from 0x2892, if !(0x00 < stack[-4] & ~0x1f) // Incoming jump from 0x2892, if !(stack[-1] < stack[-3]) // Inputs[2] // { // @28AB stack[-7] // @28AC stack[-3] // } 28A9 5B JUMPDEST 28AA 50 POP 28AB 85 DUP6 28AC 82 DUP3 28AD 10 LT 28AE 15 ISZERO 28AF 61 PUSH2 0x28c7 28B2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x28c7, if !(stack[-3] < stack[-7]) label_28B3: // Incoming jump from 0x28B2, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @28B3 stack[-8] // @28B4 stack[-5] // @28B6 memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @28BC stack[-6] // @28C5 stack[-1] // @28D3 stack[-7] // @28D6 stack[-9] // } 28B3 87 DUP8 28B4 85 DUP6 28B5 01 ADD 28B6 51 MLOAD 28B7 60 PUSH1 0x00 28B9 19 NOT 28BA 60 PUSH1 0x03 28BC 88 DUP9 28BD 90 SWAP1 28BE 1B SHL 28BF 60 PUSH1 0xf8 28C1 16 AND 28C2 1C SHR 28C3 19 NOT 28C4 16 AND 28C5 81 DUP2 28C6 55 SSTORE 28C7 5B JUMPDEST 28C8 50 POP 28C9 50 POP 28CA 50 POP 28CB 50 POP 28CC 50 POP 28CD 60 PUSH1 0x01 28CF 90 SWAP1 28D0 81 DUP2 28D1 1B SHL 28D2 01 ADD 28D3 90 SWAP1 28D4 55 SSTORE 28D5 50 POP 28D6 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @28C6 storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @28D4 storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] 28D7 5B JUMPDEST 28D8 60 PUSH1 0x00 28DA 83 DUP4 28DB 51 MLOAD 28DC 61 PUSH2 0x28e9 28DF 81 DUP2 28E0 84 DUP5 28E1 60 PUSH1 0x20 28E3 88 DUP9 28E4 01 ADD 28E5 61 PUSH2 0x22e7 28E8 56 *JUMP 28E9 5B JUMPDEST 28EA 83 DUP4 28EB 51 MLOAD 28EC 90 SWAP1 28ED 83 DUP4 28EE 01 ADD 28EF 90 SWAP1 28F0 61 PUSH2 0x28fd 28F3 81 DUP2 28F4 83 DUP4 28F5 60 PUSH1 0x20 28F7 88 DUP9 28F8 01 ADD 28F9 61 PUSH2 0x22e7 28FC 56 *JUMP 28FD 5B JUMPDEST 28FE 01 ADD 28FF 94 SWAP5 2900 93 SWAP4 2901 50 POP 2902 50 POP 2903 50 POP 2904 50 POP 2905 56 *JUMP label_2906: // Incoming call from 0x2004, returns to 0x2005 // Inputs[5] // { // @2912 stack[-5] // @2914 stack[-1] // @2917 stack[-4] // @291F stack[-3] // @2933 stack[-2] // } 2906 5B JUMPDEST 2907 60 PUSH1 0x00 2909 60 PUSH1 0x01 290B 60 PUSH1 0x01 290D 60 PUSH1 0xa0 290F 1B SHL 2910 03 SUB 2911 80 DUP1 2912 87 DUP8 2913 16 AND 2914 83 DUP4 2915 52 MSTORE 2916 80 DUP1 2917 86 DUP7 2918 16 AND 2919 60 PUSH1 0x20 291B 84 DUP5 291C 01 ADD 291D 52 MSTORE 291E 50 POP 291F 83 DUP4 2920 60 PUSH1 0x40 2922 83 DUP4 2923 01 ADD 2924 52 MSTORE 2925 60 PUSH1 0x80 2927 60 PUSH1 0x60 2929 83 DUP4 292A 01 ADD 292B 52 MSTORE 292C 61 PUSH2 0x2938 292F 60 PUSH1 0x80 2931 83 DUP4 2932 01 ADD 2933 84 DUP5 2934 61 PUSH2 0x230b 2937 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @2907 stack[0] = 0x00 // @2915 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @291D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2924 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @292B memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @292C stack[1] = 0x2938 // @2932 stack[2] = stack[-1] + 0x80 // @2933 stack[3] = stack[-2] // } // Block ends with call to 0x230b, returns to 0x2938 label_2938: // Incoming return from call to 0x230B at 0x2937 // Inputs[3] // { // @2939 stack[-8] // @2939 stack[-1] // @293A stack[-7] // } 2938 5B JUMPDEST 2939 96 SWAP7 293A 95 SWAP6 293B 50 POP 293C 50 POP 293D 50 POP 293E 50 POP 293F 50 POP 2940 50 POP 2941 56 *JUMP // Stack delta = -7 // Outputs[1] { @2939 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2942: // Incoming jump from 0x203C // Inputs[2] // { // @2947 stack[-1] // @2948 stack[-2] // } 2942 5B JUMPDEST 2943 60 PUSH1 0x00 2945 60 PUSH1 0x20 2947 82 DUP3 2948 84 DUP5 2949 03 SUB 294A 12 SLT 294B 15 ISZERO 294C 61 PUSH2 0x2954 294F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2943 stack[0] = 0x00 } // Block ends with conditional jump to 0x2954, if !(stack[-2] - stack[-1] i< 0x20) label_2950: // Incoming jump from 0x294F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2953 memory[0x00:0x00] } 2950 60 PUSH1 0x00 2952 80 DUP1 2953 FD *REVERT // Stack delta = +0 // Outputs[1] { @2953 revert(memory[0x00:0x00]); } // Block terminates label_2954: // Incoming jump from 0x294F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2955 stack[-2] // @2956 memory[stack[-2]:stack[-2] + 0x20] // } 2954 5B JUMPDEST 2955 81 DUP2 2956 51 MLOAD 2957 61 PUSH2 0x1adb 295A 81 DUP2 295B 61 PUSH2 0x227d 295E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2956 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2957 stack[1] = 0x1adb // @295A stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x227d, returns to 0x1ADB label_295F: // Incoming jump from 0x217B // Inputs[1] { @2974 memory[0x00:0x24] } 295F 5B JUMPDEST 2960 63 PUSH4 0x4e487b71 2965 60 PUSH1 0xe0 2967 1B SHL 2968 60 PUSH1 0x00 296A 52 MSTORE 296B 60 PUSH1 0x32 296D 60 PUSH1 0x04 296F 52 MSTORE 2970 60 PUSH1 0x24 2972 60 PUSH1 0x00 2974 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @296A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @296F memory[0x04:0x24] = 0x32 // @2974 revert(memory[0x00:0x24]); // } // Block terminates label_2975: // Incoming call from 0x2194, returns to 0x2195 // Inputs[1] { @297A stack[-1] } 2975 5B JUMPDEST 2976 60 PUSH1 0x00 2978 60 PUSH1 0x01 297A 82 DUP3 297B 01 ADD 297C 61 PUSH2 0x2987 297F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2976 stack[0] = 0x00 } // Block ends with conditional jump to 0x2987, if stack[-1] + 0x01 label_2980: // Incoming jump from 0x297F, if not stack[-1] + 0x01 2980 61 PUSH2 0x2987 2983 61 PUSH2 0x276f 2986 56 *JUMP // Stack delta = +1 // Outputs[1] { @2980 stack[0] = 0x2987 } // Block ends with unconditional jump to 0x276f label_2987: // Incoming jump from 0x297F, if stack[-1] + 0x01 // Inputs[2] // { // @298B stack[-2] // @298C stack[-3] // } 2987 5B JUMPDEST 2988 50 POP 2989 60 PUSH1 0x01 298B 01 ADD 298C 90 SWAP1 298D 56 *JUMP // Stack delta = -2 // Outputs[1] { @298C stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] 298E FE *ASSERT 298F A2 LOG2 2990 64 PUSH5 0x6970667358 2996 22 22 2997 12 SLT 2998 20 SHA3 2999 38 CODESIZE 299A 37 CALLDATACOPY 299B 99 SWAP10 299C 0E 0E 299D C7 C7 299E A9 A9 299F 54 SLOAD 29A0 E8 E8 29A1 01 ADD 29A2 CB CB 29A3 DE DE 29A4 2A 2A 29A5 81 DUP2 29A6 41 COINBASE 29A7 DA DA 29A8 42 TIMESTAMP 29A9 5B JUMPDEST 29AA 83 DUP4 29AB 8A DUP11 29AC 81 DUP2 29AD 4A 4A 29AE 0D 0D 29AF D6 D6 29B0 C2 C2 29B1 EB EB 29B2 18 XOR 29B3 77 PUSH24 0x14f3b7d77664736f6c63430008110033