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 0x0251 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0251, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x70a08231 0019 11 GT 001A 61 PUSH2 0x0139 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0139, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb071401b 0024 11 GT 0025 61 PUSH2 0x00b6 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00b6, if 0xb071401b > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb071401b > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd5abeb01 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xd5abeb01 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd5abeb01 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd5abeb01 003A 14 EQ 003B 61 PUSH2 0x069d 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x069d, if 0xd5abeb01 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xdb4bec44 0045 14 EQ 0046 61 PUSH2 0x06b3 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b3, if 0xdb4bec44 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xdb4bec44 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe0a80853 0050 14 EQ 0051 61 PUSH2 0x06e3 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e3, if 0xe0a80853 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe0a80853 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x0703 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0703, if 0xe985e9c5 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xefbd73f4 0066 14 EQ 0067 61 PUSH2 0x074c 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x074c, if 0xefbd73f4 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xefbd73f4 == stack[-1] // Inputs[1] { @006B stack[-1] } 006B 80 DUP1 006C 63 PUSH4 0xf2fde38b 0071 14 EQ 0072 61 PUSH2 0x076c 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x076c, if 0xf2fde38b == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0079 memory[0x00:0x00] } 0076 60 PUSH1 0x00 0078 80 DUP1 0079 FD *REVERT // Stack delta = +0 // Outputs[1] { @0079 revert(memory[0x00:0x00]); } // Block terminates label_007A: // Incoming jump from 0x0033, if 0xd5abeb01 > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0xb071401b 0081 14 EQ 0082 61 PUSH2 0x060a 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060a, if 0xb071401b == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xb071401b == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xb767a098 008C 14 EQ 008D 61 PUSH2 0x062a 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x062a, if 0xb767a098 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xb767a098 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xb88d4fde 0097 14 EQ 0098 61 PUSH2 0x064a 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064a, if 0xb88d4fde == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xb88d4fde == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xc87b56dd 00A2 14 EQ 00A3 61 PUSH2 0x066a 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066a, if 0xc87b56dd == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xd2cab056 00AD 14 EQ 00AE 61 PUSH2 0x068a 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x068a, if 0xd2cab056 == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xd2cab056 == stack[-1] // Inputs[1] { @00B5 memory[0x00:0x00] } 00B2 60 PUSH1 0x00 00B4 80 DUP1 00B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B5 revert(memory[0x00:0x00]); } // Block terminates label_00B6: // Incoming jump from 0x0028, if 0xb071401b > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B6 5B JUMPDEST 00B7 80 DUP1 00B8 63 PUSH4 0x94354fd0 00BD 11 GT 00BE 61 PUSH2 0x00fd 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00fd, if 0x94354fd0 > stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x94354fd0 > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x94354fd0 00C8 14 EQ 00C9 61 PUSH2 0x0597 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0597, if 0x94354fd0 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x94354fd0 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x95d89b41 00D3 14 EQ 00D4 61 PUSH2 0x05ad 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ad, if 0x95d89b41 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0xa0712d68 00DE 14 EQ 00DF 61 PUSH2 0x05c2 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c2, if 0xa0712d68 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xa0712d68 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xa22cb465 00E9 14 EQ 00EA 61 PUSH2 0x05d5 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d5, if 0xa22cb465 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0xa45ba8e7 00F4 14 EQ 00F5 61 PUSH2 0x05f5 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f5, if 0xa45ba8e7 == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0xa45ba8e7 == stack[-1] // Inputs[1] { @00FC memory[0x00:0x00] } 00F9 60 PUSH1 0x00 00FB 80 DUP1 00FC FD *REVERT // Stack delta = +0 // Outputs[1] { @00FC revert(memory[0x00:0x00]); } // Block terminates label_00FD: // Incoming jump from 0x00C1, if 0x94354fd0 > stack[-1] // Inputs[1] { @00FE stack[-1] } 00FD 5B JUMPDEST 00FE 80 DUP1 00FF 63 PUSH4 0x70a08231 0104 14 EQ 0105 61 PUSH2 0x0504 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0504, if 0x70a08231 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x70a08231 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x715018a6 010F 14 EQ 0110 61 PUSH2 0x0524 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0524, if 0x715018a6 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x715018a6 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x7cb64759 011A 14 EQ 011B 61 PUSH2 0x0539 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0539, if 0x7cb64759 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x7cb64759 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x7ec4a659 0125 14 EQ 0126 61 PUSH2 0x0559 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0559, if 0x7ec4a659 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x7ec4a659 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x8da5cb5b 0130 14 EQ 0131 61 PUSH2 0x0579 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0579, if 0x8da5cb5b == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0138 memory[0x00:0x00] } 0135 60 PUSH1 0x00 0137 80 DUP1 0138 FD *REVERT // Stack delta = +0 // Outputs[1] { @0138 revert(memory[0x00:0x00]); } // Block terminates label_0139: // Incoming jump from 0x001D, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @013A stack[-1] } 0139 5B JUMPDEST 013A 80 DUP1 013B 63 PUSH4 0x3ccfd60b 0140 11 GT 0141 61 PUSH2 0x01d2 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d2, if 0x3ccfd60b > stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x3ccfd60b > stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x51830227 014B 11 GT 014C 61 PUSH2 0x0196 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0196, if 0x51830227 > stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x51830227 > stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x51830227 0156 14 EQ 0157 61 PUSH2 0x0461 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0461, if 0x51830227 == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x51830227 == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x5503a0e8 0161 14 EQ 0162 61 PUSH2 0x0481 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0481, if 0x5503a0e8 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x5503a0e8 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x5c975abb 016C 14 EQ 016D 61 PUSH2 0x0496 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0496, if 0x5c975abb == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x5c975abb == stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x62b99ad4 0177 14 EQ 0178 61 PUSH2 0x04b0 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b0, if 0x62b99ad4 == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x62b99ad4 == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x6352211e 0182 14 EQ 0183 61 PUSH2 0x04c5 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c5, if 0x6352211e == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x6352211e == stack[-1] // Inputs[1] { @0187 stack[-1] } 0187 80 DUP1 0188 63 PUSH4 0x6caede3d 018D 14 EQ 018E 61 PUSH2 0x04e5 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e5, if 0x6caede3d == stack[-1] label_0192: // Incoming jump from 0x0191, if not 0x6caede3d == stack[-1] // Inputs[1] { @0195 memory[0x00:0x00] } 0192 60 PUSH1 0x00 0194 80 DUP1 0195 FD *REVERT // Stack delta = +0 // Outputs[1] { @0195 revert(memory[0x00:0x00]); } // Block terminates label_0196: // Incoming jump from 0x014F, if 0x51830227 > stack[-1] // Inputs[1] { @0197 stack[-1] } 0196 5B JUMPDEST 0197 80 DUP1 0198 63 PUSH4 0x3ccfd60b 019D 14 EQ 019E 61 PUSH2 0x03bf 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03bf, if 0x3ccfd60b == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A2 80 DUP1 01A3 63 PUSH4 0x42842e0e 01A8 14 EQ 01A9 61 PUSH2 0x03d4 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d4, if 0x42842e0e == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x42842e0e == stack[-1] // Inputs[1] { @01AD stack[-1] } 01AD 80 DUP1 01AE 63 PUSH4 0x438b6300 01B3 14 EQ 01B4 61 PUSH2 0x03f4 01B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f4, if 0x438b6300 == stack[-1] label_01B8: // Incoming jump from 0x01B7, if not 0x438b6300 == stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B8 80 DUP1 01B9 63 PUSH4 0x44a0d68a 01BE 14 EQ 01BF 61 PUSH2 0x0421 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0421, if 0x44a0d68a == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x44a0d68a == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x4fdd43cb 01C9 14 EQ 01CA 61 PUSH2 0x0441 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0441, if 0x4fdd43cb == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x4fdd43cb == stack[-1] // Inputs[1] { @01D1 memory[0x00:0x00] } 01CE 60 PUSH1 0x00 01D0 80 DUP1 01D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D1 revert(memory[0x00:0x00]); } // Block terminates label_01D2: // Incoming jump from 0x0144, if 0x3ccfd60b > stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D2 5B JUMPDEST 01D3 80 DUP1 01D4 63 PUSH4 0x16ba10e0 01D9 11 GT 01DA 61 PUSH2 0x0219 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0219, if 0x16ba10e0 > stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x16ba10e0 > stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x16ba10e0 01E4 14 EQ 01E5 61 PUSH2 0x032b 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032b, if 0x16ba10e0 == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x16ba10e0 == stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x16c38b3c 01EF 14 EQ 01F0 61 PUSH2 0x034b 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034b, if 0x16c38b3c == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x16c38b3c == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x18160ddd 01FA 14 EQ 01FB 61 PUSH2 0x036b 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036b, if 0x18160ddd == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x18160ddd == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x23b872dd 0205 14 EQ 0206 61 PUSH2 0x0389 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0389, if 0x23b872dd == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x23b872dd == stack[-1] // Inputs[1] { @020A stack[-1] } 020A 80 DUP1 020B 63 PUSH4 0x2eb4a7ab 0210 14 EQ 0211 61 PUSH2 0x03a9 0214 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a9, if 0x2eb4a7ab == stack[-1] label_0215: // Incoming jump from 0x0214, if not 0x2eb4a7ab == stack[-1] // Inputs[1] { @0218 memory[0x00:0x00] } 0215 60 PUSH1 0x00 0217 80 DUP1 0218 FD *REVERT // Stack delta = +0 // Outputs[1] { @0218 revert(memory[0x00:0x00]); } // Block terminates label_0219: // Incoming jump from 0x01DD, if 0x16ba10e0 > stack[-1] // Inputs[1] { @021A stack[-1] } 0219 5B JUMPDEST 021A 80 DUP1 021B 63 PUSH4 0x01ffc9a7 0220 14 EQ 0221 61 PUSH2 0x0256 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0256, if 0x01ffc9a7 == stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0225 stack[-1] } 0225 80 DUP1 0226 63 PUSH4 0x06fdde03 022B 14 EQ 022C 61 PUSH2 0x028b 022F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028b, if 0x06fdde03 == stack[-1] label_0230: // Incoming jump from 0x022F, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0230 stack[-1] } 0230 80 DUP1 0231 63 PUSH4 0x081812fc 0236 14 EQ 0237 61 PUSH2 0x02ad 023A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ad, if 0x081812fc == stack[-1] label_023B: // Incoming jump from 0x023A, if not 0x081812fc == stack[-1] // Inputs[1] { @023B stack[-1] } 023B 80 DUP1 023C 63 PUSH4 0x095ea7b3 0241 14 EQ 0242 61 PUSH2 0x02e5 0245 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e5, if 0x095ea7b3 == stack[-1] label_0246: // Incoming jump from 0x0245, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0246 stack[-1] } 0246 80 DUP1 0247 63 PUSH4 0x13faede6 024C 14 EQ 024D 61 PUSH2 0x0307 0250 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0307, if 0x13faede6 == stack[-1] label_0251: // Incoming jump from 0x0250, if not 0x13faede6 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @0255 memory[0x00:0x00] } 0251 5B JUMPDEST 0252 60 PUSH1 0x00 0254 80 DUP1 0255 FD *REVERT // Stack delta = +0 // Outputs[1] { @0255 revert(memory[0x00:0x00]); } // Block terminates label_0256: // Incoming jump from 0x0224, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0257 msg.value } 0256 5B JUMPDEST 0257 34 CALLVALUE 0258 80 DUP1 0259 15 ISZERO 025A 61 PUSH2 0x0262 025D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0257 stack[0] = msg.value } // Block ends with conditional jump to 0x0262, if !msg.value label_025E: // Incoming jump from 0x025D, if not !msg.value // Inputs[1] { @0261 memory[0x00:0x00] } 025E 60 PUSH1 0x00 0260 80 DUP1 0261 FD *REVERT // Stack delta = +0 // Outputs[1] { @0261 revert(memory[0x00:0x00]); } // Block terminates label_0262: // Incoming jump from 0x025D, if !msg.value // Inputs[1] { @026A msg.data.length } 0262 5B JUMPDEST 0263 50 POP 0264 61 PUSH2 0x0276 0267 61 PUSH2 0x0271 026A 36 CALLDATASIZE 026B 60 PUSH1 0x04 026D 61 PUSH2 0x1f53 0270 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0264 stack[-1] = 0x0276 // @0267 stack[0] = 0x0271 // @026A stack[1] = msg.data.length // @026B stack[2] = 0x04 // } // Block ends with call to 0x1f53, returns to 0x0271 label_0271: // Incoming return from call to 0x1F53 at 0x0270 0271 5B JUMPDEST 0272 61 PUSH2 0x078c 0275 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x078c label_0276: // Incoming jump from 0x0503 // Incoming jump from 0x0480 // Incoming return from call to 0x06CE at 0x06CD // Incoming jump from 0x04AF // Incoming return from call to 0x0271 at 0x0270 // Inputs[4] // { // @0279 memory[0x40:0x60] // @027A stack[-1] // @0285 memory[0x40:0x60] // @028A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0276 5B JUMPDEST 0277 60 PUSH1 0x40 0279 51 MLOAD 027A 90 SWAP1 027B 15 ISZERO 027C 15 ISZERO 027D 81 DUP2 027E 52 MSTORE 027F 60 PUSH1 0x20 0281 01 ADD 0282 5B JUMPDEST 0283 60 PUSH1 0x40 0285 51 MLOAD 0286 80 DUP1 0287 91 SWAP2 0288 03 SUB 0289 90 SWAP1 028A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @027E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @028A return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_028B: // Incoming jump from 0x022F, if 0x06fdde03 == stack[-1] // Inputs[1] { @028C msg.value } 028B 5B JUMPDEST 028C 34 CALLVALUE 028D 80 DUP1 028E 15 ISZERO 028F 61 PUSH2 0x0297 0292 57 *JUMPI // Stack delta = +1 // Outputs[1] { @028C stack[0] = msg.value } // Block ends with conditional jump to 0x0297, if !msg.value label_0293: // Incoming jump from 0x0292, if not !msg.value // Inputs[1] { @0296 memory[0x00:0x00] } 0293 60 PUSH1 0x00 0295 80 DUP1 0296 FD *REVERT // Stack delta = +0 // Outputs[1] { @0296 revert(memory[0x00:0x00]); } // Block terminates label_0297: // Incoming jump from 0x0292, if !msg.value 0297 5B JUMPDEST 0298 50 POP 0299 61 PUSH2 0x02a0 029C 61 PUSH2 0x07de 029F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0299 stack[-1] = 0x02a0 } // Block ends with call to 0x07de, returns to 0x02A0 label_02A0: // Incoming return from call to 0x0E3A at 0x05C1 // Incoming return from call to 0x07DE at 0x029F // Incoming return from call to 0x0C9D at 0x0495 // Incoming return from call to 0x0FFC at 0x0609 // Incoming return from call to 0x0685 at 0x0684 // Incoming return from call to 0x0D2B at 0x04C4 // Inputs[2] // { // @02A3 memory[0x40:0x60] // @02A7 stack[-1] // } 02A0 5B JUMPDEST 02A1 60 PUSH1 0x40 02A3 51 MLOAD 02A4 61 PUSH2 0x0282 02A7 91 SWAP2 02A8 90 SWAP1 02A9 61 PUSH2 0x1fc8 02AC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02A7 stack[-1] = 0x0282 // @02A8 stack[1] = memory[0x40:0x60] // @02A8 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1fc8 label_02AD: // Incoming jump from 0x023A, if 0x081812fc == stack[-1] // Inputs[1] { @02AE msg.value } 02AD 5B JUMPDEST 02AE 34 CALLVALUE 02AF 80 DUP1 02B0 15 ISZERO 02B1 61 PUSH2 0x02b9 02B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02AE stack[0] = msg.value } // Block ends with conditional jump to 0x02b9, if !msg.value label_02B5: // Incoming jump from 0x02B4, if not !msg.value // Inputs[1] { @02B8 memory[0x00:0x00] } 02B5 60 PUSH1 0x00 02B7 80 DUP1 02B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B8 revert(memory[0x00:0x00]); } // Block terminates label_02B9: // Incoming jump from 0x02B4, if !msg.value // Inputs[1] { @02C1 msg.data.length } 02B9 5B JUMPDEST 02BA 50 POP 02BB 61 PUSH2 0x02cd 02BE 61 PUSH2 0x02c8 02C1 36 CALLDATASIZE 02C2 60 PUSH1 0x04 02C4 61 PUSH2 0x1fdb 02C7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02BB stack[-1] = 0x02cd // @02BE stack[0] = 0x02c8 // @02C1 stack[1] = msg.data.length // @02C2 stack[2] = 0x04 // } // Block ends with call to 0x1fdb, returns to 0x02C8 label_02C8: // Incoming return from call to 0x1FDB at 0x02C7 02C8 5B JUMPDEST 02C9 61 PUSH2 0x0870 02CC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0870 label_02CD: // Incoming return from call to 0x04E0 at 0x04DF // Incoming jump from 0x0596 // Incoming return from call to 0x02C8 at 0x02C7 // Inputs[2] // { // @02D0 memory[0x40:0x60] // @02DA stack[-1] // } 02CD 5B JUMPDEST 02CE 60 PUSH1 0x40 02D0 51 MLOAD 02D1 60 PUSH1 0x01 02D3 60 PUSH1 0x01 02D5 60 PUSH1 0xa0 02D7 1B SHL 02D8 03 SUB 02D9 90 SWAP1 02DA 91 SWAP2 02DB 16 AND 02DC 81 DUP2 02DD 52 MSTORE 02DE 60 PUSH1 0x20 02E0 01 ADD 02E1 61 PUSH2 0x0282 02E4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02E0 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0282 label_02E5: // Incoming jump from 0x0245, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02E6 msg.value } 02E5 5B JUMPDEST 02E6 34 CALLVALUE 02E7 80 DUP1 02E8 15 ISZERO 02E9 61 PUSH2 0x02f1 02EC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E6 stack[0] = msg.value } // Block ends with conditional jump to 0x02f1, if !msg.value label_02ED: // Incoming jump from 0x02EC, if not !msg.value // Inputs[1] { @02F0 memory[0x00:0x00] } 02ED 60 PUSH1 0x00 02EF 80 DUP1 02F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F0 revert(memory[0x00:0x00]); } // Block terminates label_02F1: // Incoming jump from 0x02EC, if !msg.value // Inputs[1] { @02F9 msg.data.length } 02F1 5B JUMPDEST 02F2 50 POP 02F3 61 PUSH2 0x0305 02F6 61 PUSH2 0x0300 02F9 36 CALLDATASIZE 02FA 60 PUSH1 0x04 02FC 61 PUSH2 0x2010 02FF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02F3 stack[-1] = 0x0305 // @02F6 stack[0] = 0x0300 // @02F9 stack[1] = msg.data.length // @02FA stack[2] = 0x04 // } // Block ends with call to 0x2010, returns to 0x0300 label_0300: // Incoming return from call to 0x2010 at 0x02FF 0300 5B JUMPDEST 0301 61 PUSH2 0x08b4 0304 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08b4 label_0305: // Incoming return from call to 0x0300 at 0x02FF // Incoming return from call to 0x0625 at 0x0624 // Incoming return from call to 0x0698 at 0x0697 // Incoming return from call to 0x0D98 at 0x0538 // Incoming return from call to 0x06FE at 0x06FD // Incoming return from call to 0x09D4 at 0x03D3 // Incoming return from call to 0x0554 at 0x0553 // Incoming return from call to 0x0645 at 0x0644 // Incoming return from call to 0x043C at 0x043B // Incoming return from call to 0x0366 at 0x0365 0305 5B JUMPDEST 0306 00 *STOP // Stack delta = +0 // Outputs[1] { @0306 stop(); } // Block terminates label_0307: // Incoming jump from 0x0250, if 0x13faede6 == stack[-1] // Inputs[1] { @0308 msg.value } 0307 5B JUMPDEST 0308 34 CALLVALUE 0309 80 DUP1 030A 15 ISZERO 030B 61 PUSH2 0x0313 030E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0308 stack[0] = msg.value } // Block ends with conditional jump to 0x0313, if !msg.value label_030F: // Incoming jump from 0x030E, if not !msg.value // Inputs[1] { @0312 memory[0x00:0x00] } 030F 60 PUSH1 0x00 0311 80 DUP1 0312 FD *REVERT // Stack delta = +0 // Outputs[1] { @0312 revert(memory[0x00:0x00]); } // Block terminates label_0313: // Incoming jump from 0x030E, if !msg.value // Inputs[1] { @031A storage[0x0f] } 0313 5B JUMPDEST 0314 50 POP 0315 61 PUSH2 0x031d 0318 60 PUSH1 0x0f 031A 54 SLOAD 031B 81 DUP2 031C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0315 stack[-1] = 0x031d // @031A stack[0] = storage[0x0f] // } // Block ends with unconditional jump to 0x031d label_031D: // Incoming jump from 0x03BE // Incoming jump from 0x06B2 // Incoming return from call to 0x051F at 0x051E // Incoming jump from 0x031C // Incoming jump from 0x0388 // Incoming jump from 0x05AC // Inputs[2] // { // @0320 memory[0x40:0x60] // @0321 stack[-1] // } 031D 5B JUMPDEST 031E 60 PUSH1 0x40 0320 51 MLOAD 0321 90 SWAP1 0322 81 DUP2 0323 52 MSTORE 0324 60 PUSH1 0x20 0326 01 ADD 0327 61 PUSH2 0x0282 032A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0323 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0326 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0282 label_032B: // Incoming jump from 0x01E8, if 0x16ba10e0 == stack[-1] // Inputs[1] { @032C msg.value } 032B 5B JUMPDEST 032C 34 CALLVALUE 032D 80 DUP1 032E 15 ISZERO 032F 61 PUSH2 0x0337 0332 57 *JUMPI // Stack delta = +1 // Outputs[1] { @032C stack[0] = msg.value } // Block ends with conditional jump to 0x0337, if !msg.value label_0333: // Incoming jump from 0x0332, if not !msg.value // Inputs[1] { @0336 memory[0x00:0x00] } 0333 60 PUSH1 0x00 0335 80 DUP1 0336 FD *REVERT // Stack delta = +0 // Outputs[1] { @0336 revert(memory[0x00:0x00]); } // Block terminates label_0337: // Incoming jump from 0x0332, if !msg.value // Inputs[1] { @033F msg.data.length } 0337 5B JUMPDEST 0338 50 POP 0339 61 PUSH2 0x0305 033C 61 PUSH2 0x0346 033F 36 CALLDATASIZE 0340 60 PUSH1 0x04 0342 61 PUSH2 0x20c5 0345 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0339 stack[-1] = 0x0305 // @033C stack[0] = 0x0346 // @033F stack[1] = msg.data.length // @0340 stack[2] = 0x04 // } // Block ends with call to 0x20c5, returns to 0x0346 label_0346: // Incoming return from call to 0x20C5 at 0x0345 0346 5B JUMPDEST 0347 61 PUSH2 0x0942 034A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0942 label_034B: // Incoming jump from 0x01F3, if 0x16c38b3c == stack[-1] // Inputs[1] { @034C msg.value } 034B 5B JUMPDEST 034C 34 CALLVALUE 034D 80 DUP1 034E 15 ISZERO 034F 61 PUSH2 0x0357 0352 57 *JUMPI // Stack delta = +1 // Outputs[1] { @034C stack[0] = msg.value } // Block ends with conditional jump to 0x0357, if !msg.value label_0353: // Incoming jump from 0x0352, if not !msg.value // Inputs[1] { @0356 memory[0x00:0x00] } 0353 60 PUSH1 0x00 0355 80 DUP1 0356 FD *REVERT // Stack delta = +0 // Outputs[1] { @0356 revert(memory[0x00:0x00]); } // Block terminates label_0357: // Incoming jump from 0x0352, if !msg.value // Inputs[1] { @035F msg.data.length } 0357 5B JUMPDEST 0358 50 POP 0359 61 PUSH2 0x0305 035C 61 PUSH2 0x0366 035F 36 CALLDATASIZE 0360 60 PUSH1 0x04 0362 61 PUSH2 0x211d 0365 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0359 stack[-1] = 0x0305 // @035C stack[0] = 0x0366 // @035F stack[1] = msg.data.length // @0360 stack[2] = 0x04 // } // Block ends with call to 0x211d, returns to 0x0366 label_0366: // Incoming return from call to 0x211D at 0x0365 0366 5B JUMPDEST 0367 61 PUSH2 0x098c 036A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x098c label_036B: // Incoming jump from 0x01FE, if 0x18160ddd == stack[-1] // Inputs[1] { @036C msg.value } 036B 5B JUMPDEST 036C 34 CALLVALUE 036D 80 DUP1 036E 15 ISZERO 036F 61 PUSH2 0x0377 0372 57 *JUMPI // Stack delta = +1 // Outputs[1] { @036C stack[0] = msg.value } // Block ends with conditional jump to 0x0377, if !msg.value label_0373: // Incoming jump from 0x0372, if not !msg.value // Inputs[1] { @0376 memory[0x00:0x00] } 0373 60 PUSH1 0x00 0375 80 DUP1 0376 FD *REVERT // Stack delta = +0 // Outputs[1] { @0376 revert(memory[0x00:0x00]); } // Block terminates label_0377: // Incoming jump from 0x0372, if !msg.value // Inputs[2] // { // @037E storage[0x01] // @0381 storage[0x00] // } 0377 5B JUMPDEST 0378 50 POP 0379 61 PUSH2 0x031d 037C 60 PUSH1 0x01 037E 54 SLOAD 037F 60 PUSH1 0x00 0381 54 SLOAD 0382 03 SUB 0383 60 PUSH1 0x00 0385 19 NOT 0386 01 ADD 0387 90 SWAP1 0388 56 *JUMP // Stack delta = +0 // Outputs[1] { @0387 stack[-1] = ~0x00 + (storage[0x00] - storage[0x01]) } // Block ends with unconditional jump to 0x031d label_0389: // Incoming jump from 0x0209, if 0x23b872dd == stack[-1] // Inputs[1] { @038A msg.value } 0389 5B JUMPDEST 038A 34 CALLVALUE 038B 80 DUP1 038C 15 ISZERO 038D 61 PUSH2 0x0395 0390 57 *JUMPI // Stack delta = +1 // Outputs[1] { @038A stack[0] = msg.value } // Block ends with conditional jump to 0x0395, if !msg.value label_0391: // Incoming jump from 0x0390, if not !msg.value // Inputs[1] { @0394 memory[0x00:0x00] } 0391 60 PUSH1 0x00 0393 80 DUP1 0394 FD *REVERT // Stack delta = +0 // Outputs[1] { @0394 revert(memory[0x00:0x00]); } // Block terminates label_0395: // Incoming jump from 0x0390, if !msg.value // Inputs[1] { @039D msg.data.length } 0395 5B JUMPDEST 0396 50 POP 0397 61 PUSH2 0x0305 039A 61 PUSH2 0x03a4 039D 36 CALLDATASIZE 039E 60 PUSH1 0x04 03A0 61 PUSH2 0x2138 03A3 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0397 stack[-1] = 0x0305 // @039A stack[0] = 0x03a4 // @039D stack[1] = msg.data.length // @039E stack[2] = 0x04 // } // Block ends with call to 0x2138, returns to 0x03A4 label_03A4: // Incoming return from call to 0x2138 at 0x03A3 03A4 5B JUMPDEST 03A5 61 PUSH2 0x09c9 03A8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09c9 label_03A9: // Incoming jump from 0x0214, if 0x2eb4a7ab == stack[-1] // Inputs[1] { @03AA msg.value } 03A9 5B JUMPDEST 03AA 34 CALLVALUE 03AB 80 DUP1 03AC 15 ISZERO 03AD 61 PUSH2 0x03b5 03B0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AA stack[0] = msg.value } // Block ends with conditional jump to 0x03b5, if !msg.value label_03B1: // Incoming jump from 0x03B0, if not !msg.value // Inputs[1] { @03B4 memory[0x00:0x00] } 03B1 60 PUSH1 0x00 03B3 80 DUP1 03B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B4 revert(memory[0x00:0x00]); } // Block terminates label_03B5: // Incoming jump from 0x03B0, if !msg.value // Inputs[1] { @03BC storage[0x0a] } 03B5 5B JUMPDEST 03B6 50 POP 03B7 61 PUSH2 0x031d 03BA 60 PUSH1 0x0a 03BC 54 SLOAD 03BD 81 DUP2 03BE 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03B7 stack[-1] = 0x031d // @03BC stack[0] = storage[0x0a] // } // Block ends with unconditional jump to 0x031d label_03BF: // Incoming jump from 0x01A1, if 0x3ccfd60b == stack[-1] // Inputs[1] { @03C0 msg.value } 03BF 5B JUMPDEST 03C0 34 CALLVALUE 03C1 80 DUP1 03C2 15 ISZERO 03C3 61 PUSH2 0x03cb 03C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C0 stack[0] = msg.value } // Block ends with conditional jump to 0x03cb, if !msg.value label_03C7: // Incoming jump from 0x03C6, if not !msg.value // Inputs[1] { @03CA memory[0x00:0x00] } 03C7 60 PUSH1 0x00 03C9 80 DUP1 03CA FD *REVERT // Stack delta = +0 // Outputs[1] { @03CA revert(memory[0x00:0x00]); } // Block terminates label_03CB: // Incoming jump from 0x03C6, if !msg.value 03CB 5B JUMPDEST 03CC 50 POP 03CD 61 PUSH2 0x0305 03D0 61 PUSH2 0x09d4 03D3 56 *JUMP // Stack delta = +0 // Outputs[1] { @03CD stack[-1] = 0x0305 } // Block ends with call to 0x09d4, returns to 0x0305 label_03D4: // Incoming jump from 0x01AC, if 0x42842e0e == stack[-1] // Inputs[1] { @03D5 msg.value } 03D4 5B JUMPDEST 03D5 34 CALLVALUE 03D6 80 DUP1 03D7 15 ISZERO 03D8 61 PUSH2 0x03e0 03DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D5 stack[0] = msg.value } // Block ends with conditional jump to 0x03e0, if !msg.value label_03DC: // Incoming jump from 0x03DB, if not !msg.value // Inputs[1] { @03DF memory[0x00:0x00] } 03DC 60 PUSH1 0x00 03DE 80 DUP1 03DF FD *REVERT // Stack delta = +0 // Outputs[1] { @03DF revert(memory[0x00:0x00]); } // Block terminates label_03E0: // Incoming jump from 0x03DB, if !msg.value // Inputs[1] { @03E8 msg.data.length } 03E0 5B JUMPDEST 03E1 50 POP 03E2 61 PUSH2 0x0305 03E5 61 PUSH2 0x03ef 03E8 36 CALLDATASIZE 03E9 60 PUSH1 0x04 03EB 61 PUSH2 0x2138 03EE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03E2 stack[-1] = 0x0305 // @03E5 stack[0] = 0x03ef // @03E8 stack[1] = msg.data.length // @03E9 stack[2] = 0x04 // } // Block ends with call to 0x2138, returns to 0x03EF label_03EF: // Incoming return from call to 0x2138 at 0x03EE 03EF 5B JUMPDEST 03F0 61 PUSH2 0x0acf 03F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0acf label_03F4: // Incoming jump from 0x01B7, if 0x438b6300 == stack[-1] // Inputs[1] { @03F5 msg.value } 03F4 5B JUMPDEST 03F5 34 CALLVALUE 03F6 80 DUP1 03F7 15 ISZERO 03F8 61 PUSH2 0x0400 03FB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F5 stack[0] = msg.value } // Block ends with conditional jump to 0x0400, if !msg.value label_03FC: // Incoming jump from 0x03FB, if not !msg.value // Inputs[1] { @03FF memory[0x00:0x00] } 03FC 60 PUSH1 0x00 03FE 80 DUP1 03FF FD *REVERT // Stack delta = +0 // Outputs[1] { @03FF revert(memory[0x00:0x00]); } // Block terminates label_0400: // Incoming jump from 0x03FB, if !msg.value // Inputs[1] { @0408 msg.data.length } 0400 5B JUMPDEST 0401 50 POP 0402 61 PUSH2 0x0414 0405 61 PUSH2 0x040f 0408 36 CALLDATASIZE 0409 60 PUSH1 0x04 040B 61 PUSH2 0x2174 040E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0402 stack[-1] = 0x0414 // @0405 stack[0] = 0x040f // @0408 stack[1] = msg.data.length // @0409 stack[2] = 0x04 // } // Block ends with call to 0x2174, returns to 0x040F label_040F: // Incoming return from call to 0x2174 at 0x040E 040F 5B JUMPDEST 0410 61 PUSH2 0x0aea 0413 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0aea label_0414: // Incoming return from call to 0x040F at 0x040E // Inputs[2] // { // @0417 memory[0x40:0x60] // @041B stack[-1] // } 0414 5B JUMPDEST 0415 60 PUSH1 0x40 0417 51 MLOAD 0418 61 PUSH2 0x0282 041B 91 SWAP2 041C 90 SWAP1 041D 61 PUSH2 0x218f 0420 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @041B stack[-1] = 0x0282 // @041C stack[1] = memory[0x40:0x60] // @041C stack[0] = stack[-1] // } // Block ends with call to 0x218f, returns to 0x0282 label_0421: // Incoming jump from 0x01C2, if 0x44a0d68a == stack[-1] // Inputs[1] { @0422 msg.value } 0421 5B JUMPDEST 0422 34 CALLVALUE 0423 80 DUP1 0424 15 ISZERO 0425 61 PUSH2 0x042d 0428 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0422 stack[0] = msg.value } // Block ends with conditional jump to 0x042d, if !msg.value label_0429: // Incoming jump from 0x0428, if not !msg.value // Inputs[1] { @042C memory[0x00:0x00] } 0429 60 PUSH1 0x00 042B 80 DUP1 042C FD *REVERT // Stack delta = +0 // Outputs[1] { @042C revert(memory[0x00:0x00]); } // Block terminates label_042D: // Incoming jump from 0x0428, if !msg.value // Inputs[1] { @0435 msg.data.length } 042D 5B JUMPDEST 042E 50 POP 042F 61 PUSH2 0x0305 0432 61 PUSH2 0x043c 0435 36 CALLDATASIZE 0436 60 PUSH1 0x04 0438 61 PUSH2 0x1fdb 043B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @042F stack[-1] = 0x0305 // @0432 stack[0] = 0x043c // @0435 stack[1] = msg.data.length // @0436 stack[2] = 0x04 // } // Block ends with call to 0x1fdb, returns to 0x043C label_043C: // Incoming return from call to 0x1FDB at 0x043B 043C 5B JUMPDEST 043D 61 PUSH2 0x0c31 0440 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c31 label_0441: // Incoming jump from 0x01CD, if 0x4fdd43cb == stack[-1] // Inputs[1] { @0442 msg.value } 0441 5B JUMPDEST 0442 34 CALLVALUE 0443 80 DUP1 0444 15 ISZERO 0445 61 PUSH2 0x044d 0448 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0442 stack[0] = msg.value } // Block ends with conditional jump to 0x044d, if !msg.value label_0449: // Incoming jump from 0x0448, if not !msg.value // Inputs[1] { @044C memory[0x00:0x00] } 0449 60 PUSH1 0x00 044B 80 DUP1 044C FD *REVERT // Stack delta = +0 // Outputs[1] { @044C revert(memory[0x00:0x00]); } // Block terminates label_044D: // Incoming jump from 0x0448, if !msg.value // Inputs[1] { @0455 msg.data.length } 044D 5B JUMPDEST 044E 50 POP 044F 61 PUSH2 0x0305 0452 61 PUSH2 0x045c 0455 36 CALLDATASIZE 0456 60 PUSH1 0x04 0458 61 PUSH2 0x20c5 045B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @044F stack[-1] = 0x0305 // @0452 stack[0] = 0x045c // @0455 stack[1] = msg.data.length // @0456 stack[2] = 0x04 // } // Block ends with call to 0x20c5, returns to 0x045C label_045C: // Incoming return from call to 0x20C5 at 0x045B 045C 5B JUMPDEST 045D 61 PUSH2 0x0c60 0460 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c60 label_0461: // Incoming jump from 0x015A, if 0x51830227 == stack[-1] // Inputs[1] { @0462 msg.value } 0461 5B JUMPDEST 0462 34 CALLVALUE 0463 80 DUP1 0464 15 ISZERO 0465 61 PUSH2 0x046d 0468 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0462 stack[0] = msg.value } // Block ends with conditional jump to 0x046d, if !msg.value label_0469: // Incoming jump from 0x0468, if not !msg.value // Inputs[1] { @046C memory[0x00:0x00] } 0469 60 PUSH1 0x00 046B 80 DUP1 046C FD *REVERT // Stack delta = +0 // Outputs[1] { @046C revert(memory[0x00:0x00]); } // Block terminates label_046D: // Incoming jump from 0x0468, if !msg.value // Inputs[1] { @0471 storage[0x12] } 046D 5B JUMPDEST 046E 50 POP 046F 60 PUSH1 0x12 0471 54 SLOAD 0472 61 PUSH2 0x0276 0475 90 SWAP1 0476 62 PUSH3 0x010000 047A 90 SWAP1 047B 04 DIV 047C 60 PUSH1 0xff 047E 16 AND 047F 81 DUP2 0480 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0475 stack[-1] = 0x0276 // @047E stack[0] = 0xff & storage[0x12] / 0x010000 // } // Block ends with unconditional jump to 0x0276 label_0481: // Incoming jump from 0x0165, if 0x5503a0e8 == stack[-1] // Inputs[1] { @0482 msg.value } 0481 5B JUMPDEST 0482 34 CALLVALUE 0483 80 DUP1 0484 15 ISZERO 0485 61 PUSH2 0x048d 0488 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0482 stack[0] = msg.value } // Block ends with conditional jump to 0x048d, if !msg.value label_0489: // Incoming jump from 0x0488, if not !msg.value // Inputs[1] { @048C memory[0x00:0x00] } 0489 60 PUSH1 0x00 048B 80 DUP1 048C FD *REVERT // Stack delta = +0 // Outputs[1] { @048C revert(memory[0x00:0x00]); } // Block terminates label_048D: // Incoming jump from 0x0488, if !msg.value 048D 5B JUMPDEST 048E 50 POP 048F 61 PUSH2 0x02a0 0492 61 PUSH2 0x0c9d 0495 56 *JUMP // Stack delta = +0 // Outputs[1] { @048F stack[-1] = 0x02a0 } // Block ends with call to 0x0c9d, returns to 0x02A0 label_0496: // Incoming jump from 0x0170, if 0x5c975abb == stack[-1] // Inputs[1] { @0497 msg.value } 0496 5B JUMPDEST 0497 34 CALLVALUE 0498 80 DUP1 0499 15 ISZERO 049A 61 PUSH2 0x04a2 049D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0497 stack[0] = msg.value } // Block ends with conditional jump to 0x04a2, if !msg.value label_049E: // Incoming jump from 0x049D, if not !msg.value // Inputs[1] { @04A1 memory[0x00:0x00] } 049E 60 PUSH1 0x00 04A0 80 DUP1 04A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A1 revert(memory[0x00:0x00]); } // Block terminates label_04A2: // Incoming jump from 0x049D, if !msg.value // Inputs[1] { @04A6 storage[0x12] } 04A2 5B JUMPDEST 04A3 50 POP 04A4 60 PUSH1 0x12 04A6 54 SLOAD 04A7 61 PUSH2 0x0276 04AA 90 SWAP1 04AB 60 PUSH1 0xff 04AD 16 AND 04AE 81 DUP2 04AF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04AA stack[-1] = 0x0276 // @04AD stack[0] = 0xff & storage[0x12] // } // Block ends with unconditional jump to 0x0276 label_04B0: // Incoming jump from 0x017B, if 0x62b99ad4 == stack[-1] // Inputs[1] { @04B1 msg.value } 04B0 5B JUMPDEST 04B1 34 CALLVALUE 04B2 80 DUP1 04B3 15 ISZERO 04B4 61 PUSH2 0x04bc 04B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B1 stack[0] = msg.value } // Block ends with conditional jump to 0x04bc, if !msg.value label_04B8: // Incoming jump from 0x04B7, if not !msg.value // Inputs[1] { @04BB memory[0x00:0x00] } 04B8 60 PUSH1 0x00 04BA 80 DUP1 04BB FD *REVERT // Stack delta = +0 // Outputs[1] { @04BB revert(memory[0x00:0x00]); } // Block terminates label_04BC: // Incoming jump from 0x04B7, if !msg.value 04BC 5B JUMPDEST 04BD 50 POP 04BE 61 PUSH2 0x02a0 04C1 61 PUSH2 0x0d2b 04C4 56 *JUMP // Stack delta = +0 // Outputs[1] { @04BE stack[-1] = 0x02a0 } // Block ends with call to 0x0d2b, returns to 0x02A0 label_04C5: // Incoming jump from 0x0186, if 0x6352211e == stack[-1] // Inputs[1] { @04C6 msg.value } 04C5 5B JUMPDEST 04C6 34 CALLVALUE 04C7 80 DUP1 04C8 15 ISZERO 04C9 61 PUSH2 0x04d1 04CC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C6 stack[0] = msg.value } // Block ends with conditional jump to 0x04d1, if !msg.value label_04CD: // Incoming jump from 0x04CC, if not !msg.value // Inputs[1] { @04D0 memory[0x00:0x00] } 04CD 60 PUSH1 0x00 04CF 80 DUP1 04D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D0 revert(memory[0x00:0x00]); } // Block terminates label_04D1: // Incoming jump from 0x04CC, if !msg.value // Inputs[1] { @04D9 msg.data.length } 04D1 5B JUMPDEST 04D2 50 POP 04D3 61 PUSH2 0x02cd 04D6 61 PUSH2 0x04e0 04D9 36 CALLDATASIZE 04DA 60 PUSH1 0x04 04DC 61 PUSH2 0x1fdb 04DF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04D3 stack[-1] = 0x02cd // @04D6 stack[0] = 0x04e0 // @04D9 stack[1] = msg.data.length // @04DA stack[2] = 0x04 // } // Block ends with call to 0x1fdb, returns to 0x04E0 label_04E0: // Incoming return from call to 0x1FDB at 0x04DF 04E0 5B JUMPDEST 04E1 61 PUSH2 0x0d38 04E4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d38 label_04E5: // Incoming jump from 0x0191, if 0x6caede3d == stack[-1] // Inputs[1] { @04E6 msg.value } 04E5 5B JUMPDEST 04E6 34 CALLVALUE 04E7 80 DUP1 04E8 15 ISZERO 04E9 61 PUSH2 0x04f1 04EC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E6 stack[0] = msg.value } // Block ends with conditional jump to 0x04f1, if !msg.value label_04ED: // Incoming jump from 0x04EC, if not !msg.value // Inputs[1] { @04F0 memory[0x00:0x00] } 04ED 60 PUSH1 0x00 04EF 80 DUP1 04F0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F0 revert(memory[0x00:0x00]); } // Block terminates label_04F1: // Incoming jump from 0x04EC, if !msg.value // Inputs[1] { @04F5 storage[0x12] } 04F1 5B JUMPDEST 04F2 50 POP 04F3 60 PUSH1 0x12 04F5 54 SLOAD 04F6 61 PUSH2 0x0276 04F9 90 SWAP1 04FA 61 PUSH2 0x0100 04FD 90 SWAP1 04FE 04 DIV 04FF 60 PUSH1 0xff 0501 16 AND 0502 81 DUP2 0503 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @04F9 stack[-1] = 0x0276 // @0501 stack[0] = 0xff & storage[0x12] / 0x0100 // } // Block ends with unconditional jump to 0x0276 label_0504: // Incoming jump from 0x0108, if 0x70a08231 == stack[-1] // Inputs[1] { @0505 msg.value } 0504 5B JUMPDEST 0505 34 CALLVALUE 0506 80 DUP1 0507 15 ISZERO 0508 61 PUSH2 0x0510 050B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0505 stack[0] = msg.value } // Block ends with conditional jump to 0x0510, if !msg.value label_050C: // Incoming jump from 0x050B, if not !msg.value // Inputs[1] { @050F memory[0x00:0x00] } 050C 60 PUSH1 0x00 050E 80 DUP1 050F FD *REVERT // Stack delta = +0 // Outputs[1] { @050F revert(memory[0x00:0x00]); } // Block terminates label_0510: // Incoming jump from 0x050B, if !msg.value // Inputs[1] { @0518 msg.data.length } 0510 5B JUMPDEST 0511 50 POP 0512 61 PUSH2 0x031d 0515 61 PUSH2 0x051f 0518 36 CALLDATASIZE 0519 60 PUSH1 0x04 051B 61 PUSH2 0x2174 051E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0512 stack[-1] = 0x031d // @0515 stack[0] = 0x051f // @0518 stack[1] = msg.data.length // @0519 stack[2] = 0x04 // } // Block ends with call to 0x2174, returns to 0x051F label_051F: // Incoming return from call to 0x2174 at 0x051E 051F 5B JUMPDEST 0520 61 PUSH2 0x0d4a 0523 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d4a label_0524: // Incoming jump from 0x0113, if 0x715018a6 == stack[-1] // Inputs[1] { @0525 msg.value } 0524 5B JUMPDEST 0525 34 CALLVALUE 0526 80 DUP1 0527 15 ISZERO 0528 61 PUSH2 0x0530 052B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0525 stack[0] = msg.value } // Block ends with conditional jump to 0x0530, if !msg.value label_052C: // Incoming jump from 0x052B, if not !msg.value // Inputs[1] { @052F memory[0x00:0x00] } 052C 60 PUSH1 0x00 052E 80 DUP1 052F FD *REVERT // Stack delta = +0 // Outputs[1] { @052F revert(memory[0x00:0x00]); } // Block terminates label_0530: // Incoming jump from 0x052B, if !msg.value 0530 5B JUMPDEST 0531 50 POP 0532 61 PUSH2 0x0305 0535 61 PUSH2 0x0d98 0538 56 *JUMP // Stack delta = +0 // Outputs[1] { @0532 stack[-1] = 0x0305 } // Block ends with call to 0x0d98, returns to 0x0305 label_0539: // Incoming jump from 0x011E, if 0x7cb64759 == stack[-1] // Inputs[1] { @053A msg.value } 0539 5B JUMPDEST 053A 34 CALLVALUE 053B 80 DUP1 053C 15 ISZERO 053D 61 PUSH2 0x0545 0540 57 *JUMPI // Stack delta = +1 // Outputs[1] { @053A stack[0] = msg.value } // Block ends with conditional jump to 0x0545, if !msg.value label_0541: // Incoming jump from 0x0540, if not !msg.value // Inputs[1] { @0544 memory[0x00:0x00] } 0541 60 PUSH1 0x00 0543 80 DUP1 0544 FD *REVERT // Stack delta = +0 // Outputs[1] { @0544 revert(memory[0x00:0x00]); } // Block terminates label_0545: // Incoming jump from 0x0540, if !msg.value // Inputs[1] { @054D msg.data.length } 0545 5B JUMPDEST 0546 50 POP 0547 61 PUSH2 0x0305 054A 61 PUSH2 0x0554 054D 36 CALLDATASIZE 054E 60 PUSH1 0x04 0550 61 PUSH2 0x1fdb 0553 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0547 stack[-1] = 0x0305 // @054A stack[0] = 0x0554 // @054D stack[1] = msg.data.length // @054E stack[2] = 0x04 // } // Block ends with call to 0x1fdb, returns to 0x0554 label_0554: // Incoming return from call to 0x1FDB at 0x0553 0554 5B JUMPDEST 0555 61 PUSH2 0x0dce 0558 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dce label_0559: // Incoming jump from 0x0129, if 0x7ec4a659 == stack[-1] // Inputs[1] { @055A msg.value } 0559 5B JUMPDEST 055A 34 CALLVALUE 055B 80 DUP1 055C 15 ISZERO 055D 61 PUSH2 0x0565 0560 57 *JUMPI // Stack delta = +1 // Outputs[1] { @055A stack[0] = msg.value } // Block ends with conditional jump to 0x0565, if !msg.value label_0561: // Incoming jump from 0x0560, if not !msg.value // Inputs[1] { @0564 memory[0x00:0x00] } 0561 60 PUSH1 0x00 0563 80 DUP1 0564 FD *REVERT // Stack delta = +0 // Outputs[1] { @0564 revert(memory[0x00:0x00]); } // Block terminates label_0565: // Incoming jump from 0x0560, if !msg.value // Inputs[1] { @056D msg.data.length } 0565 5B JUMPDEST 0566 50 POP 0567 61 PUSH2 0x0305 056A 61 PUSH2 0x0574 056D 36 CALLDATASIZE 056E 60 PUSH1 0x04 0570 61 PUSH2 0x20c5 0573 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0567 stack[-1] = 0x0305 // @056A stack[0] = 0x0574 // @056D stack[1] = msg.data.length // @056E stack[2] = 0x04 // } // Block ends with call to 0x20c5, returns to 0x0574 label_0574: // Incoming return from call to 0x20C5 at 0x0573 0574 5B JUMPDEST 0575 61 PUSH2 0x0dfd 0578 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dfd label_0579: // Incoming jump from 0x0134, if 0x8da5cb5b == stack[-1] // Inputs[1] { @057A msg.value } 0579 5B JUMPDEST 057A 34 CALLVALUE 057B 80 DUP1 057C 15 ISZERO 057D 61 PUSH2 0x0585 0580 57 *JUMPI // Stack delta = +1 // Outputs[1] { @057A stack[0] = msg.value } // Block ends with conditional jump to 0x0585, if !msg.value label_0581: // Incoming jump from 0x0580, if not !msg.value // Inputs[1] { @0584 memory[0x00:0x00] } 0581 60 PUSH1 0x00 0583 80 DUP1 0584 FD *REVERT // Stack delta = +0 // Outputs[1] { @0584 revert(memory[0x00:0x00]); } // Block terminates label_0585: // Incoming jump from 0x0580, if !msg.value // Inputs[1] { @0589 storage[0x08] } 0585 5B JUMPDEST 0586 50 POP 0587 60 PUSH1 0x08 0589 54 SLOAD 058A 60 PUSH1 0x01 058C 60 PUSH1 0x01 058E 60 PUSH1 0xa0 0590 1B SHL 0591 03 SUB 0592 16 AND 0593 61 PUSH2 0x02cd 0596 56 *JUMP // Stack delta = +0 // Outputs[1] { @0592 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x08] } // Block ends with unconditional jump to 0x02cd label_0597: // Incoming jump from 0x00CC, if 0x94354fd0 == stack[-1] // Inputs[1] { @0598 msg.value } 0597 5B JUMPDEST 0598 34 CALLVALUE 0599 80 DUP1 059A 15 ISZERO 059B 61 PUSH2 0x05a3 059E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0598 stack[0] = msg.value } // Block ends with conditional jump to 0x05a3, if !msg.value label_059F: // Incoming jump from 0x059E, if not !msg.value // Inputs[1] { @05A2 memory[0x00:0x00] } 059F 60 PUSH1 0x00 05A1 80 DUP1 05A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A2 revert(memory[0x00:0x00]); } // Block terminates label_05A3: // Incoming jump from 0x059E, if !msg.value // Inputs[1] { @05AA storage[0x11] } 05A3 5B JUMPDEST 05A4 50 POP 05A5 61 PUSH2 0x031d 05A8 60 PUSH1 0x11 05AA 54 SLOAD 05AB 81 DUP2 05AC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05A5 stack[-1] = 0x031d // @05AA stack[0] = storage[0x11] // } // Block ends with unconditional jump to 0x031d label_05AD: // Incoming jump from 0x00D7, if 0x95d89b41 == stack[-1] // Inputs[1] { @05AE msg.value } 05AD 5B JUMPDEST 05AE 34 CALLVALUE 05AF 80 DUP1 05B0 15 ISZERO 05B1 61 PUSH2 0x05b9 05B4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05AE stack[0] = msg.value } // Block ends with conditional jump to 0x05b9, if !msg.value label_05B5: // Incoming jump from 0x05B4, if not !msg.value // Inputs[1] { @05B8 memory[0x00:0x00] } 05B5 60 PUSH1 0x00 05B7 80 DUP1 05B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B8 revert(memory[0x00:0x00]); } // Block terminates label_05B9: // Incoming jump from 0x05B4, if !msg.value 05B9 5B JUMPDEST 05BA 50 POP 05BB 61 PUSH2 0x02a0 05BE 61 PUSH2 0x0e3a 05C1 56 *JUMP // Stack delta = +0 // Outputs[1] { @05BB stack[-1] = 0x02a0 } // Block ends with call to 0x0e3a, returns to 0x02A0 label_05C2: // Incoming jump from 0x00E2, if 0xa0712d68 == stack[-1] // Inputs[1] { @05C9 msg.data.length } 05C2 5B JUMPDEST 05C3 61 PUSH2 0x0305 05C6 61 PUSH2 0x05d0 05C9 36 CALLDATASIZE 05CA 60 PUSH1 0x04 05CC 61 PUSH2 0x1fdb 05CF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05C3 stack[0] = 0x0305 // @05C6 stack[1] = 0x05d0 // @05C9 stack[2] = msg.data.length // @05CA stack[3] = 0x04 // } // Block ends with call to 0x1fdb, returns to 0x05D0 label_05D0: // Incoming return from call to 0x1FDB at 0x05CF 05D0 5B JUMPDEST 05D1 61 PUSH2 0x0e49 05D4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e49 label_05D5: // Incoming jump from 0x00ED, if 0xa22cb465 == stack[-1] // Inputs[1] { @05D6 msg.value } 05D5 5B JUMPDEST 05D6 34 CALLVALUE 05D7 80 DUP1 05D8 15 ISZERO 05D9 61 PUSH2 0x05e1 05DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D6 stack[0] = msg.value } // Block ends with conditional jump to 0x05e1, if !msg.value label_05DD: // Incoming jump from 0x05DC, if not !msg.value // Inputs[1] { @05E0 memory[0x00:0x00] } 05DD 60 PUSH1 0x00 05DF 80 DUP1 05E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E0 revert(memory[0x00:0x00]); } // Block terminates label_05E1: // Incoming jump from 0x05DC, if !msg.value // Inputs[1] { @05E9 msg.data.length } 05E1 5B JUMPDEST 05E2 50 POP 05E3 61 PUSH2 0x0305 05E6 61 PUSH2 0x05f0 05E9 36 CALLDATASIZE 05EA 60 PUSH1 0x04 05EC 61 PUSH2 0x21d3 05EF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05E3 stack[-1] = 0x0305 // @05E6 stack[0] = 0x05f0 // @05E9 stack[1] = msg.data.length // @05EA stack[2] = 0x04 // } // Block ends with unconditional jump to 0x21d3 05F0 5B JUMPDEST 05F1 61 PUSH2 0x0f66 05F4 56 *JUMP label_05F5: // Incoming jump from 0x00F8, if 0xa45ba8e7 == stack[-1] // Inputs[1] { @05F6 msg.value } 05F5 5B JUMPDEST 05F6 34 CALLVALUE 05F7 80 DUP1 05F8 15 ISZERO 05F9 61 PUSH2 0x0601 05FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F6 stack[0] = msg.value } // Block ends with conditional jump to 0x0601, if !msg.value label_05FD: // Incoming jump from 0x05FC, if not !msg.value // Inputs[1] { @0600 memory[0x00:0x00] } 05FD 60 PUSH1 0x00 05FF 80 DUP1 0600 FD *REVERT // Stack delta = +0 // Outputs[1] { @0600 revert(memory[0x00:0x00]); } // Block terminates label_0601: // Incoming jump from 0x05FC, if !msg.value 0601 5B JUMPDEST 0602 50 POP 0603 61 PUSH2 0x02a0 0606 61 PUSH2 0x0ffc 0609 56 *JUMP // Stack delta = +0 // Outputs[1] { @0603 stack[-1] = 0x02a0 } // Block ends with call to 0x0ffc, returns to 0x02A0 label_060A: // Incoming jump from 0x0085, if 0xb071401b == stack[-1] // Inputs[1] { @060B msg.value } 060A 5B JUMPDEST 060B 34 CALLVALUE 060C 80 DUP1 060D 15 ISZERO 060E 61 PUSH2 0x0616 0611 57 *JUMPI // Stack delta = +1 // Outputs[1] { @060B stack[0] = msg.value } // Block ends with conditional jump to 0x0616, if !msg.value label_0612: // Incoming jump from 0x0611, if not !msg.value // Inputs[1] { @0615 memory[0x00:0x00] } 0612 60 PUSH1 0x00 0614 80 DUP1 0615 FD *REVERT // Stack delta = +0 // Outputs[1] { @0615 revert(memory[0x00:0x00]); } // Block terminates label_0616: // Incoming jump from 0x0611, if !msg.value // Inputs[1] { @061E msg.data.length } 0616 5B JUMPDEST 0617 50 POP 0618 61 PUSH2 0x0305 061B 61 PUSH2 0x0625 061E 36 CALLDATASIZE 061F 60 PUSH1 0x04 0621 61 PUSH2 0x1fdb 0624 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0618 stack[-1] = 0x0305 // @061B stack[0] = 0x0625 // @061E stack[1] = msg.data.length // @061F stack[2] = 0x04 // } // Block ends with call to 0x1fdb, returns to 0x0625 label_0625: // Incoming return from call to 0x1FDB at 0x0624 0625 5B JUMPDEST 0626 61 PUSH2 0x1009 0629 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1009 label_062A: // Incoming jump from 0x0090, if 0xb767a098 == stack[-1] // Inputs[1] { @062B msg.value } 062A 5B JUMPDEST 062B 34 CALLVALUE 062C 80 DUP1 062D 15 ISZERO 062E 61 PUSH2 0x0636 0631 57 *JUMPI // Stack delta = +1 // Outputs[1] { @062B stack[0] = msg.value } // Block ends with conditional jump to 0x0636, if !msg.value label_0632: // Incoming jump from 0x0631, if not !msg.value // Inputs[1] { @0635 memory[0x00:0x00] } 0632 60 PUSH1 0x00 0634 80 DUP1 0635 FD *REVERT // Stack delta = +0 // Outputs[1] { @0635 revert(memory[0x00:0x00]); } // Block terminates label_0636: // Incoming jump from 0x0631, if !msg.value // Inputs[1] { @063E msg.data.length } 0636 5B JUMPDEST 0637 50 POP 0638 61 PUSH2 0x0305 063B 61 PUSH2 0x0645 063E 36 CALLDATASIZE 063F 60 PUSH1 0x04 0641 61 PUSH2 0x211d 0644 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0638 stack[-1] = 0x0305 // @063B stack[0] = 0x0645 // @063E stack[1] = msg.data.length // @063F stack[2] = 0x04 // } // Block ends with call to 0x211d, returns to 0x0645 label_0645: // Incoming return from call to 0x211D at 0x0644 0645 5B JUMPDEST 0646 61 PUSH2 0x1038 0649 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1038 label_064A: // Incoming jump from 0x009B, if 0xb88d4fde == stack[-1] // Inputs[1] { @064B msg.value } 064A 5B JUMPDEST 064B 34 CALLVALUE 064C 80 DUP1 064D 15 ISZERO 064E 61 PUSH2 0x0656 0651 57 *JUMPI // Stack delta = +1 // Outputs[1] { @064B stack[0] = msg.value } // Block ends with conditional jump to 0x0656, if !msg.value label_0652: // Incoming jump from 0x0651, if not !msg.value // Inputs[1] { @0655 memory[0x00:0x00] } 0652 60 PUSH1 0x00 0654 80 DUP1 0655 FD *REVERT // Stack delta = +0 // Outputs[1] { @0655 revert(memory[0x00:0x00]); } // Block terminates label_0656: // Incoming jump from 0x0651, if !msg.value // Inputs[1] { @065E msg.data.length } 0656 5B JUMPDEST 0657 50 POP 0658 61 PUSH2 0x0305 065B 61 PUSH2 0x0665 065E 36 CALLDATASIZE 065F 60 PUSH1 0x04 0661 61 PUSH2 0x2206 0664 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0658 stack[-1] = 0x0305 // @065B stack[0] = 0x0665 // @065E stack[1] = msg.data.length // @065F stack[2] = 0x04 // } // Block ends with call to 0x2206, returns to 0x0665 label_0665: // Incoming return from call to 0x2206 at 0x0664 0665 5B JUMPDEST 0666 61 PUSH2 0x107c 0669 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x107c label_066A: // Incoming jump from 0x00A6, if 0xc87b56dd == stack[-1] // Inputs[1] { @066B msg.value } 066A 5B JUMPDEST 066B 34 CALLVALUE 066C 80 DUP1 066D 15 ISZERO 066E 61 PUSH2 0x0676 0671 57 *JUMPI // Stack delta = +1 // Outputs[1] { @066B stack[0] = msg.value } // Block ends with conditional jump to 0x0676, if !msg.value label_0672: // Incoming jump from 0x0671, if not !msg.value // Inputs[1] { @0675 memory[0x00:0x00] } 0672 60 PUSH1 0x00 0674 80 DUP1 0675 FD *REVERT // Stack delta = +0 // Outputs[1] { @0675 revert(memory[0x00:0x00]); } // Block terminates label_0676: // Incoming jump from 0x0671, if !msg.value // Inputs[1] { @067E msg.data.length } 0676 5B JUMPDEST 0677 50 POP 0678 61 PUSH2 0x02a0 067B 61 PUSH2 0x0685 067E 36 CALLDATASIZE 067F 60 PUSH1 0x04 0681 61 PUSH2 0x1fdb 0684 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0678 stack[-1] = 0x02a0 // @067B stack[0] = 0x0685 // @067E stack[1] = msg.data.length // @067F stack[2] = 0x04 // } // Block ends with call to 0x1fdb, returns to 0x0685 label_0685: // Incoming return from call to 0x1FDB at 0x0684 0685 5B JUMPDEST 0686 61 PUSH2 0x10cd 0689 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10cd label_068A: // Incoming jump from 0x00B1, if 0xd2cab056 == stack[-1] // Inputs[1] { @0691 msg.data.length } 068A 5B JUMPDEST 068B 61 PUSH2 0x0305 068E 61 PUSH2 0x0698 0691 36 CALLDATASIZE 0692 60 PUSH1 0x04 0694 61 PUSH2 0x2281 0697 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @068B stack[0] = 0x0305 // @068E stack[1] = 0x0698 // @0691 stack[2] = msg.data.length // @0692 stack[3] = 0x04 // } // Block ends with call to 0x2281, returns to 0x0698 label_0698: // Incoming return from call to 0x2281 at 0x0697 0698 5B JUMPDEST 0699 61 PUSH2 0x123d 069C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x123d label_069D: // Incoming jump from 0x003E, if 0xd5abeb01 == stack[-1] // Inputs[1] { @069E msg.value } 069D 5B JUMPDEST 069E 34 CALLVALUE 069F 80 DUP1 06A0 15 ISZERO 06A1 61 PUSH2 0x06a9 06A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @069E stack[0] = msg.value } // Block ends with conditional jump to 0x06a9, if !msg.value label_06A5: // Incoming jump from 0x06A4, if not !msg.value // Inputs[1] { @06A8 memory[0x00:0x00] } 06A5 60 PUSH1 0x00 06A7 80 DUP1 06A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A8 revert(memory[0x00:0x00]); } // Block terminates label_06A9: // Incoming jump from 0x06A4, if !msg.value // Inputs[1] { @06B0 storage[0x10] } 06A9 5B JUMPDEST 06AA 50 POP 06AB 61 PUSH2 0x031d 06AE 60 PUSH1 0x10 06B0 54 SLOAD 06B1 81 DUP2 06B2 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06AB stack[-1] = 0x031d // @06B0 stack[0] = storage[0x10] // } // Block ends with unconditional jump to 0x031d label_06B3: // Incoming jump from 0x0049, if 0xdb4bec44 == stack[-1] // Inputs[1] { @06B4 msg.value } 06B3 5B JUMPDEST 06B4 34 CALLVALUE 06B5 80 DUP1 06B6 15 ISZERO 06B7 61 PUSH2 0x06bf 06BA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06B4 stack[0] = msg.value } // Block ends with conditional jump to 0x06bf, if !msg.value label_06BB: // Incoming jump from 0x06BA, if not !msg.value // Inputs[1] { @06BE memory[0x00:0x00] } 06BB 60 PUSH1 0x00 06BD 80 DUP1 06BE FD *REVERT // Stack delta = +0 // Outputs[1] { @06BE revert(memory[0x00:0x00]); } // Block terminates label_06BF: // Incoming jump from 0x06BA, if !msg.value // Inputs[1] { @06C7 msg.data.length } 06BF 5B JUMPDEST 06C0 50 POP 06C1 61 PUSH2 0x0276 06C4 61 PUSH2 0x06ce 06C7 36 CALLDATASIZE 06C8 60 PUSH1 0x04 06CA 61 PUSH2 0x2174 06CD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06C1 stack[-1] = 0x0276 // @06C4 stack[0] = 0x06ce // @06C7 stack[1] = msg.data.length // @06C8 stack[2] = 0x04 // } // Block ends with call to 0x2174, returns to 0x06CE label_06CE: // Incoming return from call to 0x2174 at 0x06CD // Inputs[4] // { // @06D6 stack[-1] // @06DC memory[0x00:0x40] // @06DD storage[keccak256(memory[0x00:0x40])] // @06E1 stack[-2] // } 06CE 5B JUMPDEST 06CF 60 PUSH1 0x0b 06D1 60 PUSH1 0x20 06D3 52 MSTORE 06D4 60 PUSH1 0x00 06D6 90 SWAP1 06D7 81 DUP2 06D8 52 MSTORE 06D9 60 PUSH1 0x40 06DB 90 SWAP1 06DC 20 SHA3 06DD 54 SLOAD 06DE 60 PUSH1 0xff 06E0 16 AND 06E1 81 DUP2 06E2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06D3 memory[0x20:0x40] = 0x0b // @06D8 memory[0x00:0x20] = stack[-1] // @06E0 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_06E3: // Incoming jump from 0x0054, if 0xe0a80853 == stack[-1] // Inputs[1] { @06E4 msg.value } 06E3 5B JUMPDEST 06E4 34 CALLVALUE 06E5 80 DUP1 06E6 15 ISZERO 06E7 61 PUSH2 0x06ef 06EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06E4 stack[0] = msg.value } // Block ends with conditional jump to 0x06ef, if !msg.value label_06EB: // Incoming jump from 0x06EA, if not !msg.value // Inputs[1] { @06EE memory[0x00:0x00] } 06EB 60 PUSH1 0x00 06ED 80 DUP1 06EE FD *REVERT // Stack delta = +0 // Outputs[1] { @06EE revert(memory[0x00:0x00]); } // Block terminates label_06EF: // Incoming jump from 0x06EA, if !msg.value // Inputs[1] { @06F7 msg.data.length } 06EF 5B JUMPDEST 06F0 50 POP 06F1 61 PUSH2 0x0305 06F4 61 PUSH2 0x06fe 06F7 36 CALLDATASIZE 06F8 60 PUSH1 0x04 06FA 61 PUSH2 0x211d 06FD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06F1 stack[-1] = 0x0305 // @06F4 stack[0] = 0x06fe // @06F7 stack[1] = msg.data.length // @06F8 stack[2] = 0x04 // } // Block ends with call to 0x211d, returns to 0x06FE label_06FE: // Incoming return from call to 0x211D at 0x06FD 06FE 5B JUMPDEST 06FF 61 PUSH2 0x14a2 0702 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14a2 label_0703: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0704 msg.value } 0703 5B JUMPDEST 0704 34 CALLVALUE 0705 80 DUP1 0706 15 ISZERO 0707 61 PUSH2 0x070f 070A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0704 stack[0] = msg.value } // Block ends with conditional jump to 0x070f, if !msg.value label_070B: // Incoming jump from 0x070A, if not !msg.value // Inputs[1] { @070E memory[0x00:0x00] } 070B 60 PUSH1 0x00 070D 80 DUP1 070E FD *REVERT // Stack delta = +0 // Outputs[1] { @070E revert(memory[0x00:0x00]); } // Block terminates label_070F: // Incoming jump from 0x070A, if !msg.value // Inputs[1] { @0717 msg.data.length } 070F 5B JUMPDEST 0710 50 POP 0711 61 PUSH2 0x0276 0714 61 PUSH2 0x071e 0717 36 CALLDATASIZE 0718 60 PUSH1 0x04 071A 61 PUSH2 0x22ff 071D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0711 stack[-1] = 0x0276 // @0714 stack[0] = 0x071e // @0717 stack[1] = msg.data.length // @0718 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x22ff label_071E: // Incoming call from 0x0911, returns to 0x0912 // Incoming call from 0x1717, returns to 0x1718 // Inputs[6] // { // @0727 stack[-2] // @073A memory[0x00:0x40] // @073B stack[-1] // @0745 memory[0x00:0x40] // @0746 storage[keccak256(memory[0x00:0x40])] // @074A stack[-3] // } 071E 5B JUMPDEST 071F 60 PUSH1 0x01 0721 60 PUSH1 0x01 0723 60 PUSH1 0xa0 0725 1B SHL 0726 03 SUB 0727 91 SWAP2 0728 82 DUP3 0729 16 AND 072A 60 PUSH1 0x00 072C 90 SWAP1 072D 81 DUP2 072E 52 MSTORE 072F 60 PUSH1 0x07 0731 60 PUSH1 0x20 0733 90 SWAP1 0734 81 DUP2 0735 52 MSTORE 0736 60 PUSH1 0x40 0738 80 DUP1 0739 83 DUP4 073A 20 SHA3 073B 93 SWAP4 073C 90 SWAP1 073D 94 SWAP5 073E 16 AND 073F 82 DUP3 0740 52 MSTORE 0741 91 SWAP2 0742 90 SWAP1 0743 91 SWAP2 0744 52 MSTORE 0745 20 SHA3 0746 54 SLOAD 0747 60 PUSH1 0xff 0749 16 AND 074A 90 SWAP1 074B 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @072E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0735 memory[0x20:0x40] = 0x07 // @0740 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0744 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @074A stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_074C: // Incoming jump from 0x006A, if 0xefbd73f4 == stack[-1] // Inputs[1] { @074D msg.value } 074C 5B JUMPDEST 074D 34 CALLVALUE 074E 80 DUP1 074F 15 ISZERO 0750 61 PUSH2 0x0758 0753 57 *JUMPI // Stack delta = +1 // Outputs[1] { @074D stack[0] = msg.value } // Block ends with conditional jump to 0x0758, if !msg.value label_0754: // Incoming jump from 0x0753, if not !msg.value // Inputs[1] { @0757 memory[0x00:0x00] } 0754 60 PUSH1 0x00 0756 80 DUP1 0757 FD *REVERT // Stack delta = +0 // Outputs[1] { @0757 revert(memory[0x00:0x00]); } // Block terminates label_0758: // Incoming jump from 0x0753, if !msg.value // Inputs[1] { @0760 msg.data.length } 0758 5B JUMPDEST 0759 50 POP 075A 61 PUSH2 0x0305 075D 61 PUSH2 0x0767 0760 36 CALLDATASIZE 0761 60 PUSH1 0x04 0763 61 PUSH2 0x2329 0766 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @075A stack[-1] = 0x0305 // @075D stack[0] = 0x0767 // @0760 stack[1] = msg.data.length // @0761 stack[2] = 0x04 // } // Block ends with call to 0x2329, returns to 0x0767 label_0767: // Incoming return from call to 0x2329 at 0x0766 0767 5B JUMPDEST 0768 61 PUSH2 0x14e8 076B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14e8 label_076C: // Incoming jump from 0x0075, if 0xf2fde38b == stack[-1] // Inputs[1] { @076D msg.value } 076C 5B JUMPDEST 076D 34 CALLVALUE 076E 80 DUP1 076F 15 ISZERO 0770 61 PUSH2 0x0778 0773 57 *JUMPI // Stack delta = +1 // Outputs[1] { @076D stack[0] = msg.value } // Block ends with conditional jump to 0x0778, if !msg.value label_0774: // Incoming jump from 0x0773, if not !msg.value // Inputs[1] { @0777 memory[0x00:0x00] } 0774 60 PUSH1 0x00 0776 80 DUP1 0777 FD *REVERT // Stack delta = +0 // Outputs[1] { @0777 revert(memory[0x00:0x00]); } // Block terminates label_0778: // Incoming jump from 0x0773, if !msg.value // Inputs[1] { @0780 msg.data.length } 0778 5B JUMPDEST 0779 50 POP 077A 61 PUSH2 0x0305 077D 61 PUSH2 0x0787 0780 36 CALLDATASIZE 0781 60 PUSH1 0x04 0783 61 PUSH2 0x2174 0786 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @077A stack[-1] = 0x0305 // @077D stack[0] = 0x0787 // @0780 stack[1] = msg.data.length // @0781 stack[2] = 0x04 // } // Block ends with call to 0x2174, returns to 0x0787 label_0787: // Incoming return from call to 0x2174 at 0x0786 0787 5B JUMPDEST 0788 61 PUSH2 0x1588 078B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1588 label_078C: // Incoming jump from 0x0275 // Inputs[1] { @0798 stack[-1] } 078C 5B JUMPDEST 078D 60 PUSH1 0x00 078F 60 PUSH1 0x01 0791 60 PUSH1 0x01 0793 60 PUSH1 0xe0 0795 1B SHL 0796 03 SUB 0797 19 NOT 0798 82 DUP3 0799 16 AND 079A 63 PUSH4 0x80ac58cd 079F 60 PUSH1 0xe0 07A1 1B SHL 07A2 14 EQ 07A3 80 DUP1 07A4 61 PUSH2 0x07bd 07A7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @078D stack[0] = 0x00 // @07A2 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x07bd, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_07A8: // Incoming jump from 0x07A7, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @07B2 stack[-3] } 07A8 50 POP 07A9 60 PUSH1 0x01 07AB 60 PUSH1 0x01 07AD 60 PUSH1 0xe0 07AF 1B SHL 07B0 03 SUB 07B1 19 NOT 07B2 82 DUP3 07B3 16 AND 07B4 63 PUSH4 0x5b5e139f 07B9 60 PUSH1 0xe0 07BB 1B SHL 07BC 14 EQ 07BD 5B JUMPDEST 07BE 80 DUP1 07BF 61 PUSH2 0x07d8 07C2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @07BC stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x07d8, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_07C3: // Incoming jump from 0x07C2, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x07C2, if not stack[-1] // Inputs[1] { @07D5 stack[-3] } 07C3 50 POP 07C4 63 PUSH4 0x01ffc9a7 07C9 60 PUSH1 0xe0 07CB 1B SHL 07CC 60 PUSH1 0x01 07CE 60 PUSH1 0x01 07D0 60 PUSH1 0xe0 07D2 1B SHL 07D3 03 SUB 07D4 19 NOT 07D5 83 DUP4 07D6 16 AND 07D7 14 EQ // Stack delta = +0 // Outputs[1] { @07D7 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_07D8: // Incoming jump from 0x163D, if !stack[-1] // Incoming jump from 0x163D, if !(stack[-3] < storage[0x00]) // Incoming jump from 0x07D7 // Incoming jump from 0x07C2, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x07C2, if stack[-1] // Inputs[3] // { // @07D9 stack[-1] // @07D9 stack[-4] // @07DA stack[-3] // } 07D8 5B JUMPDEST 07D9 92 SWAP3 07DA 91 SWAP2 07DB 50 POP 07DC 50 POP 07DD 56 *JUMP // Stack delta = -3 // Outputs[1] { @07D9 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_07DE: // Incoming call from 0x029F, returns to 0x02A0 // Inputs[1] { @07E4 storage[0x02] } 07DE 5B JUMPDEST 07DF 60 PUSH1 0x60 07E1 60 PUSH1 0x02 07E3 80 DUP1 07E4 54 SLOAD 07E5 61 PUSH2 0x07ed 07E8 90 SWAP1 07E9 61 PUSH2 0x234c 07EC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07DF stack[0] = 0x60 // @07E1 stack[1] = 0x02 // @07E8 stack[2] = 0x07ed // @07E8 stack[3] = storage[0x02] // } // Block ends with call to 0x234c, returns to 0x07ED label_07ED: // Incoming return from call to 0x234C at 0x07EC // Incoming return from call to 0x234C at 0x0E48 // Incoming return from call to 0x234C at 0x1B3F // Inputs[4] // { // @07EE stack[-1] // @07FD memory[0x40:0x60] // @0805 stack[-2] // @0810 storage[stack[-2]] // } 07ED 5B JUMPDEST 07EE 80 DUP1 07EF 60 PUSH1 0x1f 07F1 01 ADD 07F2 60 PUSH1 0x20 07F4 80 DUP1 07F5 91 SWAP2 07F6 04 DIV 07F7 02 MUL 07F8 60 PUSH1 0x20 07FA 01 ADD 07FB 60 PUSH1 0x40 07FD 51 MLOAD 07FE 90 SWAP1 07FF 81 DUP2 0800 01 ADD 0801 60 PUSH1 0x40 0803 52 MSTORE 0804 80 DUP1 0805 92 SWAP3 0806 91 SWAP2 0807 90 SWAP1 0808 81 DUP2 0809 81 DUP2 080A 52 MSTORE 080B 60 PUSH1 0x20 080D 01 ADD 080E 82 DUP3 080F 80 DUP1 0810 54 SLOAD 0811 61 PUSH2 0x0819 0814 90 SWAP1 0815 61 PUSH2 0x234c 0818 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0803 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0805 stack[-2] = memory[0x40:0x60] // @0806 stack[-1] = stack[-2] // @0807 stack[0] = stack[-1] // @080A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @080D stack[1] = 0x20 + memory[0x40:0x60] // @080E stack[2] = stack[-2] // @0814 stack[4] = storage[stack[-2]] // @0814 stack[3] = 0x0819 // } // Block ends with call to 0x234c, returns to 0x0819 label_0819: // Incoming return from call to 0x234C at 0x0818 // Inputs[1] { @081A stack[-1] } 0819 5B JUMPDEST 081A 80 DUP1 081B 15 ISZERO 081C 61 PUSH2 0x0866 081F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0866, if !stack[-1] label_0820: // Incoming jump from 0x081F, if not !stack[-1] // Inputs[1] { @0820 stack[-1] } 0820 80 DUP1 0821 60 PUSH1 0x1f 0823 10 LT 0824 61 PUSH2 0x083b 0827 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x083b, if 0x1f < stack[-1] label_0828: // Incoming jump from 0x0827, if not 0x1f < stack[-1] // Inputs[4] // { // @082C stack[-2] // @082D storage[stack[-2]] // @0830 stack[-3] // @0832 stack[-1] // } 0828 61 PUSH2 0x0100 082B 80 DUP1 082C 83 DUP4 082D 54 SLOAD 082E 04 DIV 082F 02 MUL 0830 83 DUP4 0831 52 MSTORE 0832 91 SWAP2 0833 60 PUSH1 0x20 0835 01 ADD 0836 91 SWAP2 0837 61 PUSH2 0x0866 083A 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0831 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0836 stack[-1] = stack[-1] // @0836 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0866 label_083B: // Incoming jump from 0x0827, if 0x1f < stack[-1] // Inputs[5] // { // @083C stack[-3] // @083D stack[-1] // @083F stack[-2] // @0847 memory[0x00:0x20] // @084B storage[keccak256(memory[0x00:0x20])] // } 083B 5B JUMPDEST 083C 82 DUP3 083D 01 ADD 083E 91 SWAP2 083F 90 SWAP1 0840 60 PUSH1 0x00 0842 52 MSTORE 0843 60 PUSH1 0x20 0845 60 PUSH1 0x00 0847 20 SHA3 0848 90 SWAP1 0849 5B JUMPDEST 084A 81 DUP2 084B 54 SLOAD 084C 81 DUP2 084D 52 MSTORE 084E 90 SWAP1 084F 60 PUSH1 0x01 0851 01 ADD 0852 90 SWAP1 0853 60 PUSH1 0x20 0855 01 ADD 0856 80 DUP1 0857 83 DUP4 0858 11 GT 0859 61 PUSH2 0x0849 085C 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @083E stack[-3] = stack[-3] + stack[-1] // @0842 memory[0x00:0x20] = stack[-2] // @084D memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0852 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0855 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0849, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_085D: // Incoming jump from 0x085C, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x085C, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @085D stack[-3] // @085E stack[-1] // } 085D 82 DUP3 085E 90 SWAP1 085F 03 SUB 0860 60 PUSH1 0x1f 0862 16 AND 0863 82 DUP3 0864 01 ADD 0865 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0865 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0865 stack[-1] = stack[-3] // } // Block continues label_0866: // Incoming jump from 0x083A // Incoming jump from 0x0865 // Incoming jump from 0x081F, if !stack[-1] // Inputs[3] // { // @086C stack[-7] // @086C stack[-6] // @086E stack[-8] // } 0866 5B JUMPDEST 0867 50 POP 0868 50 POP 0869 50 POP 086A 50 POP 086B 50 POP 086C 90 SWAP1 086D 50 POP 086E 90 SWAP1 086F 56 *JUMP // Stack delta = -7 // Outputs[1] { @086E stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0870: // Incoming jump from 0x02CC // Incoming call from 0x1727, returns to 0x1728 // Inputs[1] { @0876 stack[-1] } 0870 5B JUMPDEST 0871 60 PUSH1 0x00 0873 61 PUSH2 0x087b 0876 82 DUP3 0877 61 PUSH2 0x1623 087A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0871 stack[0] = 0x00 // @0873 stack[1] = 0x087b // @0876 stack[2] = stack[-1] // } // Block ends with call to 0x1623, returns to 0x087B label_087B: // Incoming return from call to 0x1623 at 0x087A // Inputs[1] { @087F stack[-1] } 087B 5B JUMPDEST 087C 61 PUSH2 0x0898 087F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0898, if stack[-1] label_0880: // Incoming jump from 0x087F, if not stack[-1] // Inputs[3] // { // @0882 memory[0x40:0x60] // @0892 memory[0x40:0x60] // @0897 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0880 60 PUSH1 0x40 0882 51 MLOAD 0883 63 PUSH4 0x33d1c039 0888 60 PUSH1 0xe2 088A 1B SHL 088B 81 DUP2 088C 52 MSTORE 088D 60 PUSH1 0x04 088F 01 ADD 0890 60 PUSH1 0x40 0892 51 MLOAD 0893 80 DUP1 0894 91 SWAP2 0895 03 SUB 0896 90 SWAP1 0897 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @088C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @0897 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0898: // Incoming jump from 0x087F, if stack[-1] // Inputs[4] // { // @089C stack[-2] // @08A7 memory[0x00:0x40] // @08A8 storage[keccak256(memory[0x00:0x40])] // @08B2 stack[-3] // } 0898 5B JUMPDEST 0899 50 POP 089A 60 PUSH1 0x00 089C 90 SWAP1 089D 81 DUP2 089E 52 MSTORE 089F 60 PUSH1 0x06 08A1 60 PUSH1 0x20 08A3 52 MSTORE 08A4 60 PUSH1 0x40 08A6 90 SWAP1 08A7 20 SHA3 08A8 54 SLOAD 08A9 60 PUSH1 0x01 08AB 60 PUSH1 0x01 08AD 60 PUSH1 0xa0 08AF 1B SHL 08B0 03 SUB 08B1 16 AND 08B2 90 SWAP1 08B3 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @089E memory[0x00:0x20] = stack[-2] // @08A3 memory[0x20:0x40] = 0x06 // @08B2 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_08B4: // Incoming jump from 0x0304 // Inputs[1] { @08BA stack[-1] } 08B4 5B JUMPDEST 08B5 60 PUSH1 0x00 08B7 61 PUSH2 0x08bf 08BA 82 DUP3 08BB 61 PUSH2 0x0d38 08BE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08B5 stack[0] = 0x00 // @08B7 stack[1] = 0x08bf // @08BA stack[2] = stack[-1] // } // Block ends with call to 0x0d38, returns to 0x08BF label_08BF: // Incoming return from call to 0x0D38 at 0x08BE // Inputs[3] // { // @08C0 stack[-1] // @08C0 stack[-2] // @08CC stack[-4] // } 08BF 5B JUMPDEST 08C0 90 SWAP1 08C1 50 POP 08C2 80 DUP1 08C3 60 PUSH1 0x01 08C5 60 PUSH1 0x01 08C7 60 PUSH1 0xa0 08C9 1B SHL 08CA 03 SUB 08CB 16 AND 08CC 83 DUP4 08CD 60 PUSH1 0x01 08CF 60 PUSH1 0x01 08D1 60 PUSH1 0xa0 08D3 1B SHL 08D4 03 SUB 08D5 16 AND 08D6 14 EQ 08D7 15 ISZERO 08D8 61 PUSH2 0x08f4 08DB 57 *JUMPI // Stack delta = -1 // Outputs[1] { @08C0 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x08f4, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_08DC: // Incoming jump from 0x08DB, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @08DE memory[0x40:0x60] // @08EE memory[0x40:0x60] // @08F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08DC 60 PUSH1 0x40 08DE 51 MLOAD 08DF 63 PUSH4 0x250fdee3 08E4 60 PUSH1 0xe2 08E6 1B SHL 08E7 81 DUP2 08E8 52 MSTORE 08E9 60 PUSH1 0x04 08EB 01 ADD 08EC 60 PUSH1 0x40 08EE 51 MLOAD 08EF 80 DUP1 08F0 91 SWAP2 08F1 03 SUB 08F2 90 SWAP1 08F3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @08F3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08F4: // Incoming jump from 0x08DB, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @08F5 msg.sender // @08FE stack[-1] // } 08F4 5B JUMPDEST 08F5 33 CALLER 08F6 60 PUSH1 0x01 08F8 60 PUSH1 0x01 08FA 60 PUSH1 0xa0 08FC 1B SHL 08FD 03 SUB 08FE 82 DUP3 08FF 16 AND 0900 14 EQ 0901 80 DUP1 0902 15 ISZERO 0903 90 SWAP1 0904 61 PUSH2 0x0914 0907 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0903 stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x0914, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0908: // Incoming jump from 0x0907, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @090C stack[-2] // @090D msg.sender // } 0908 50 POP 0909 61 PUSH2 0x0912 090C 81 DUP2 090D 33 CALLER 090E 61 PUSH2 0x071e 0911 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0909 stack[-1] = 0x0912 // @090C stack[0] = stack[-2] // @090D stack[1] = msg.sender // } // Block ends with call to 0x071e, returns to 0x0912 label_0912: // Incoming return from call to 0x071E at 0x0911 // Inputs[1] { @0913 stack[-1] } 0912 5B JUMPDEST 0913 15 ISZERO // Stack delta = +0 // Outputs[1] { @0913 stack[-1] = !stack[-1] } // Block continues label_0914: // Incoming jump from 0x0907, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming jump from 0x0913 // Inputs[1] { @0915 stack[-1] } 0914 5B JUMPDEST 0915 15 ISZERO 0916 61 PUSH2 0x0932 0919 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0932, if !stack[-1] label_091A: // Incoming jump from 0x0919, if not !stack[-1] // Inputs[3] // { // @091C memory[0x40:0x60] // @092C memory[0x40:0x60] // @0931 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 091A 60 PUSH1 0x40 091C 51 MLOAD 091D 63 PUSH4 0x67d9dca1 0922 60 PUSH1 0xe1 0924 1B SHL 0925 81 DUP2 0926 52 MSTORE 0927 60 PUSH1 0x04 0929 01 ADD 092A 60 PUSH1 0x40 092C 51 MLOAD 092D 80 DUP1 092E 91 SWAP2 092F 03 SUB 0930 90 SWAP1 0931 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0926 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @0931 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0932: // Incoming jump from 0x0919, if !stack[-1] // Inputs[3] // { // @0936 stack[-3] // @0937 stack[-2] // @0938 stack[-1] // } 0932 5B JUMPDEST 0933 61 PUSH2 0x093d 0936 83 DUP4 0937 83 DUP4 0938 83 DUP4 0939 61 PUSH2 0x165c 093C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0933 stack[0] = 0x093d // @0936 stack[1] = stack[-3] // @0937 stack[2] = stack[-2] // @0938 stack[3] = stack[-1] // } // Block ends with call to 0x165c, returns to 0x093D label_093D: // Incoming return from call to 0x165C at 0x093C // Incoming return from call to 0x1A1F at 0x0F65 // Incoming return from call to 0x1A1F at 0x1587 // Incoming return from call to 0x1CD4 at 0x1C5F // Inputs[1] { @0941 stack[-4] } 093D 5B JUMPDEST 093E 50 POP 093F 50 POP 0940 50 POP 0941 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0942: // Incoming jump from 0x034A // Inputs[2] // { // @0945 storage[0x08] // @094F msg.sender // } 0942 5B JUMPDEST 0943 60 PUSH1 0x08 0945 54 SLOAD 0946 60 PUSH1 0x01 0948 60 PUSH1 0x01 094A 60 PUSH1 0xa0 094C 1B SHL 094D 03 SUB 094E 16 AND 094F 33 CALLER 0950 14 EQ 0951 61 PUSH2 0x0975 0954 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0975, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0955: // Incoming jump from 0x0954, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0957 memory[0x40:0x60] } 0955 60 PUSH1 0x40 0957 51 MLOAD 0958 62 PUSH3 0x461bcd 095C 60 PUSH1 0xe5 095E 1B SHL 095F 81 DUP2 0960 52 MSTORE 0961 60 PUSH1 0x04 0963 01 ADD 0964 61 PUSH2 0x096c 0967 90 SWAP1 0968 61 PUSH2 0x2387 096B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0960 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0967 stack[0] = 0x096c // @0967 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_096C: // Incoming jump from 0x0F08 // Incoming return from call to 0x2387 at 0x09B5 // Incoming return from call to 0x2403 at 0x0E77 // Incoming jump from 0x0A50 // Incoming jump from 0x12FC // Incoming return from call to 0x2403 at 0x1516 // Incoming jump from 0x1475 // Incoming return from call to 0x2449 at 0x1553 // Incoming return from call to 0x2387 at 0x157D // Incoming jump from 0x13BE // Incoming jump from 0x0F5B // Incoming return from call to 0x2387 at 0x14CB // Incoming jump from 0x135E // Incoming return from call to 0x2387 at 0x0E26 // Incoming return from call to 0x2449 at 0x12A8 // Incoming jump from 0x1616 // Incoming return from call to 0x2387 at 0x0C89 // Incoming return from call to 0x2387 at 0x096B // Incoming return from call to 0x2387 at 0x1032 // Incoming return from call to 0x2387 at 0x09FD // Incoming return from call to 0x2387 at 0x1061 // Incoming return from call to 0x2387 at 0x0DF7 // Incoming return from call to 0x2403 at 0x126B // Incoming return from call to 0x2387 at 0x0DC1 // Incoming return from call to 0x2387 at 0x15B1 // Incoming jump from 0x113B // Incoming return from call to 0x2449 at 0x0EB4 // Incoming return from call to 0x2387 at 0x0C5A // Inputs[3] // { // @096F memory[0x40:0x60] // @0971 stack[-1] // @0974 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 096C 5B JUMPDEST 096D 60 PUSH1 0x40 096F 51 MLOAD 0970 80 DUP1 0971 91 SWAP2 0972 03 SUB 0973 90 SWAP1 0974 FD *REVERT // Stack delta = -1 // Outputs[1] { @0974 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0975: // Incoming jump from 0x0954, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0976 stack[-1] // @0977 memory[stack[-1]:stack[-1] + 0x20] // } 0975 5B JUMPDEST 0976 80 DUP1 0977 51 MLOAD 0978 61 PUSH2 0x0988 097B 90 SWAP1 097C 60 PUSH1 0x0d 097E 90 SWAP1 097F 60 PUSH1 0x20 0981 84 DUP5 0982 01 ADD 0983 90 SWAP1 0984 61 PUSH2 0x1ea4 0987 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @097B stack[0] = 0x0988 // @097E stack[1] = 0x0d // @0983 stack[2] = stack[-1] + 0x20 // @0983 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1ea4 label_0988: // Incoming return from call to 0x1C53 at 0x1A38 // Inputs[1] { @098B stack[-3] } 0988 5B JUMPDEST 0989 50 POP 098A 50 POP 098B 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_098C: // Incoming jump from 0x036A // Inputs[2] // { // @098F storage[0x08] // @0999 msg.sender // } 098C 5B JUMPDEST 098D 60 PUSH1 0x08 098F 54 SLOAD 0990 60 PUSH1 0x01 0992 60 PUSH1 0x01 0994 60 PUSH1 0xa0 0996 1B SHL 0997 03 SUB 0998 16 AND 0999 33 CALLER 099A 14 EQ 099B 61 PUSH2 0x09b6 099E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_099F: // Incoming jump from 0x099E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09A1 memory[0x40:0x60] } 099F 60 PUSH1 0x40 09A1 51 MLOAD 09A2 62 PUSH3 0x461bcd 09A6 60 PUSH1 0xe5 09A8 1B SHL 09A9 81 DUP2 09AA 52 MSTORE 09AB 60 PUSH1 0x04 09AD 01 ADD 09AE 61 PUSH2 0x096c 09B1 90 SWAP1 09B2 61 PUSH2 0x2387 09B5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09B1 stack[0] = 0x096c // @09B1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_09B6: // Incoming jump from 0x099E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @09BA storage[0x12] // @09BF stack[-1] // @09C8 stack[-2] // } 09B6 5B JUMPDEST 09B7 60 PUSH1 0x12 09B9 80 DUP1 09BA 54 SLOAD 09BB 60 PUSH1 0xff 09BD 19 NOT 09BE 16 AND 09BF 91 SWAP2 09C0 15 ISZERO 09C1 15 ISZERO 09C2 91 SWAP2 09C3 90 SWAP1 09C4 91 SWAP2 09C5 17 OR 09C6 90 SWAP1 09C7 55 SSTORE 09C8 56 *JUMP // Stack delta = -2 // Outputs[1] { @09C7 storage[0x12] = !!stack[-1] | (~0xff & storage[0x12]) } // Block ends with unconditional jump to stack[-2] label_09C9: // Incoming jump from 0x03A8 // Inputs[3] // { // @09CD stack[-3] // @09CE stack[-2] // @09CF stack[-1] // } 09C9 5B JUMPDEST 09CA 61 PUSH2 0x093d 09CD 83 DUP4 09CE 83 DUP4 09CF 83 DUP4 09D0 61 PUSH2 0x16b8 09D3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09CA stack[0] = 0x093d // @09CD stack[1] = stack[-3] // @09CE stack[2] = stack[-2] // @09CF stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x16b8 label_09D4: // Incoming call from 0x03D3, returns to 0x0305 // Inputs[2] // { // @09D7 storage[0x08] // @09E1 msg.sender // } 09D4 5B JUMPDEST 09D5 60 PUSH1 0x08 09D7 54 SLOAD 09D8 60 PUSH1 0x01 09DA 60 PUSH1 0x01 09DC 60 PUSH1 0xa0 09DE 1B SHL 09DF 03 SUB 09E0 16 AND 09E1 33 CALLER 09E2 14 EQ 09E3 61 PUSH2 0x09fe 09E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09fe, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_09E7: // Incoming jump from 0x09E6, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @09E9 memory[0x40:0x60] } 09E7 60 PUSH1 0x40 09E9 51 MLOAD 09EA 62 PUSH3 0x461bcd 09EE 60 PUSH1 0xe5 09F0 1B SHL 09F1 81 DUP2 09F2 52 MSTORE 09F3 60 PUSH1 0x04 09F5 01 ADD 09F6 61 PUSH2 0x096c 09F9 90 SWAP1 09FA 61 PUSH2 0x2387 09FD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09F9 stack[0] = 0x096c // @09F9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_09FE: // Incoming jump from 0x09E6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0A03 storage[0x09] } 09FE 5B JUMPDEST 09FF 60 PUSH1 0x02 0A01 60 PUSH1 0x09 0A03 54 SLOAD 0A04 14 EQ 0A05 15 ISZERO 0A06 61 PUSH2 0x0a51 0A09 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a51, if !(storage[0x09] == 0x02) label_0A0A: // Incoming jump from 0x0A09, if not !(storage[0x09] == 0x02) // Inputs[1] { @0A0C memory[0x40:0x60] } 0A0A 60 PUSH1 0x40 0A0C 51 MLOAD 0A0D 62 PUSH3 0x461bcd 0A11 60 PUSH1 0xe5 0A13 1B SHL 0A14 81 DUP2 0A15 52 MSTORE 0A16 60 PUSH1 0x20 0A18 60 PUSH1 0x04 0A1A 82 DUP3 0A1B 01 ADD 0A1C 52 MSTORE 0A1D 60 PUSH1 0x1f 0A1F 60 PUSH1 0x24 0A21 82 DUP3 0A22 01 ADD 0A23 52 MSTORE 0A24 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 0A45 60 PUSH1 0x44 0A47 82 DUP3 0A48 01 ADD 0A49 52 MSTORE 0A4A 60 PUSH1 0x64 0A4C 01 ADD 0A4D 61 PUSH2 0x096c 0A50 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A1C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A23 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0A49 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @0A4C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_0A51: // Incoming jump from 0x0A09, if !(storage[0x09] == 0x02) // Inputs[1] { @0A5E storage[0x08] } 0A51 5B JUMPDEST 0A52 60 PUSH1 0x02 0A54 60 PUSH1 0x09 0A56 55 SSTORE 0A57 60 PUSH1 0x00 0A59 61 PUSH2 0x0a6a 0A5C 60 PUSH1 0x08 0A5E 54 SLOAD 0A5F 60 PUSH1 0x01 0A61 60 PUSH1 0x01 0A63 60 PUSH1 0xa0 0A65 1B SHL 0A66 03 SUB 0A67 16 AND 0A68 90 SWAP1 0A69 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A56 storage[0x09] = 0x02 // @0A57 stack[0] = 0x00 // @0A68 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x08] // } // Block ends with unconditional jump to 0x0a6a label_0A6A: // Incoming jump from 0x0A69 // Inputs[9] // { // @0A73 stack[-1] // @0A74 address(this) // @0A74 address(this).balance // @0A77 memory[0x40:0x60] // @0A7C memory[0x40:0x60] // @0A83 msg.gas // @0A84 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @0A84 address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0A89 returndata.length // } 0A6A 5B JUMPDEST 0A6B 60 PUSH1 0x01 0A6D 60 PUSH1 0x01 0A6F 60 PUSH1 0xa0 0A71 1B SHL 0A72 03 SUB 0A73 16 AND 0A74 47 SELFBALANCE 0A75 60 PUSH1 0x40 0A77 51 MLOAD 0A78 60 PUSH1 0x00 0A7A 60 PUSH1 0x40 0A7C 51 MLOAD 0A7D 80 DUP1 0A7E 83 DUP4 0A7F 03 SUB 0A80 81 DUP2 0A81 85 DUP6 0A82 87 DUP8 0A83 5A GAS 0A84 F1 CALL 0A85 92 SWAP3 0A86 50 POP 0A87 50 POP 0A88 50 POP 0A89 3D RETURNDATASIZE 0A8A 80 DUP1 0A8B 60 PUSH1 0x00 0A8D 81 DUP2 0A8E 14 EQ 0A8F 61 PUSH2 0x0ab4 0A92 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0A84 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0A85 stack[-1] = address((0x01 << 0xa0) - 0x01 & stack[-1]).call.gas(msg.gas).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @0A89 stack[0] = returndata.length // @0A8A stack[1] = returndata.length // } // Block ends with conditional jump to 0x0ab4, if returndata.length == 0x00 label_0A93: // Incoming jump from 0x0A92, if not returndata.length == 0x00 // Inputs[6] // { // @0A95 memory[0x40:0x60] // @0A96 stack[-2] // @0A9D returndata.length // @0AA5 returndata.length // @0AA8 returndata.length // @0AAF returndata[0x00:0x00 + returndata.length] // } 0A93 60 PUSH1 0x40 0A95 51 MLOAD 0A96 91 SWAP2 0A97 50 POP 0A98 60 PUSH1 0x1f 0A9A 19 NOT 0A9B 60 PUSH1 0x3f 0A9D 3D RETURNDATASIZE 0A9E 01 ADD 0A9F 16 AND 0AA0 82 DUP3 0AA1 01 ADD 0AA2 60 PUSH1 0x40 0AA4 52 MSTORE 0AA5 3D RETURNDATASIZE 0AA6 82 DUP3 0AA7 52 MSTORE 0AA8 3D RETURNDATASIZE 0AA9 60 PUSH1 0x00 0AAB 60 PUSH1 0x20 0AAD 84 DUP5 0AAE 01 ADD 0AAF 3E RETURNDATACOPY 0AB0 61 PUSH2 0x0ab9 0AB3 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0A96 stack[-2] = memory[0x40:0x60] // @0AA4 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @0AA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @0AAF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0ab9 label_0AB4: // Incoming jump from 0x0A92, if returndata.length == 0x00 // Inputs[3] // { // @0AB7 stack[-2] // @0ABC stack[-4] // @0ABC stack[-3] // } 0AB4 5B JUMPDEST 0AB5 60 PUSH1 0x60 0AB7 91 SWAP2 0AB8 50 POP 0AB9 5B JUMPDEST 0ABA 50 POP 0ABB 50 POP 0ABC 90 SWAP1 0ABD 50 POP 0ABE 80 DUP1 0ABF 61 PUSH2 0x0ac7 0AC2 57 *JUMPI // Stack delta = -3 // Outputs[1] { @0ABC stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0ac7, if stack[-3] label_0AC3: // Incoming jump from 0x0AC2, if not stack[-3] // Incoming jump from 0x0AC2, if not stack[-3] // Inputs[1] { @0AC6 memory[0x00:0x00] } 0AC3 60 PUSH1 0x00 0AC5 80 DUP1 0AC6 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AC6 revert(memory[0x00:0x00]); } // Block terminates label_0AC7: // Incoming jump from 0x0AC2, if stack[-3] // Incoming jump from 0x0AC2, if stack[-3] // Inputs[1] { @0ACE stack[-2] } 0AC7 5B JUMPDEST 0AC8 50 POP 0AC9 60 PUSH1 0x01 0ACB 60 PUSH1 0x09 0ACD 55 SSTORE 0ACE 56 *JUMP // Stack delta = -2 // Outputs[1] { @0ACD storage[0x09] = 0x01 } // Block ends with unconditional jump to stack[-2] label_0ACF: // Incoming jump from 0x03F3 // Inputs[4] // { // @0AD3 stack[-3] // @0AD4 stack[-2] // @0AD5 stack[-1] // @0AD8 memory[0x40:0x60] // } 0ACF 5B JUMPDEST 0AD0 61 PUSH2 0x093d 0AD3 83 DUP4 0AD4 83 DUP4 0AD5 83 DUP4 0AD6 60 PUSH1 0x40 0AD8 51 MLOAD 0AD9 80 DUP1 0ADA 60 PUSH1 0x20 0ADC 01 ADD 0ADD 60 PUSH1 0x40 0ADF 52 MSTORE 0AE0 80 DUP1 0AE1 60 PUSH1 0x00 0AE3 81 DUP2 0AE4 52 MSTORE 0AE5 50 POP 0AE6 61 PUSH2 0x107c 0AE9 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0AD0 stack[0] = 0x093d // @0AD3 stack[1] = stack[-3] // @0AD4 stack[2] = stack[-2] // @0AD5 stack[3] = stack[-1] // @0AD8 stack[4] = memory[0x40:0x60] // @0ADF memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0AE4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x107c label_0AEA: // Incoming jump from 0x0413 // Inputs[1] { @0AF2 stack[-1] } 0AEA 5B JUMPDEST 0AEB 60 PUSH1 0x60 0AED 60 PUSH1 0x00 0AEF 61 PUSH2 0x0af7 0AF2 83 DUP4 0AF3 61 PUSH2 0x0d4a 0AF6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AEB stack[0] = 0x60 // @0AED stack[1] = 0x00 // @0AEF stack[2] = 0x0af7 // @0AF2 stack[3] = stack[-1] // } // Block ends with call to 0x0d4a, returns to 0x0AF7 label_0AF7: // Incoming return from call to 0x0D4A at 0x0AF6 // Inputs[2] // { // @0AF8 stack[-2] // @0AF8 stack[-1] // } 0AF7 5B JUMPDEST 0AF8 90 SWAP1 0AF9 50 POP 0AFA 60 PUSH1 0x00 0AFC 81 DUP2 0AFD 60 PUSH1 0x01 0AFF 60 PUSH1 0x01 0B01 60 PUSH1 0x40 0B03 1B SHL 0B04 03 SUB 0B05 81 DUP2 0B06 11 GT 0B07 15 ISZERO 0B08 61 PUSH2 0x0b13 0B0B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0AF8 stack[-2] = stack[-1] // @0AFA stack[-1] = 0x00 // @0AFC stack[0] = stack[-1] // } // Block ends with conditional jump to 0x0b13, if !(stack[-1] > (0x01 << 0x40) - 0x01) label_0B0C: // Incoming jump from 0x0B0B, if not !(stack[-1] > (0x01 << 0x40) - 0x01) 0B0C 61 PUSH2 0x0b13 0B0F 61 PUSH2 0x203a 0B12 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B0C stack[0] = 0x0b13 } // Block ends with unconditional jump to 0x203a label_0B13: // Incoming jump from 0x0B0B, if !(stack[-1] > (0x01 << 0x40) - 0x01) // Inputs[2] // { // @0B16 memory[0x40:0x60] // @0B17 stack[-1] // } 0B13 5B JUMPDEST 0B14 60 PUSH1 0x40 0B16 51 MLOAD 0B17 90 SWAP1 0B18 80 DUP1 0B19 82 DUP3 0B1A 52 MSTORE 0B1B 80 DUP1 0B1C 60 PUSH1 0x20 0B1E 02 MUL 0B1F 60 PUSH1 0x20 0B21 01 ADD 0B22 82 DUP3 0B23 01 ADD 0B24 60 PUSH1 0x40 0B26 52 MSTORE 0B27 80 DUP1 0B28 15 ISZERO 0B29 61 PUSH2 0x0b3c 0B2C 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0B17 stack[-1] = memory[0x40:0x60] // @0B17 stack[0] = stack[-1] // @0B1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B26 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0b3c, if !stack[-1] label_0B2D: // Incoming jump from 0x0B2C, if not !stack[-1] // Inputs[6] // { // @0B2D stack[-2] // @0B33 stack[-1] // @0B36 msg.data.length // @0B38 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0B3E stack[-3] // @0B46 stack[-4] // } 0B2D 81 DUP2 0B2E 60 PUSH1 0x20 0B30 01 ADD 0B31 60 PUSH1 0x20 0B33 82 DUP3 0B34 02 MUL 0B35 80 DUP1 0B36 36 CALLDATASIZE 0B37 83 DUP4 0B38 37 CALLDATACOPY 0B39 01 ADD 0B3A 90 SWAP1 0B3B 50 POP 0B3C 5B JUMPDEST 0B3D 50 POP 0B3E 90 SWAP1 0B3F 50 POP 0B40 60 PUSH1 0x01 0B42 60 PUSH1 0x00 0B44 80 DUP1 0B45 5B JUMPDEST 0B46 84 DUP5 0B47 82 DUP3 0B48 10 LT 0B49 80 DUP1 0B4A 15 ISZERO 0B4B 61 PUSH2 0x0b56 0B4E 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @0B38 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0B3E stack[-3] = stack[-2] // @0B40 stack[-2] = 0x01 // @0B42 stack[-1] = 0x00 // @0B44 stack[0] = 0x00 // @0B48 stack[1] = 0x00 < stack[-4] // } // Block ends with conditional jump to 0x0b56, if !(0x00 < stack[-4]) label_0B4F: // Incoming jump from 0x0B4E, if not !(0x00 < stack[-4]) // Incoming jump from 0x0B4E, if not !(stack[-2] < stack[-5]) // Incoming jump from 0x0B4E, if not !(0x00 < stack[-4]) // Inputs[2] // { // @0B52 storage[0x10] // @0B53 stack[-4] // } 0B4F 50 POP 0B50 60 PUSH1 0x10 0B52 54 SLOAD 0B53 83 DUP4 0B54 11 GT 0B55 15 ISZERO 0B56 5B JUMPDEST 0B57 15 ISZERO 0B58 61 PUSH2 0x0c26 0B5B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c26, if !!(stack[-4] > storage[0x10]) label_0B5C: // Incoming jump from 0x0B5B, if not !!(stack[-4] > storage[0x10]) // Incoming jump from 0x0B5B, if not !stack[-1] // Inputs[4] // { // @0B5E stack[-3] // @0B6D memory[0x00:0x40] // @0B6F memory[0x40:0x60] // @0B77 storage[keccak256(memory[0x00:0x40])] // } 0B5C 60 PUSH1 0x00 0B5E 83 DUP4 0B5F 81 DUP2 0B60 52 MSTORE 0B61 60 PUSH1 0x04 0B63 60 PUSH1 0x20 0B65 90 SWAP1 0B66 81 DUP2 0B67 52 MSTORE 0B68 60 PUSH1 0x40 0B6A 91 SWAP2 0B6B 82 DUP3 0B6C 90 SWAP1 0B6D 20 SHA3 0B6E 82 DUP3 0B6F 51 MLOAD 0B70 60 PUSH1 0x60 0B72 81 DUP2 0B73 01 ADD 0B74 84 DUP5 0B75 52 MSTORE 0B76 90 SWAP1 0B77 54 SLOAD 0B78 60 PUSH1 0x01 0B7A 60 PUSH1 0x01 0B7C 60 PUSH1 0xa0 0B7E 1B SHL 0B7F 03 SUB 0B80 81 DUP2 0B81 16 AND 0B82 82 DUP3 0B83 52 MSTORE 0B84 60 PUSH1 0x01 0B86 60 PUSH1 0xa0 0B88 1B SHL 0B89 81 DUP2 0B8A 04 DIV 0B8B 60 PUSH1 0x01 0B8D 60 PUSH1 0x01 0B8F 60 PUSH1 0x40 0B91 1B SHL 0B92 03 SUB 0B93 16 AND 0B94 92 SWAP3 0B95 82 DUP3 0B96 01 ADD 0B97 92 SWAP3 0B98 90 SWAP1 0B99 92 SWAP3 0B9A 52 MSTORE 0B9B 60 PUSH1 0x01 0B9D 60 PUSH1 0xe0 0B9F 1B SHL 0BA0 90 SWAP1 0BA1 91 SWAP2 0BA2 04 DIV 0BA3 60 PUSH1 0xff 0BA5 16 AND 0BA6 15 ISZERO 0BA7 80 DUP1 0BA8 15 ISZERO 0BA9 92 SWAP3 0BAA 82 DUP3 0BAB 01 ADD 0BAC 83 DUP4 0BAD 90 SWAP1 0BAE 52 MSTORE 0BAF 90 SWAP1 0BB0 91 SWAP2 0BB1 61 PUSH2 0x0bc3 0BB4 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @0B60 memory[0x00:0x20] = stack[-3] // @0B67 memory[0x20:0x40] = 0x04 // @0B75 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @0B83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0B9A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0BAE memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @0BAF stack[1] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @0BB0 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x0bc3, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_0BB5: // Incoming jump from 0x0BB4, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @0BB6 stack[-2] // @0BB7 memory[stack[-2]:stack[-2] + 0x20] // } 0BB5 50 POP 0BB6 80 DUP1 0BB7 51 MLOAD 0BB8 60 PUSH1 0x01 0BBA 60 PUSH1 0x01 0BBC 60 PUSH1 0xa0 0BBE 1B SHL 0BBF 03 SUB 0BC0 16 AND 0BC1 15 ISZERO 0BC2 15 ISZERO 0BC3 5B JUMPDEST 0BC4 15 ISZERO 0BC5 61 PUSH2 0x0bcd 0BC8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bcd, if !!!((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) label_0BC9: // Incoming jump from 0x0BC8, if not !!!((0x01 << 0xa0) - 0x01 & memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0BC8, if not !stack[-1] // Inputs[4] // { // @0BC9 stack[-1] // @0BCA memory[stack[-1]:stack[-1] + 0x20] // @0BCB stack[-2] // @0BCE stack[-8] // } 0BC9 80 DUP1 0BCA 51 MLOAD 0BCB 91 SWAP2 0BCC 50 POP 0BCD 5B JUMPDEST 0BCE 87 DUP8 0BCF 60 PUSH1 0x01 0BD1 60 PUSH1 0x01 0BD3 60 PUSH1 0xa0 0BD5 1B SHL 0BD6 03 SUB 0BD7 16 AND 0BD8 82 DUP3 0BD9 60 PUSH1 0x01 0BDB 60 PUSH1 0x01 0BDD 60 PUSH1 0xa0 0BDF 1B SHL 0BE0 03 SUB 0BE1 16 AND 0BE2 14 EQ 0BE3 15 ISZERO 0BE4 61 PUSH2 0x0c13 0BE7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0BCB stack[-2] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0c13, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) label_0BE8: // Incoming jump from 0x0BE7, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0BE7, if not !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[4] // { // @0BE8 stack[-4] // @0BE9 stack[-5] // @0BEA stack[-3] // @0BEC memory[stack[-5]:stack[-5] + 0x20] // } 0BE8 83 DUP4 0BE9 85 DUP6 0BEA 84 DUP5 0BEB 81 DUP2 0BEC 51 MLOAD 0BED 81 DUP2 0BEE 10 LT 0BEF 61 PUSH2 0x0bfa 0BF2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0BE8 stack[0] = stack[-4] // @0BE9 stack[1] = stack[-5] // @0BEA stack[2] = stack[-3] // } // Block ends with conditional jump to 0x0bfa, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] label_0BF3: // Incoming jump from 0x0BF2, if not stack[-3] < memory[stack[-5]:stack[-5] + 0x20] 0BF3 61 PUSH2 0x0bfa 0BF6 61 PUSH2 0x23bc 0BF9 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BF3 stack[0] = 0x0bfa } // Block ends with unconditional jump to 0x23bc label_0BFA: // Incoming jump from 0x0BF2, if stack[-3] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[4] // { // @0BFD stack[-1] // @0C00 stack[-2] // @0C05 stack[-3] // @0C06 stack[-6] // } 0BFA 5B JUMPDEST 0BFB 60 PUSH1 0x20 0BFD 90 SWAP1 0BFE 81 DUP2 0BFF 02 MUL 0C00 91 SWAP2 0C01 90 SWAP1 0C02 91 SWAP2 0C03 01 ADD 0C04 01 ADD 0C05 52 MSTORE 0C06 82 DUP3 0C07 61 PUSH2 0x0c0f 0C0A 81 DUP2 0C0B 61 PUSH2 0x23e8 0C0E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0C05 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0C06 stack[-3] = stack[-6] // @0C07 stack[-2] = 0x0c0f // @0C0A stack[-1] = stack[-6] // } // Block ends with call to 0x23e8, returns to 0x0C0F label_0C0F: // Incoming return from call to 0x23E8 at 0x0C0E // Inputs[2] // { // @0C10 stack[-5] // @0C10 stack[-1] // } 0C0F 5B JUMPDEST 0C10 93 SWAP4 0C11 50 POP 0C12 50 POP // Stack delta = -2 // Outputs[1] { @0C10 stack[-5] = stack[-1] } // Block continues label_0C13: // Incoming jump from 0x0C12 // Incoming jump from 0x0BE7, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0BE7, if !((0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[1] { @0C14 stack[-4] } 0C13 5B JUMPDEST 0C14 83 DUP4 0C15 61 PUSH2 0x0c1d 0C18 81 DUP2 0C19 61 PUSH2 0x23e8 0C1C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C14 stack[0] = stack[-4] // @0C15 stack[1] = 0x0c1d // @0C18 stack[2] = stack[-4] // } // Block ends with call to 0x23e8, returns to 0x0C1D label_0C1D: // Incoming return from call to 0x23E8 at 0x0C1C // Inputs[2] // { // @0C1E stack[-6] // @0C1E stack[-1] // } 0C1D 5B JUMPDEST 0C1E 94 SWAP5 0C1F 50 POP 0C20 50 POP 0C21 50 POP 0C22 61 PUSH2 0x0b45 0C25 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C1E stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x0b45 label_0C26: // Incoming jump from 0x0B5B, if !!(stack[-4] > storage[0x10]) // Incoming jump from 0x0B5B, if !stack[-1] // Inputs[4] // { // @0C28 stack[-2] // @0C28 stack[-4] // @0C29 stack[-8] // @0C2A stack[-7] // } 0C26 5B JUMPDEST 0C27 50 POP 0C28 91 SWAP2 0C29 95 SWAP6 0C2A 94 SWAP5 0C2B 50 POP 0C2C 50 POP 0C2D 50 POP 0C2E 50 POP 0C2F 50 POP 0C30 56 *JUMP // Stack delta = -7 // Outputs[1] { @0C29 stack[-8] = stack[-4] } // Block ends with unconditional jump to stack[-8] label_0C31: // Incoming jump from 0x0440 // Inputs[2] // { // @0C34 storage[0x08] // @0C3E msg.sender // } 0C31 5B JUMPDEST 0C32 60 PUSH1 0x08 0C34 54 SLOAD 0C35 60 PUSH1 0x01 0C37 60 PUSH1 0x01 0C39 60 PUSH1 0xa0 0C3B 1B SHL 0C3C 03 SUB 0C3D 16 AND 0C3E 33 CALLER 0C3F 14 EQ 0C40 61 PUSH2 0x0c5b 0C43 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c5b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0C44: // Incoming jump from 0x0C43, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0C46 memory[0x40:0x60] } 0C44 60 PUSH1 0x40 0C46 51 MLOAD 0C47 62 PUSH3 0x461bcd 0C4B 60 PUSH1 0xe5 0C4D 1B SHL 0C4E 81 DUP2 0C4F 52 MSTORE 0C50 60 PUSH1 0x04 0C52 01 ADD 0C53 61 PUSH2 0x096c 0C56 90 SWAP1 0C57 61 PUSH2 0x2387 0C5A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C56 stack[0] = 0x096c // @0C56 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_0C5B: // Incoming jump from 0x0C43, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0C5E stack[-1] // @0C5F stack[-2] // } 0C5B 5B JUMPDEST 0C5C 60 PUSH1 0x0f 0C5E 55 SSTORE 0C5F 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C5E storage[0x0f] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C60: // Incoming jump from 0x0460 // Inputs[2] // { // @0C63 storage[0x08] // @0C6D msg.sender // } 0C60 5B JUMPDEST 0C61 60 PUSH1 0x08 0C63 54 SLOAD 0C64 60 PUSH1 0x01 0C66 60 PUSH1 0x01 0C68 60 PUSH1 0xa0 0C6A 1B SHL 0C6B 03 SUB 0C6C 16 AND 0C6D 33 CALLER 0C6E 14 EQ 0C6F 61 PUSH2 0x0c8a 0C72 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c8a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0C73: // Incoming jump from 0x0C72, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0C75 memory[0x40:0x60] } 0C73 60 PUSH1 0x40 0C75 51 MLOAD 0C76 62 PUSH3 0x461bcd 0C7A 60 PUSH1 0xe5 0C7C 1B SHL 0C7D 81 DUP2 0C7E 52 MSTORE 0C7F 60 PUSH1 0x04 0C81 01 ADD 0C82 61 PUSH2 0x096c 0C85 90 SWAP1 0C86 61 PUSH2 0x2387 0C89 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C7E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C85 stack[0] = 0x096c // @0C85 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_0C8A: // Incoming jump from 0x0C72, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0C8B stack[-1] // @0C8C memory[stack[-1]:stack[-1] + 0x20] // } 0C8A 5B JUMPDEST 0C8B 80 DUP1 0C8C 51 MLOAD 0C8D 61 PUSH2 0x0988 0C90 90 SWAP1 0C91 60 PUSH1 0x0e 0C93 90 SWAP1 0C94 60 PUSH1 0x20 0C96 84 DUP5 0C97 01 ADD 0C98 90 SWAP1 0C99 61 PUSH2 0x1ea4 0C9C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C90 stack[0] = 0x0988 // @0C93 stack[1] = 0x0e // @0C98 stack[2] = stack[-1] + 0x20 // @0C98 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1ea4 label_0C9D: // Incoming call from 0x0495, returns to 0x02A0 // Inputs[1] { @0CA1 storage[0x0d] } 0C9D 5B JUMPDEST 0C9E 60 PUSH1 0x0d 0CA0 80 DUP1 0CA1 54 SLOAD 0CA2 61 PUSH2 0x0caa 0CA5 90 SWAP1 0CA6 61 PUSH2 0x234c 0CA9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C9E stack[0] = 0x0d // @0CA5 stack[1] = 0x0caa // @0CA5 stack[2] = storage[0x0d] // } // Block ends with call to 0x234c, returns to 0x0CAA label_0CAA: // Incoming return from call to 0x234C at 0x0D37 // Incoming return from call to 0x234C at 0x1008 // Incoming return from call to 0x234C at 0x0CA9 // Inputs[4] // { // @0CAB stack[-1] // @0CBA memory[0x40:0x60] // @0CC2 stack[-2] // @0CCD storage[stack[-2]] // } 0CAA 5B JUMPDEST 0CAB 80 DUP1 0CAC 60 PUSH1 0x1f 0CAE 01 ADD 0CAF 60 PUSH1 0x20 0CB1 80 DUP1 0CB2 91 SWAP2 0CB3 04 DIV 0CB4 02 MUL 0CB5 60 PUSH1 0x20 0CB7 01 ADD 0CB8 60 PUSH1 0x40 0CBA 51 MLOAD 0CBB 90 SWAP1 0CBC 81 DUP2 0CBD 01 ADD 0CBE 60 PUSH1 0x40 0CC0 52 MSTORE 0CC1 80 DUP1 0CC2 92 SWAP3 0CC3 91 SWAP2 0CC4 90 SWAP1 0CC5 81 DUP2 0CC6 81 DUP2 0CC7 52 MSTORE 0CC8 60 PUSH1 0x20 0CCA 01 ADD 0CCB 82 DUP3 0CCC 80 DUP1 0CCD 54 SLOAD 0CCE 61 PUSH2 0x0cd6 0CD1 90 SWAP1 0CD2 61 PUSH2 0x234c 0CD5 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0CC0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0CC2 stack[-2] = memory[0x40:0x60] // @0CC3 stack[-1] = stack[-2] // @0CC4 stack[0] = stack[-1] // @0CC7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0CCA stack[1] = 0x20 + memory[0x40:0x60] // @0CCB stack[2] = stack[-2] // @0CD1 stack[4] = storage[stack[-2]] // @0CD1 stack[3] = 0x0cd6 // } // Block ends with call to 0x234c, returns to 0x0CD6 label_0CD6: // Incoming return from call to 0x234C at 0x0CD5 // Inputs[1] { @0CD7 stack[-1] } 0CD6 5B JUMPDEST 0CD7 80 DUP1 0CD8 15 ISZERO 0CD9 61 PUSH2 0x0d23 0CDC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d23, if !stack[-1] label_0CDD: // Incoming jump from 0x0CDC, if not !stack[-1] // Inputs[1] { @0CDD stack[-1] } 0CDD 80 DUP1 0CDE 60 PUSH1 0x1f 0CE0 10 LT 0CE1 61 PUSH2 0x0cf8 0CE4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cf8, if 0x1f < stack[-1] label_0CE5: // Incoming jump from 0x0CE4, if not 0x1f < stack[-1] // Inputs[4] // { // @0CE9 stack[-2] // @0CEA storage[stack[-2]] // @0CED stack[-3] // @0CEF stack[-1] // } 0CE5 61 PUSH2 0x0100 0CE8 80 DUP1 0CE9 83 DUP4 0CEA 54 SLOAD 0CEB 04 DIV 0CEC 02 MUL 0CED 83 DUP4 0CEE 52 MSTORE 0CEF 91 SWAP2 0CF0 60 PUSH1 0x20 0CF2 01 ADD 0CF3 91 SWAP2 0CF4 61 PUSH2 0x0d23 0CF7 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0CEE memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0CF3 stack[-1] = stack[-1] // @0CF3 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0d23 label_0CF8: // Incoming jump from 0x0CE4, if 0x1f < stack[-1] // Inputs[5] // { // @0CF9 stack[-3] // @0CFA stack[-1] // @0CFC stack[-2] // @0D04 memory[0x00:0x20] // @0D08 storage[keccak256(memory[0x00:0x20])] // } 0CF8 5B JUMPDEST 0CF9 82 DUP3 0CFA 01 ADD 0CFB 91 SWAP2 0CFC 90 SWAP1 0CFD 60 PUSH1 0x00 0CFF 52 MSTORE 0D00 60 PUSH1 0x20 0D02 60 PUSH1 0x00 0D04 20 SHA3 0D05 90 SWAP1 0D06 5B JUMPDEST 0D07 81 DUP2 0D08 54 SLOAD 0D09 81 DUP2 0D0A 52 MSTORE 0D0B 90 SWAP1 0D0C 60 PUSH1 0x01 0D0E 01 ADD 0D0F 90 SWAP1 0D10 60 PUSH1 0x20 0D12 01 ADD 0D13 80 DUP1 0D14 83 DUP4 0D15 11 GT 0D16 61 PUSH2 0x0d06 0D19 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0CFB stack[-3] = stack[-3] + stack[-1] // @0CFF memory[0x00:0x20] = stack[-2] // @0D0A memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0D0F stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0D12 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0d06, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0D1A: // Incoming jump from 0x0D19, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0D19, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0D1A stack[-3] // @0D1B stack[-1] // } 0D1A 82 DUP3 0D1B 90 SWAP1 0D1C 03 SUB 0D1D 60 PUSH1 0x1f 0D1F 16 AND 0D20 82 DUP3 0D21 01 ADD 0D22 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0D22 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0D22 stack[-1] = stack[-3] // } // Block continues label_0D23: // Incoming jump from 0x0CF7 // Incoming jump from 0x0CDC, if !stack[-1] // Incoming jump from 0x0D22 // Inputs[1] { @0D29 stack[-7] } 0D23 5B JUMPDEST 0D24 50 POP 0D25 50 POP 0D26 50 POP 0D27 50 POP 0D28 50 POP 0D29 81 DUP2 0D2A 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0D2B: // Incoming call from 0x04C4, returns to 0x02A0 // Inputs[1] { @0D2F storage[0x0c] } 0D2B 5B JUMPDEST 0D2C 60 PUSH1 0x0c 0D2E 80 DUP1 0D2F 54 SLOAD 0D30 61 PUSH2 0x0caa 0D33 90 SWAP1 0D34 61 PUSH2 0x234c 0D37 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D2C stack[0] = 0x0c // @0D33 stack[1] = 0x0caa // @0D33 stack[2] = storage[0x0c] // } // Block ends with call to 0x234c, returns to 0x0CAA label_0D38: // Incoming call from 0x08BE, returns to 0x08BF // Incoming jump from 0x04E4 // Inputs[1] { @0D3E stack[-1] } 0D38 5B JUMPDEST 0D39 60 PUSH1 0x00 0D3B 61 PUSH2 0x0d43 0D3E 82 DUP3 0D3F 61 PUSH2 0x18a6 0D42 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D39 stack[0] = 0x00 // @0D3B stack[1] = 0x0d43 // @0D3E stack[2] = stack[-1] // } // Block ends with call to 0x18a6, returns to 0x0D43 label_0D43: // Incoming return from call to 0x18A6 at 0x0D42 // Inputs[4] // { // @0D44 memory[stack[-1]:stack[-1] + 0x20] // @0D44 stack[-1] // @0D45 stack[-4] // @0D46 stack[-3] // } 0D43 5B JUMPDEST 0D44 51 MLOAD 0D45 92 SWAP3 0D46 91 SWAP2 0D47 50 POP 0D48 50 POP 0D49 56 *JUMP // Stack delta = -3 // Outputs[1] { @0D45 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0D4A: // Incoming call from 0x0AF6, returns to 0x0AF7 // Incoming jump from 0x0523 // Inputs[1] { @0D55 stack[-1] } 0D4A 5B JUMPDEST 0D4B 60 PUSH1 0x00 0D4D 60 PUSH1 0x01 0D4F 60 PUSH1 0x01 0D51 60 PUSH1 0xa0 0D53 1B SHL 0D54 03 SUB 0D55 82 DUP3 0D56 16 AND 0D57 61 PUSH2 0x0d73 0D5A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D4B stack[0] = 0x00 } // Block ends with conditional jump to 0x0d73, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0D5B: // Incoming jump from 0x0D5A, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0D5D memory[0x40:0x60] // @0D6D memory[0x40:0x60] // @0D72 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D5B 60 PUSH1 0x40 0D5D 51 MLOAD 0D5E 63 PUSH4 0x23d3ad81 0D63 60 PUSH1 0xe2 0D65 1B SHL 0D66 81 DUP2 0D67 52 MSTORE 0D68 60 PUSH1 0x04 0D6A 01 ADD 0D6B 60 PUSH1 0x40 0D6D 51 MLOAD 0D6E 80 DUP1 0D6F 91 SWAP2 0D70 03 SUB 0D71 90 SWAP1 0D72 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D67 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0D72 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D73: // Incoming jump from 0x0D5A, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0D7D stack[-2] // @0D8B memory[0x00:0x40] // @0D8C storage[keccak256(memory[0x00:0x40])] // @0D96 stack[-3] // } 0D73 5B JUMPDEST 0D74 50 POP 0D75 60 PUSH1 0x01 0D77 60 PUSH1 0x01 0D79 60 PUSH1 0xa0 0D7B 1B SHL 0D7C 03 SUB 0D7D 16 AND 0D7E 60 PUSH1 0x00 0D80 90 SWAP1 0D81 81 DUP2 0D82 52 MSTORE 0D83 60 PUSH1 0x05 0D85 60 PUSH1 0x20 0D87 52 MSTORE 0D88 60 PUSH1 0x40 0D8A 90 SWAP1 0D8B 20 SHA3 0D8C 54 SLOAD 0D8D 60 PUSH1 0x01 0D8F 60 PUSH1 0x01 0D91 60 PUSH1 0x40 0D93 1B SHL 0D94 03 SUB 0D95 16 AND 0D96 90 SWAP1 0D97 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0D82 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0D87 memory[0x20:0x40] = 0x05 // @0D96 stack[-3] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0D98: // Incoming call from 0x0538, returns to 0x0305 // Inputs[2] // { // @0D9B storage[0x08] // @0DA5 msg.sender // } 0D98 5B JUMPDEST 0D99 60 PUSH1 0x08 0D9B 54 SLOAD 0D9C 60 PUSH1 0x01 0D9E 60 PUSH1 0x01 0DA0 60 PUSH1 0xa0 0DA2 1B SHL 0DA3 03 SUB 0DA4 16 AND 0DA5 33 CALLER 0DA6 14 EQ 0DA7 61 PUSH2 0x0dc2 0DAA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0dc2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0DAB: // Incoming jump from 0x0DAA, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0DAD memory[0x40:0x60] } 0DAB 60 PUSH1 0x40 0DAD 51 MLOAD 0DAE 62 PUSH3 0x461bcd 0DB2 60 PUSH1 0xe5 0DB4 1B SHL 0DB5 81 DUP2 0DB6 52 MSTORE 0DB7 60 PUSH1 0x04 0DB9 01 ADD 0DBA 61 PUSH2 0x096c 0DBD 90 SWAP1 0DBE 61 PUSH2 0x2387 0DC1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DBD stack[0] = 0x096c // @0DBD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_0DC2: // Incoming jump from 0x0DAA, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] 0DC2 5B JUMPDEST 0DC3 61 PUSH2 0x0dcc 0DC6 60 PUSH1 0x00 0DC8 61 PUSH2 0x19cd 0DCB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DC3 stack[0] = 0x0dcc // @0DC6 stack[1] = 0x00 // } // Block ends with call to 0x19cd, returns to 0x0DCC label_0DCC: // Incoming return from call to 0x19CD at 0x0DCB // Inputs[1] { @0DCD stack[-1] } 0DCC 5B JUMPDEST 0DCD 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0DCE: // Incoming jump from 0x0558 // Inputs[2] // { // @0DD1 storage[0x08] // @0DDB msg.sender // } 0DCE 5B JUMPDEST 0DCF 60 PUSH1 0x08 0DD1 54 SLOAD 0DD2 60 PUSH1 0x01 0DD4 60 PUSH1 0x01 0DD6 60 PUSH1 0xa0 0DD8 1B SHL 0DD9 03 SUB 0DDA 16 AND 0DDB 33 CALLER 0DDC 14 EQ 0DDD 61 PUSH2 0x0df8 0DE0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0df8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0DE1: // Incoming jump from 0x0DE0, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0DE3 memory[0x40:0x60] } 0DE1 60 PUSH1 0x40 0DE3 51 MLOAD 0DE4 62 PUSH3 0x461bcd 0DE8 60 PUSH1 0xe5 0DEA 1B SHL 0DEB 81 DUP2 0DEC 52 MSTORE 0DED 60 PUSH1 0x04 0DEF 01 ADD 0DF0 61 PUSH2 0x096c 0DF3 90 SWAP1 0DF4 61 PUSH2 0x2387 0DF7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DEC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DF3 stack[0] = 0x096c // @0DF3 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_0DF8: // Incoming jump from 0x0DE0, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0DFB stack[-1] // @0DFC stack[-2] // } 0DF8 5B JUMPDEST 0DF9 60 PUSH1 0x0a 0DFB 55 SSTORE 0DFC 56 *JUMP // Stack delta = -2 // Outputs[1] { @0DFB storage[0x0a] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0DFD: // Incoming jump from 0x0578 // Inputs[2] // { // @0E00 storage[0x08] // @0E0A msg.sender // } 0DFD 5B JUMPDEST 0DFE 60 PUSH1 0x08 0E00 54 SLOAD 0E01 60 PUSH1 0x01 0E03 60 PUSH1 0x01 0E05 60 PUSH1 0xa0 0E07 1B SHL 0E08 03 SUB 0E09 16 AND 0E0A 33 CALLER 0E0B 14 EQ 0E0C 61 PUSH2 0x0e27 0E0F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e27, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_0E10: // Incoming jump from 0x0E0F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @0E12 memory[0x40:0x60] } 0E10 60 PUSH1 0x40 0E12 51 MLOAD 0E13 62 PUSH3 0x461bcd 0E17 60 PUSH1 0xe5 0E19 1B SHL 0E1A 81 DUP2 0E1B 52 MSTORE 0E1C 60 PUSH1 0x04 0E1E 01 ADD 0E1F 61 PUSH2 0x096c 0E22 90 SWAP1 0E23 61 PUSH2 0x2387 0E26 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E22 stack[0] = 0x096c // @0E22 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_0E27: // Incoming jump from 0x0E0F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @0E28 stack[-1] // @0E29 memory[stack[-1]:stack[-1] + 0x20] // } 0E27 5B JUMPDEST 0E28 80 DUP1 0E29 51 MLOAD 0E2A 61 PUSH2 0x0988 0E2D 90 SWAP1 0E2E 60 PUSH1 0x0c 0E30 90 SWAP1 0E31 60 PUSH1 0x20 0E33 84 DUP5 0E34 01 ADD 0E35 90 SWAP1 0E36 61 PUSH2 0x1ea4 0E39 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E2D stack[0] = 0x0988 // @0E30 stack[1] = 0x0c // @0E35 stack[2] = stack[-1] + 0x20 // @0E35 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1ea4 label_0E3A: // Incoming call from 0x05C1, returns to 0x02A0 // Inputs[1] { @0E40 storage[0x03] } 0E3A 5B JUMPDEST 0E3B 60 PUSH1 0x60 0E3D 60 PUSH1 0x03 0E3F 80 DUP1 0E40 54 SLOAD 0E41 61 PUSH2 0x07ed 0E44 90 SWAP1 0E45 61 PUSH2 0x234c 0E48 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E3B stack[0] = 0x60 // @0E3D stack[1] = 0x03 // @0E44 stack[2] = 0x07ed // @0E44 stack[3] = storage[0x03] // } // Block ends with call to 0x234c, returns to 0x07ED label_0E49: // Incoming jump from 0x05D4 // Inputs[1] { @0E4A stack[-1] } 0E49 5B JUMPDEST 0E4A 80 DUP1 0E4B 60 PUSH1 0x00 0E4D 81 DUP2 0E4E 11 GT 0E4F 80 DUP1 0E50 15 ISZERO 0E51 61 PUSH2 0x0e5c 0E54 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0E4A stack[0] = stack[-1] // @0E4E stack[1] = stack[-1] > 0x00 // } // Block ends with conditional jump to 0x0e5c, if !(stack[-1] > 0x00) label_0E55: // Incoming jump from 0x0E54, if not !(stack[-1] > 0x00) // Inputs[2] // { // @0E58 storage[0x11] // @0E59 stack[-2] // } 0E55 50 POP 0E56 60 PUSH1 0x11 0E58 54 SLOAD 0E59 81 DUP2 0E5A 11 GT 0E5B 15 ISZERO 0E5C 5B JUMPDEST 0E5D 61 PUSH2 0x0e78 0E60 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e78, if !(stack[-2] > storage[0x11]) label_0E61: // Incoming jump from 0x0E60, if not !(stack[-2] > storage[0x11]) // Incoming jump from 0x0E60, if not stack[-1] // Inputs[1] { @0E63 memory[0x40:0x60] } 0E61 60 PUSH1 0x40 0E63 51 MLOAD 0E64 62 PUSH3 0x461bcd 0E68 60 PUSH1 0xe5 0E6A 1B SHL 0E6B 81 DUP2 0E6C 52 MSTORE 0E6D 60 PUSH1 0x04 0E6F 01 ADD 0E70 61 PUSH2 0x096c 0E73 90 SWAP1 0E74 61 PUSH2 0x2403 0E77 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E6C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E73 stack[0] = 0x096c // @0E73 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2403, returns to 0x096C label_0E78: // Incoming jump from 0x0E60, if !(stack[-2] > storage[0x11]) // Incoming jump from 0x0E60, if stack[-1] // Inputs[4] // { // @0E7B storage[0x10] // @0E7C stack[-1] // @0E82 storage[0x01] // @0E85 storage[0x00] // } 0E78 5B JUMPDEST 0E79 60 PUSH1 0x10 0E7B 54 SLOAD 0E7C 81 DUP2 0E7D 61 PUSH2 0x0e8d 0E80 60 PUSH1 0x01 0E82 54 SLOAD 0E83 60 PUSH1 0x00 0E85 54 SLOAD 0E86 03 SUB 0E87 60 PUSH1 0x00 0E89 19 NOT 0E8A 01 ADD 0E8B 90 SWAP1 0E8C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E7B stack[0] = storage[0x10] // @0E7C stack[1] = stack[-1] // @0E8B stack[2] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with unconditional jump to 0x0e8d label_0E8D: // Incoming jump from 0x0E8C // Inputs[2] // { // @0E91 stack[-2] // @0E92 stack[-1] // } 0E8D 5B JUMPDEST 0E8E 61 PUSH2 0x0e97 0E91 91 SWAP2 0E92 90 SWAP1 0E93 61 PUSH2 0x2431 0E96 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E91 stack[-2] = 0x0e97 // @0E92 stack[-1] = stack[-2] // @0E92 stack[0] = stack[-1] // } // Block ends with call to 0x2431, returns to 0x0E97 label_0E97: // Incoming return from call to 0x2431 at 0x0E96 // Inputs[2] // { // @0E98 stack[-2] // @0E98 stack[-1] // } 0E97 5B JUMPDEST 0E98 11 GT 0E99 15 ISZERO 0E9A 61 PUSH2 0x0eb5 0E9D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0eb5, if !(stack[-1] > stack[-2]) label_0E9E: // Incoming jump from 0x0E9D, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0EA0 memory[0x40:0x60] } 0E9E 60 PUSH1 0x40 0EA0 51 MLOAD 0EA1 62 PUSH3 0x461bcd 0EA5 60 PUSH1 0xe5 0EA7 1B SHL 0EA8 81 DUP2 0EA9 52 MSTORE 0EAA 60 PUSH1 0x04 0EAC 01 ADD 0EAD 61 PUSH2 0x096c 0EB0 90 SWAP1 0EB1 61 PUSH2 0x2449 0EB4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EB0 stack[0] = 0x096c // @0EB0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2449, returns to 0x096C label_0EB5: // Incoming jump from 0x0E9D, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0EB6 stack[-2] // @0EBA storage[0x0f] // } 0EB5 5B JUMPDEST 0EB6 81 DUP2 0EB7 80 DUP1 0EB8 60 PUSH1 0x0f 0EBA 54 SLOAD 0EBB 61 PUSH2 0x0ec4 0EBE 91 SWAP2 0EBF 90 SWAP1 0EC0 61 PUSH2 0x2477 0EC3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EB6 stack[0] = stack[-2] // @0EBE stack[1] = 0x0ec4 // @0EBF stack[2] = stack[-2] // @0EBF stack[3] = storage[0x0f] // } // Block ends with call to 0x2477, returns to 0x0EC4 label_0EC4: // Incoming return from call to 0x2477 at 0x0EC3 // Inputs[2] // { // @0EC5 msg.value // @0EC6 stack[-1] // } 0EC4 5B JUMPDEST 0EC5 34 CALLVALUE 0EC6 10 LT 0EC7 15 ISZERO 0EC8 61 PUSH2 0x0f09 0ECB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f09, if !(msg.value < stack[-1]) label_0ECC: // Incoming jump from 0x0ECB, if not !(msg.value < stack[-1]) // Inputs[1] { @0ECE memory[0x40:0x60] } 0ECC 60 PUSH1 0x40 0ECE 51 MLOAD 0ECF 62 PUSH3 0x461bcd 0ED3 60 PUSH1 0xe5 0ED5 1B SHL 0ED6 81 DUP2 0ED7 52 MSTORE 0ED8 60 PUSH1 0x20 0EDA 60 PUSH1 0x04 0EDC 82 DUP3 0EDD 01 ADD 0EDE 52 MSTORE 0EDF 60 PUSH1 0x13 0EE1 60 PUSH1 0x24 0EE3 82 DUP3 0EE4 01 ADD 0EE5 52 MSTORE 0EE6 72 PUSH19 0x496e73756666696369656e742066756e647321 0EFA 60 PUSH1 0x68 0EFC 1B SHL 0EFD 60 PUSH1 0x44 0EFF 82 DUP3 0F00 01 ADD 0F01 52 MSTORE 0F02 60 PUSH1 0x64 0F04 01 ADD 0F05 61 PUSH2 0x096c 0F08 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0ED7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EDE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EE5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @0F01 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742066756e647321 << 0x68 // @0F04 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_0F09: // Incoming jump from 0x0ECB, if !(msg.value < stack[-1]) // Inputs[1] { @0F0C storage[0x12] } 0F09 5B JUMPDEST 0F0A 60 PUSH1 0x12 0F0C 54 SLOAD 0F0D 60 PUSH1 0xff 0F0F 16 AND 0F10 15 ISZERO 0F11 61 PUSH2 0x0f5c 0F14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f5c, if !(0xff & storage[0x12]) label_0F15: // Incoming jump from 0x0F14, if not !(0xff & storage[0x12]) // Inputs[1] { @0F17 memory[0x40:0x60] } 0F15 60 PUSH1 0x40 0F17 51 MLOAD 0F18 62 PUSH3 0x461bcd 0F1C 60 PUSH1 0xe5 0F1E 1B SHL 0F1F 81 DUP2 0F20 52 MSTORE 0F21 60 PUSH1 0x20 0F23 60 PUSH1 0x04 0F25 82 DUP3 0F26 01 ADD 0F27 52 MSTORE 0F28 60 PUSH1 0x17 0F2A 60 PUSH1 0x24 0F2C 82 DUP3 0F2D 01 ADD 0F2E 52 MSTORE 0F2F 7F PUSH32 0x54686520636f6e74726163742069732070617573656421000000000000000000 0F50 60 PUSH1 0x44 0F52 82 DUP3 0F53 01 ADD 0F54 52 MSTORE 0F55 60 PUSH1 0x64 0F57 01 ADD 0F58 61 PUSH2 0x096c 0F5B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F20 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F27 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F2E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x17 // @0F54 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x54686520636f6e74726163742069732070617573656421000000000000000000 // @0F57 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_0F5C: // Incoming jump from 0x0F14, if !(0xff & storage[0x12]) // Inputs[2] // { // @0F60 msg.sender // @0F61 stack[-3] // } 0F5C 5B JUMPDEST 0F5D 61 PUSH2 0x093d 0F60 33 CALLER 0F61 84 DUP5 0F62 61 PUSH2 0x1a1f 0F65 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F5D stack[0] = 0x093d // @0F60 stack[1] = msg.sender // @0F61 stack[2] = stack[-3] // } // Block ends with call to 0x1a1f, returns to 0x093D 0F66 5B JUMPDEST 0F67 60 PUSH1 0x01 0F69 60 PUSH1 0x01 0F6B 60 PUSH1 0xa0 0F6D 1B SHL 0F6E 03 SUB 0F6F 82 DUP3 0F70 16 AND 0F71 33 CALLER 0F72 14 EQ 0F73 15 ISZERO 0F74 61 PUSH2 0x0f90 0F77 57 *JUMPI 0F78 60 PUSH1 0x40 0F7A 51 MLOAD 0F7B 63 PUSH4 0xb06307db 0F80 60 PUSH1 0xe0 0F82 1B SHL 0F83 81 DUP2 0F84 52 MSTORE 0F85 60 PUSH1 0x04 0F87 01 ADD 0F88 60 PUSH1 0x40 0F8A 51 MLOAD 0F8B 80 DUP1 0F8C 91 SWAP2 0F8D 03 SUB 0F8E 90 SWAP1 0F8F FD *REVERT 0F90 5B JUMPDEST 0F91 33 CALLER 0F92 60 PUSH1 0x00 0F94 81 DUP2 0F95 81 DUP2 0F96 52 MSTORE 0F97 60 PUSH1 0x07 0F99 60 PUSH1 0x20 0F9B 90 SWAP1 0F9C 81 DUP2 0F9D 52 MSTORE 0F9E 60 PUSH1 0x40 0FA0 80 DUP1 0FA1 83 DUP4 0FA2 20 SHA3 0FA3 60 PUSH1 0x01 0FA5 60 PUSH1 0x01 0FA7 60 PUSH1 0xa0 0FA9 1B SHL 0FAA 03 SUB 0FAB 87 DUP8 0FAC 16 AND 0FAD 80 DUP1 0FAE 85 DUP6 0FAF 52 MSTORE 0FB0 90 SWAP1 0FB1 83 DUP4 0FB2 52 MSTORE 0FB3 92 SWAP3 0FB4 81 DUP2 0FB5 90 SWAP1 0FB6 20 SHA3 0FB7 80 DUP1 0FB8 54 SLOAD 0FB9 60 PUSH1 0xff 0FBB 19 NOT 0FBC 16 AND 0FBD 86 DUP7 0FBE 15 ISZERO 0FBF 15 ISZERO 0FC0 90 SWAP1 0FC1 81 DUP2 0FC2 17 OR 0FC3 90 SWAP1 0FC4 91 SWAP2 0FC5 55 SSTORE 0FC6 90 SWAP1 0FC7 51 MLOAD 0FC8 90 SWAP1 0FC9 81 DUP2 0FCA 52 MSTORE 0FCB 91 SWAP2 0FCC 92 SWAP3 0FCD 91 SWAP2 0FCE 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0FEF 91 SWAP2 0FF0 01 ADD 0FF1 60 PUSH1 0x40 0FF3 51 MLOAD 0FF4 80 DUP1 0FF5 91 SWAP2 0FF6 03 SUB 0FF7 90 SWAP1 0FF8 A3 LOG3 0FF9 50 POP 0FFA 50 POP 0FFB 56 *JUMP label_0FFC: // Incoming call from 0x0609, returns to 0x02A0 // Inputs[1] { @1000 storage[0x0e] } 0FFC 5B JUMPDEST 0FFD 60 PUSH1 0x0e 0FFF 80 DUP1 1000 54 SLOAD 1001 61 PUSH2 0x0caa 1004 90 SWAP1 1005 61 PUSH2 0x234c 1008 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FFD stack[0] = 0x0e // @1004 stack[1] = 0x0caa // @1004 stack[2] = storage[0x0e] // } // Block ends with call to 0x234c, returns to 0x0CAA label_1009: // Incoming jump from 0x0629 // Inputs[2] // { // @100C storage[0x08] // @1016 msg.sender // } 1009 5B JUMPDEST 100A 60 PUSH1 0x08 100C 54 SLOAD 100D 60 PUSH1 0x01 100F 60 PUSH1 0x01 1011 60 PUSH1 0xa0 1013 1B SHL 1014 03 SUB 1015 16 AND 1016 33 CALLER 1017 14 EQ 1018 61 PUSH2 0x1033 101B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1033, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_101C: // Incoming jump from 0x101B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @101E memory[0x40:0x60] } 101C 60 PUSH1 0x40 101E 51 MLOAD 101F 62 PUSH3 0x461bcd 1023 60 PUSH1 0xe5 1025 1B SHL 1026 81 DUP2 1027 52 MSTORE 1028 60 PUSH1 0x04 102A 01 ADD 102B 61 PUSH2 0x096c 102E 90 SWAP1 102F 61 PUSH2 0x2387 1032 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1027 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @102E stack[0] = 0x096c // @102E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_1033: // Incoming jump from 0x101B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @1036 stack[-1] // @1037 stack[-2] // } 1033 5B JUMPDEST 1034 60 PUSH1 0x11 1036 55 SSTORE 1037 56 *JUMP // Stack delta = -2 // Outputs[1] { @1036 storage[0x11] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1038: // Incoming jump from 0x0649 // Inputs[2] // { // @103B storage[0x08] // @1045 msg.sender // } 1038 5B JUMPDEST 1039 60 PUSH1 0x08 103B 54 SLOAD 103C 60 PUSH1 0x01 103E 60 PUSH1 0x01 1040 60 PUSH1 0xa0 1042 1B SHL 1043 03 SUB 1044 16 AND 1045 33 CALLER 1046 14 EQ 1047 61 PUSH2 0x1062 104A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1062, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_104B: // Incoming jump from 0x104A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @104D memory[0x40:0x60] } 104B 60 PUSH1 0x40 104D 51 MLOAD 104E 62 PUSH3 0x461bcd 1052 60 PUSH1 0xe5 1054 1B SHL 1055 81 DUP2 1056 52 MSTORE 1057 60 PUSH1 0x04 1059 01 ADD 105A 61 PUSH2 0x096c 105D 90 SWAP1 105E 61 PUSH2 0x2387 1061 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1056 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @105D stack[0] = 0x096c // @105D stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_1062: // Incoming jump from 0x104A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @1066 storage[0x12] // @1067 stack[-1] // @107B stack[-2] // } 1062 5B JUMPDEST 1063 60 PUSH1 0x12 1065 80 DUP1 1066 54 SLOAD 1067 91 SWAP2 1068 15 ISZERO 1069 15 ISZERO 106A 61 PUSH2 0x0100 106D 02 MUL 106E 61 PUSH2 0xff00 1071 19 NOT 1072 90 SWAP1 1073 92 SWAP3 1074 16 AND 1075 91 SWAP2 1076 90 SWAP1 1077 91 SWAP2 1078 17 OR 1079 90 SWAP1 107A 55 SSTORE 107B 56 *JUMP // Stack delta = -2 // Outputs[1] { @107A storage[0x12] = (storage[0x12] & ~0xff00) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_107C: // Incoming jump from 0x0669 // Incoming jump from 0x0AE9 // Inputs[3] // { // @1080 stack[-4] // @1081 stack[-3] // @1082 stack[-2] // } 107C 5B JUMPDEST 107D 61 PUSH2 0x1087 1080 84 DUP5 1081 84 DUP5 1082 84 DUP5 1083 61 PUSH2 0x16b8 1086 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @107D stack[0] = 0x1087 // @1080 stack[1] = stack[-4] // @1081 stack[2] = stack[-3] // @1082 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x16b8 1087 5B JUMPDEST 1088 60 PUSH1 0x01 108A 60 PUSH1 0x01 108C 60 PUSH1 0xa0 108E 1B SHL 108F 03 SUB 1090 83 DUP4 1091 16 AND 1092 3B EXTCODESIZE 1093 15 ISZERO 1094 15 ISZERO 1095 80 DUP1 1096 15 ISZERO 1097 61 PUSH2 0x10a9 109A 57 *JUMPI 109B 50 POP 109C 61 PUSH2 0x10a7 109F 84 DUP5 10A0 84 DUP5 10A1 84 DUP5 10A2 84 DUP5 10A3 61 PUSH2 0x1a39 10A6 56 *JUMP 10A7 5B JUMPDEST 10A8 15 ISZERO 10A9 5B JUMPDEST 10AA 15 ISZERO 10AB 61 PUSH2 0x10c7 10AE 57 *JUMPI 10AF 60 PUSH1 0x40 10B1 51 MLOAD 10B2 63 PUSH4 0x68d2bf6b 10B7 60 PUSH1 0xe1 10B9 1B SHL 10BA 81 DUP2 10BB 52 MSTORE 10BC 60 PUSH1 0x04 10BE 01 ADD 10BF 60 PUSH1 0x40 10C1 51 MLOAD 10C2 80 DUP1 10C3 91 SWAP2 10C4 03 SUB 10C5 90 SWAP1 10C6 FD *REVERT label_10C7: // Incoming jump from 0x1F93, if !(stack[-1] > stack[-4]) // Inputs[1] { @10CC stack[-5] } 10C7 5B JUMPDEST 10C8 50 POP 10C9 50 POP 10CA 50 POP 10CB 50 POP 10CC 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_10CD: // Incoming jump from 0x0689 // Inputs[1] { @10D3 stack[-1] } 10CD 5B JUMPDEST 10CE 60 PUSH1 0x60 10D0 61 PUSH2 0x10d8 10D3 82 DUP3 10D4 61 PUSH2 0x1623 10D7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10CE stack[0] = 0x60 // @10D0 stack[1] = 0x10d8 // @10D3 stack[2] = stack[-1] // } // Block ends with call to 0x1623, returns to 0x10D8 label_10D8: // Incoming return from call to 0x1623 at 0x10D7 // Inputs[1] { @10DC stack[-1] } 10D8 5B JUMPDEST 10D9 61 PUSH2 0x113c 10DC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x113c, if stack[-1] label_10DD: // Incoming jump from 0x10DC, if not stack[-1] // Inputs[1] { @10DF memory[0x40:0x60] } 10DD 60 PUSH1 0x40 10DF 51 MLOAD 10E0 62 PUSH3 0x461bcd 10E4 60 PUSH1 0xe5 10E6 1B SHL 10E7 81 DUP2 10E8 52 MSTORE 10E9 60 PUSH1 0x20 10EB 60 PUSH1 0x04 10ED 82 DUP3 10EE 01 ADD 10EF 52 MSTORE 10F0 60 PUSH1 0x2f 10F2 60 PUSH1 0x24 10F4 82 DUP3 10F5 01 ADD 10F6 52 MSTORE 10F7 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 1118 60 PUSH1 0x44 111A 82 DUP3 111B 01 ADD 111C 52 MSTORE 111D 6E PUSH15 0x3732bc34b9ba32b73a103a37b5b2b7 112D 60 PUSH1 0x89 112F 1B SHL 1130 60 PUSH1 0x64 1132 82 DUP3 1133 01 ADD 1134 52 MSTORE 1135 60 PUSH1 0x84 1137 01 ADD 1138 61 PUSH2 0x096c 113B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @10E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10EF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10F6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @111C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @1134 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x3732bc34b9ba32b73a103a37b5b2b7 << 0x89 // @1137 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_113C: // Incoming jump from 0x10DC, if stack[-1] // Inputs[1] { @113F storage[0x12] } 113C 5B JUMPDEST 113D 60 PUSH1 0x12 113F 54 SLOAD 1140 62 PUSH3 0x010000 1144 90 SWAP1 1145 04 DIV 1146 60 PUSH1 0xff 1148 16 AND 1149 61 PUSH2 0x11de 114C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11de, if 0xff & storage[0x12] / 0x010000 label_114D: // Incoming jump from 0x114C, if not 0xff & storage[0x12] / 0x010000 // Inputs[1] { @1150 storage[0x0e] } 114D 60 PUSH1 0x0e 114F 80 DUP1 1150 54 SLOAD 1151 61 PUSH2 0x1159 1154 90 SWAP1 1155 61 PUSH2 0x234c 1158 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @114D stack[0] = 0x0e // @1154 stack[1] = 0x1159 // @1154 stack[2] = storage[0x0e] // } // Block ends with call to 0x234c, returns to 0x1159 label_1159: // Incoming return from call to 0x234C at 0x1158 // Inputs[4] // { // @115A stack[-1] // @1169 memory[0x40:0x60] // @1171 stack[-2] // @117C storage[stack[-2]] // } 1159 5B JUMPDEST 115A 80 DUP1 115B 60 PUSH1 0x1f 115D 01 ADD 115E 60 PUSH1 0x20 1160 80 DUP1 1161 91 SWAP2 1162 04 DIV 1163 02 MUL 1164 60 PUSH1 0x20 1166 01 ADD 1167 60 PUSH1 0x40 1169 51 MLOAD 116A 90 SWAP1 116B 81 DUP2 116C 01 ADD 116D 60 PUSH1 0x40 116F 52 MSTORE 1170 80 DUP1 1171 92 SWAP3 1172 91 SWAP2 1173 90 SWAP1 1174 81 DUP2 1175 81 DUP2 1176 52 MSTORE 1177 60 PUSH1 0x20 1179 01 ADD 117A 82 DUP3 117B 80 DUP1 117C 54 SLOAD 117D 61 PUSH2 0x1185 1180 90 SWAP1 1181 61 PUSH2 0x234c 1184 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @116F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1171 stack[-2] = memory[0x40:0x60] // @1172 stack[-1] = stack[-2] // @1173 stack[0] = stack[-1] // @1176 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1179 stack[1] = 0x20 + memory[0x40:0x60] // @117A stack[2] = stack[-2] // @1180 stack[4] = storage[stack[-2]] // @1180 stack[3] = 0x1185 // } // Block ends with call to 0x234c, returns to 0x1185 label_1185: // Incoming return from call to 0x234C at 0x1184 // Inputs[1] { @1186 stack[-1] } 1185 5B JUMPDEST 1186 80 DUP1 1187 15 ISZERO 1188 61 PUSH2 0x11d2 118B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11d2, if !stack[-1] label_118C: // Incoming jump from 0x118B, if not !stack[-1] // Inputs[1] { @118C stack[-1] } 118C 80 DUP1 118D 60 PUSH1 0x1f 118F 10 LT 1190 61 PUSH2 0x11a7 1193 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11a7, if 0x1f < stack[-1] label_1194: // Incoming jump from 0x1193, if not 0x1f < stack[-1] // Inputs[4] // { // @1198 stack[-2] // @1199 storage[stack[-2]] // @119C stack[-3] // @119E stack[-1] // } 1194 61 PUSH2 0x0100 1197 80 DUP1 1198 83 DUP4 1199 54 SLOAD 119A 04 DIV 119B 02 MUL 119C 83 DUP4 119D 52 MSTORE 119E 91 SWAP2 119F 60 PUSH1 0x20 11A1 01 ADD 11A2 91 SWAP2 11A3 61 PUSH2 0x11d2 11A6 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @119D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @11A2 stack[-1] = stack[-1] // @11A2 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x11d2 label_11A7: // Incoming jump from 0x1193, if 0x1f < stack[-1] // Inputs[5] // { // @11A8 stack[-3] // @11A9 stack[-1] // @11AB stack[-2] // @11B3 memory[0x00:0x20] // @11B7 storage[keccak256(memory[0x00:0x20])] // } 11A7 5B JUMPDEST 11A8 82 DUP3 11A9 01 ADD 11AA 91 SWAP2 11AB 90 SWAP1 11AC 60 PUSH1 0x00 11AE 52 MSTORE 11AF 60 PUSH1 0x20 11B1 60 PUSH1 0x00 11B3 20 SHA3 11B4 90 SWAP1 11B5 5B JUMPDEST 11B6 81 DUP2 11B7 54 SLOAD 11B8 81 DUP2 11B9 52 MSTORE 11BA 90 SWAP1 11BB 60 PUSH1 0x01 11BD 01 ADD 11BE 90 SWAP1 11BF 60 PUSH1 0x20 11C1 01 ADD 11C2 80 DUP1 11C3 83 DUP4 11C4 11 GT 11C5 61 PUSH2 0x11b5 11C8 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @11AA stack[-3] = stack[-3] + stack[-1] // @11AE memory[0x00:0x20] = stack[-2] // @11B9 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @11BE stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @11C1 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x11b5, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_11C9: // Incoming jump from 0x11C8, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x11C8, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @11C9 stack[-3] // @11CA stack[-1] // } 11C9 82 DUP3 11CA 90 SWAP1 11CB 03 SUB 11CC 60 PUSH1 0x1f 11CE 16 AND 11CF 82 DUP3 11D0 01 ADD 11D1 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @11D1 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @11D1 stack[-1] = stack[-3] // } // Block continues label_11D2: // Incoming jump from 0x11A6 // Incoming jump from 0x11D1 // Incoming jump from 0x118B, if !stack[-1] // Inputs[4] // { // @11D8 stack[-7] // @11D8 stack[-6] // @11DA stack[-9] // @11DB stack[-8] // } 11D2 5B JUMPDEST 11D3 50 POP 11D4 50 POP 11D5 50 POP 11D6 50 POP 11D7 50 POP 11D8 90 SWAP1 11D9 50 POP 11DA 91 SWAP2 11DB 90 SWAP1 11DC 50 POP 11DD 56 *JUMP // Stack delta = -8 // Outputs[1] { @11DA stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_11DE: // Incoming jump from 0x114C, if 0xff & storage[0x12] / 0x010000 11DE 5B JUMPDEST 11DF 60 PUSH1 0x00 11E1 61 PUSH2 0x11e8 11E4 61 PUSH2 0x1b31 11E7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11DF stack[0] = 0x00 // @11E1 stack[1] = 0x11e8 // } // Block ends with unconditional jump to 0x1b31 11E8 5B JUMPDEST 11E9 90 SWAP1 11EA 50 POP 11EB 60 PUSH1 0x00 11ED 81 DUP2 11EE 51 MLOAD 11EF 11 GT 11F0 61 PUSH2 0x1208 11F3 57 *JUMPI 11F4 60 PUSH1 0x40 11F6 51 MLOAD 11F7 80 DUP1 11F8 60 PUSH1 0x20 11FA 01 ADD 11FB 60 PUSH1 0x40 11FD 52 MSTORE 11FE 80 DUP1 11FF 60 PUSH1 0x00 1201 81 DUP2 1202 52 MSTORE 1203 50 POP 1204 61 PUSH2 0x1236 1207 56 *JUMP 1208 5B JUMPDEST 1209 80 DUP1 120A 61 PUSH2 0x1212 120D 84 DUP5 120E 61 PUSH2 0x1b40 1211 56 *JUMP 1212 5B JUMPDEST 1213 60 PUSH1 0x0d 1215 60 PUSH1 0x40 1217 51 MLOAD 1218 60 PUSH1 0x20 121A 01 ADD 121B 61 PUSH2 0x1226 121E 93 SWAP4 121F 92 SWAP3 1220 91 SWAP2 1221 90 SWAP1 1222 61 PUSH2 0x2496 1225 56 *JUMP 1226 5B JUMPDEST 1227 60 PUSH1 0x40 1229 51 MLOAD 122A 60 PUSH1 0x20 122C 81 DUP2 122D 83 DUP4 122E 03 SUB 122F 03 SUB 1230 81 DUP2 1231 52 MSTORE 1232 90 SWAP1 1233 60 PUSH1 0x40 1235 52 MSTORE label_1236: // Incoming return from call to 0x1F3D at 0x1F6F // Incoming return from call to 0x1F3D at 0x25B3 // Incoming return from call to 0x1F9C at 0x1FDA // Incoming return from call to 0x210D at 0x2137 // Incoming return from call to 0x1FF4 at 0x218E // Inputs[3] // { // @1237 stack[-5] // @1237 stack[-1] // @1238 stack[-4] // } 1236 5B JUMPDEST 1237 93 SWAP4 1238 92 SWAP3 1239 50 POP 123A 50 POP 123B 50 POP 123C 56 *JUMP // Stack delta = -4 // Outputs[1] { @1237 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_123D: // Incoming jump from 0x069C // Inputs[1] { @123E stack[-3] } 123D 5B JUMPDEST 123E 82 DUP3 123F 60 PUSH1 0x00 1241 81 DUP2 1242 11 GT 1243 80 DUP1 1244 15 ISZERO 1245 61 PUSH2 0x1250 1248 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @123E stack[0] = stack[-3] // @1242 stack[1] = stack[-3] > 0x00 // } // Block ends with conditional jump to 0x1250, if !(stack[-3] > 0x00) label_1249: // Incoming jump from 0x1248, if not !(stack[-3] > 0x00) // Inputs[2] // { // @124C storage[0x11] // @124D stack[-2] // } 1249 50 POP 124A 60 PUSH1 0x11 124C 54 SLOAD 124D 81 DUP2 124E 11 GT 124F 15 ISZERO 1250 5B JUMPDEST 1251 61 PUSH2 0x126c 1254 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x126c, if !(stack[-2] > storage[0x11]) label_1255: // Incoming jump from 0x1254, if not stack[-1] // Incoming jump from 0x1254, if not !(stack[-2] > storage[0x11]) // Inputs[1] { @1257 memory[0x40:0x60] } 1255 60 PUSH1 0x40 1257 51 MLOAD 1258 62 PUSH3 0x461bcd 125C 60 PUSH1 0xe5 125E 1B SHL 125F 81 DUP2 1260 52 MSTORE 1261 60 PUSH1 0x04 1263 01 ADD 1264 61 PUSH2 0x096c 1267 90 SWAP1 1268 61 PUSH2 0x2403 126B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1260 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1267 stack[0] = 0x096c // @1267 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2403, returns to 0x096C label_126C: // Incoming jump from 0x1254, if stack[-1] // Incoming jump from 0x1254, if !(stack[-2] > storage[0x11]) // Inputs[4] // { // @126F storage[0x10] // @1270 stack[-1] // @1276 storage[0x01] // @1279 storage[0x00] // } 126C 5B JUMPDEST 126D 60 PUSH1 0x10 126F 54 SLOAD 1270 81 DUP2 1271 61 PUSH2 0x1281 1274 60 PUSH1 0x01 1276 54 SLOAD 1277 60 PUSH1 0x00 1279 54 SLOAD 127A 03 SUB 127B 60 PUSH1 0x00 127D 19 NOT 127E 01 ADD 127F 90 SWAP1 1280 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @126F stack[0] = storage[0x10] // @1270 stack[1] = stack[-1] // @127F stack[2] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with unconditional jump to 0x1281 label_1281: // Incoming jump from 0x1280 // Inputs[2] // { // @1285 stack[-2] // @1286 stack[-1] // } 1281 5B JUMPDEST 1282 61 PUSH2 0x128b 1285 91 SWAP2 1286 90 SWAP1 1287 61 PUSH2 0x2431 128A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1285 stack[-2] = 0x128b // @1286 stack[-1] = stack[-2] // @1286 stack[0] = stack[-1] // } // Block ends with call to 0x2431, returns to 0x128B label_128B: // Incoming return from call to 0x2431 at 0x128A // Inputs[2] // { // @128C stack[-1] // @128C stack[-2] // } 128B 5B JUMPDEST 128C 11 GT 128D 15 ISZERO 128E 61 PUSH2 0x12a9 1291 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x12a9, if !(stack[-1] > stack[-2]) label_1292: // Incoming jump from 0x1291, if not !(stack[-1] > stack[-2]) // Inputs[1] { @1294 memory[0x40:0x60] } 1292 60 PUSH1 0x40 1294 51 MLOAD 1295 62 PUSH3 0x461bcd 1299 60 PUSH1 0xe5 129B 1B SHL 129C 81 DUP2 129D 52 MSTORE 129E 60 PUSH1 0x04 12A0 01 ADD 12A1 61 PUSH2 0x096c 12A4 90 SWAP1 12A5 61 PUSH2 0x2449 12A8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @129D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12A4 stack[0] = 0x096c // @12A4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2449, returns to 0x096C label_12A9: // Incoming jump from 0x1291, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @12AA stack[-4] // @12AE storage[0x0f] // } 12A9 5B JUMPDEST 12AA 83 DUP4 12AB 80 DUP1 12AC 60 PUSH1 0x0f 12AE 54 SLOAD 12AF 61 PUSH2 0x12b8 12B2 91 SWAP2 12B3 90 SWAP1 12B4 61 PUSH2 0x2477 12B7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12AA stack[0] = stack[-4] // @12B2 stack[1] = 0x12b8 // @12B3 stack[2] = stack[-4] // @12B3 stack[3] = storage[0x0f] // } // Block ends with call to 0x2477, returns to 0x12B8 label_12B8: // Incoming return from call to 0x2477 at 0x12B7 // Inputs[2] // { // @12B9 msg.value // @12BA stack[-1] // } 12B8 5B JUMPDEST 12B9 34 CALLVALUE 12BA 10 LT 12BB 15 ISZERO 12BC 61 PUSH2 0x12fd 12BF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12fd, if !(msg.value < stack[-1]) label_12C0: // Incoming jump from 0x12BF, if not !(msg.value < stack[-1]) // Inputs[1] { @12C2 memory[0x40:0x60] } 12C0 60 PUSH1 0x40 12C2 51 MLOAD 12C3 62 PUSH3 0x461bcd 12C7 60 PUSH1 0xe5 12C9 1B SHL 12CA 81 DUP2 12CB 52 MSTORE 12CC 60 PUSH1 0x20 12CE 60 PUSH1 0x04 12D0 82 DUP3 12D1 01 ADD 12D2 52 MSTORE 12D3 60 PUSH1 0x13 12D5 60 PUSH1 0x24 12D7 82 DUP3 12D8 01 ADD 12D9 52 MSTORE 12DA 72 PUSH19 0x496e73756666696369656e742066756e647321 12EE 60 PUSH1 0x68 12F0 1B SHL 12F1 60 PUSH1 0x44 12F3 82 DUP3 12F4 01 ADD 12F5 52 MSTORE 12F6 60 PUSH1 0x64 12F8 01 ADD 12F9 61 PUSH2 0x096c 12FC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @12CB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12D2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12D9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @12F5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742066756e647321 << 0x68 // @12F8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_12FD: // Incoming jump from 0x12BF, if !(msg.value < stack[-1]) // Inputs[1] { @1300 storage[0x12] } 12FD 5B JUMPDEST 12FE 60 PUSH1 0x12 1300 54 SLOAD 1301 61 PUSH2 0x0100 1304 90 SWAP1 1305 04 DIV 1306 60 PUSH1 0xff 1308 16 AND 1309 61 PUSH2 0x135f 130C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x135f, if 0xff & storage[0x12] / 0x0100 label_130D: // Incoming jump from 0x130C, if not 0xff & storage[0x12] / 0x0100 // Inputs[1] { @130F memory[0x40:0x60] } 130D 60 PUSH1 0x40 130F 51 MLOAD 1310 62 PUSH3 0x461bcd 1314 60 PUSH1 0xe5 1316 1B SHL 1317 81 DUP2 1318 52 MSTORE 1319 60 PUSH1 0x20 131B 60 PUSH1 0x04 131D 82 DUP3 131E 01 ADD 131F 52 MSTORE 1320 60 PUSH1 0x22 1322 60 PUSH1 0x24 1324 82 DUP3 1325 01 ADD 1326 52 MSTORE 1327 7F PUSH32 0x5468652077686974656c6973742073616c65206973206e6f7420656e61626c65 1348 60 PUSH1 0x44 134A 82 DUP3 134B 01 ADD 134C 52 MSTORE 134D 61 PUSH2 0x6421 1350 60 PUSH1 0xf0 1352 1B SHL 1353 60 PUSH1 0x64 1355 82 DUP3 1356 01 ADD 1357 52 MSTORE 1358 60 PUSH1 0x84 135A 01 ADD 135B 61 PUSH2 0x096c 135E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1318 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @131F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1326 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @134C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468652077686974656c6973742073616c65206973206e6f7420656e61626c65 // @1357 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6421 << 0xf0 // @135A stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_135F: // Incoming jump from 0x130C, if 0xff & storage[0x12] / 0x0100 // Inputs[3] // { // @1360 msg.sender // @136E memory[0x00:0x40] // @136F storage[keccak256(memory[0x00:0x40])] // } 135F 5B JUMPDEST 1360 33 CALLER 1361 60 PUSH1 0x00 1363 90 SWAP1 1364 81 DUP2 1365 52 MSTORE 1366 60 PUSH1 0x0b 1368 60 PUSH1 0x20 136A 52 MSTORE 136B 60 PUSH1 0x40 136D 90 SWAP1 136E 20 SHA3 136F 54 SLOAD 1370 60 PUSH1 0xff 1372 16 AND 1373 15 ISZERO 1374 61 PUSH2 0x13bf 1377 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1365 memory[0x00:0x20] = msg.sender // @136A memory[0x20:0x40] = 0x0b // } // Block ends with conditional jump to 0x13bf, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1378: // Incoming jump from 0x1377, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @137A memory[0x40:0x60] } 1378 60 PUSH1 0x40 137A 51 MLOAD 137B 62 PUSH3 0x461bcd 137F 60 PUSH1 0xe5 1381 1B SHL 1382 81 DUP2 1383 52 MSTORE 1384 60 PUSH1 0x20 1386 60 PUSH1 0x04 1388 82 DUP3 1389 01 ADD 138A 52 MSTORE 138B 60 PUSH1 0x18 138D 60 PUSH1 0x24 138F 82 DUP3 1390 01 ADD 1391 52 MSTORE 1392 7F PUSH32 0x4164647265737320616c726561647920636c61696d6564210000000000000000 13B3 60 PUSH1 0x44 13B5 82 DUP3 13B6 01 ADD 13B7 52 MSTORE 13B8 60 PUSH1 0x64 13BA 01 ADD 13BB 61 PUSH2 0x096c 13BE 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1383 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @138A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1391 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @13B7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4164647265737320616c726561647920636c61696d6564210000000000000000 // @13BA stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_13BF: // Incoming jump from 0x1377, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[10] // { // @13C2 memory[0x40:0x60] // @13D1 msg.sender // @13E3 memory[0x40:0x60] // @13F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @13F6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @13FC stack[-4] // @13FD stack[-3] // @1408 memory[0x40:0x60] // @1422 msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @142F storage[0x0a] // } 13BF 5B JUMPDEST 13C0 60 PUSH1 0x40 13C2 51 MLOAD 13C3 6B PUSH12 0xffffffffffffffffffffffff 13D0 19 NOT 13D1 33 CALLER 13D2 60 PUSH1 0x60 13D4 1B SHL 13D5 16 AND 13D6 60 PUSH1 0x20 13D8 82 DUP3 13D9 01 ADD 13DA 52 MSTORE 13DB 60 PUSH1 0x00 13DD 90 SWAP1 13DE 60 PUSH1 0x34 13E0 01 ADD 13E1 60 PUSH1 0x40 13E3 51 MLOAD 13E4 60 PUSH1 0x20 13E6 81 DUP2 13E7 83 DUP4 13E8 03 SUB 13E9 03 SUB 13EA 81 DUP2 13EB 52 MSTORE 13EC 90 SWAP1 13ED 60 PUSH1 0x40 13EF 52 MSTORE 13F0 80 DUP1 13F1 51 MLOAD 13F2 90 SWAP1 13F3 60 PUSH1 0x20 13F5 01 ADD 13F6 20 SHA3 13F7 90 SWAP1 13F8 50 POP 13F9 61 PUSH2 0x1439 13FC 85 DUP6 13FD 85 DUP6 13FE 80 DUP1 13FF 80 DUP1 1400 60 PUSH1 0x20 1402 02 MUL 1403 60 PUSH1 0x20 1405 01 ADD 1406 60 PUSH1 0x40 1408 51 MLOAD 1409 90 SWAP1 140A 81 DUP2 140B 01 ADD 140C 60 PUSH1 0x40 140E 52 MSTORE 140F 80 DUP1 1410 93 SWAP4 1411 92 SWAP3 1412 91 SWAP2 1413 90 SWAP1 1414 81 DUP2 1415 81 DUP2 1416 52 MSTORE 1417 60 PUSH1 0x20 1419 01 ADD 141A 83 DUP4 141B 83 DUP4 141C 60 PUSH1 0x20 141E 02 MUL 141F 80 DUP1 1420 82 DUP3 1421 84 DUP5 1422 37 CALLDATACOPY 1423 60 PUSH1 0x00 1425 92 SWAP3 1426 01 ADD 1427 91 SWAP2 1428 90 SWAP1 1429 91 SWAP2 142A 52 MSTORE 142B 50 POP 142C 50 POP 142D 60 PUSH1 0x0a 142F 54 SLOAD 1430 91 SWAP2 1431 50 POP 1432 84 DUP5 1433 90 SWAP1 1434 50 POP 1435 61 PUSH2 0x1c3d 1438 56 *JUMP // Stack delta = +5 // Outputs[12] // { // @13DA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @13EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x34 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @13EF memory[0x40:0x60] = 0x34 + memory[0x40:0x60] // @13F7 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @13F9 stack[1] = 0x1439 // @140E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-3] // @1410 stack[2] = memory[0x40:0x60] // @1416 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-3] // @1422 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3]] = msg.data[stack[-4]:stack[-4] + 0x20 * stack[-3]] // @142A memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-3]:0x20 + memory[0x40:0x60] + 0x20 * stack[-3] + 0x20] = 0x00 // @1430 stack[3] = storage[0x0a] // @1433 stack[4] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x1c3d, returns to 0x1439 label_1439: // Incoming return from call to 0x1C3D at 0x1438 // Inputs[1] { @143D stack[-1] } 1439 5B JUMPDEST 143A 61 PUSH2 0x1476 143D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1476, if stack[-1] label_143E: // Incoming jump from 0x143D, if not stack[-1] // Inputs[1] { @1440 memory[0x40:0x60] } 143E 60 PUSH1 0x40 1440 51 MLOAD 1441 62 PUSH3 0x461bcd 1445 60 PUSH1 0xe5 1447 1B SHL 1448 81 DUP2 1449 52 MSTORE 144A 60 PUSH1 0x20 144C 60 PUSH1 0x04 144E 82 DUP3 144F 01 ADD 1450 52 MSTORE 1451 60 PUSH1 0x0e 1453 60 PUSH1 0x24 1455 82 DUP3 1456 01 ADD 1457 52 MSTORE 1458 6D PUSH14 0x496e76616c69642070726f6f6621 1467 60 PUSH1 0x90 1469 1B SHL 146A 60 PUSH1 0x44 146C 82 DUP3 146D 01 ADD 146E 52 MSTORE 146F 60 PUSH1 0x64 1471 01 ADD 1472 61 PUSH2 0x096c 1475 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1449 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1450 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1457 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0e // @146E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e76616c69642070726f6f6621 << 0x90 // @1471 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_1476: // Incoming jump from 0x143D, if stack[-1] // Inputs[4] // { // @1477 msg.sender // @1485 memory[0x00:0x40] // @1487 storage[keccak256(memory[0x00:0x40])] // @1495 stack[-6] // } 1476 5B JUMPDEST 1477 33 CALLER 1478 60 PUSH1 0x00 147A 81 DUP2 147B 81 DUP2 147C 52 MSTORE 147D 60 PUSH1 0x0b 147F 60 PUSH1 0x20 1481 52 MSTORE 1482 60 PUSH1 0x40 1484 90 SWAP1 1485 20 SHA3 1486 80 DUP1 1487 54 SLOAD 1488 60 PUSH1 0xff 148A 19 NOT 148B 16 AND 148C 60 PUSH1 0x01 148E 17 OR 148F 90 SWAP1 1490 55 SSTORE 1491 61 PUSH2 0x149a 1494 90 SWAP1 1495 87 DUP8 1496 61 PUSH2 0x1a1f 1499 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @147C memory[0x00:0x20] = msg.sender // @1481 memory[0x20:0x40] = 0x0b // @1490 storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1494 stack[0] = 0x149a // @1494 stack[1] = msg.sender // @1495 stack[2] = stack[-6] // } // Block ends with call to 0x1a1f, returns to 0x149A label_149A: // Incoming return from call to 0x1A1F at 0x1499 // Inputs[1] { @14A1 stack[-7] } 149A 5B JUMPDEST 149B 50 POP 149C 50 POP 149D 50 POP 149E 50 POP 149F 50 POP 14A0 50 POP 14A1 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_14A2: // Incoming jump from 0x0702 // Inputs[2] // { // @14A5 storage[0x08] // @14AF msg.sender // } 14A2 5B JUMPDEST 14A3 60 PUSH1 0x08 14A5 54 SLOAD 14A6 60 PUSH1 0x01 14A8 60 PUSH1 0x01 14AA 60 PUSH1 0xa0 14AC 1B SHL 14AD 03 SUB 14AE 16 AND 14AF 33 CALLER 14B0 14 EQ 14B1 61 PUSH2 0x14cc 14B4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14cc, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_14B5: // Incoming jump from 0x14B4, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @14B7 memory[0x40:0x60] } 14B5 60 PUSH1 0x40 14B7 51 MLOAD 14B8 62 PUSH3 0x461bcd 14BC 60 PUSH1 0xe5 14BE 1B SHL 14BF 81 DUP2 14C0 52 MSTORE 14C1 60 PUSH1 0x04 14C3 01 ADD 14C4 61 PUSH2 0x096c 14C7 90 SWAP1 14C8 61 PUSH2 0x2387 14CB 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14C7 stack[0] = 0x096c // @14C7 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_14CC: // Incoming jump from 0x14B4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[3] // { // @14D0 storage[0x12] // @14D1 stack[-1] // @14E7 stack[-2] // } 14CC 5B JUMPDEST 14CD 60 PUSH1 0x12 14CF 80 DUP1 14D0 54 SLOAD 14D1 91 SWAP2 14D2 15 ISZERO 14D3 15 ISZERO 14D4 62 PUSH3 0x010000 14D8 02 MUL 14D9 62 PUSH3 0xff0000 14DD 19 NOT 14DE 90 SWAP1 14DF 92 SWAP3 14E0 16 AND 14E1 91 SWAP2 14E2 90 SWAP1 14E3 91 SWAP2 14E4 17 OR 14E5 90 SWAP1 14E6 55 SSTORE 14E7 56 *JUMP // Stack delta = -2 // Outputs[1] { @14E6 storage[0x12] = (storage[0x12] & ~0xff0000) | 0x010000 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_14E8: // Incoming jump from 0x076B // Inputs[1] { @14E9 stack[-2] } 14E8 5B JUMPDEST 14E9 81 DUP2 14EA 60 PUSH1 0x00 14EC 81 DUP2 14ED 11 GT 14EE 80 DUP1 14EF 15 ISZERO 14F0 61 PUSH2 0x14fb 14F3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14E9 stack[0] = stack[-2] // @14ED stack[1] = stack[-2] > 0x00 // } // Block ends with conditional jump to 0x14fb, if !(stack[-2] > 0x00) label_14F4: // Incoming jump from 0x14F3, if not !(stack[-2] > 0x00) // Inputs[2] // { // @14F7 storage[0x11] // @14F8 stack[-2] // } 14F4 50 POP 14F5 60 PUSH1 0x11 14F7 54 SLOAD 14F8 81 DUP2 14F9 11 GT 14FA 15 ISZERO 14FB 5B JUMPDEST 14FC 61 PUSH2 0x1517 14FF 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1517, if !(stack[-2] > storage[0x11]) label_1500: // Incoming jump from 0x14FF, if not stack[-1] // Incoming jump from 0x14FF, if not !(stack[-2] > storage[0x11]) // Inputs[1] { @1502 memory[0x40:0x60] } 1500 60 PUSH1 0x40 1502 51 MLOAD 1503 62 PUSH3 0x461bcd 1507 60 PUSH1 0xe5 1509 1B SHL 150A 81 DUP2 150B 52 MSTORE 150C 60 PUSH1 0x04 150E 01 ADD 150F 61 PUSH2 0x096c 1512 90 SWAP1 1513 61 PUSH2 0x2403 1516 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @150B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1512 stack[0] = 0x096c // @1512 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2403, returns to 0x096C label_1517: // Incoming jump from 0x14FF, if stack[-1] // Incoming jump from 0x14FF, if !(stack[-2] > storage[0x11]) // Inputs[4] // { // @151A storage[0x10] // @151B stack[-1] // @1521 storage[0x01] // @1524 storage[0x00] // } 1517 5B JUMPDEST 1518 60 PUSH1 0x10 151A 54 SLOAD 151B 81 DUP2 151C 61 PUSH2 0x152c 151F 60 PUSH1 0x01 1521 54 SLOAD 1522 60 PUSH1 0x00 1524 54 SLOAD 1525 03 SUB 1526 60 PUSH1 0x00 1528 19 NOT 1529 01 ADD 152A 90 SWAP1 152B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @151A stack[0] = storage[0x10] // @151B stack[1] = stack[-1] // @152A stack[2] = ~0x00 + (storage[0x00] - storage[0x01]) // } // Block ends with unconditional jump to 0x152c label_152C: // Incoming jump from 0x152B // Inputs[2] // { // @1530 stack[-2] // @1531 stack[-1] // } 152C 5B JUMPDEST 152D 61 PUSH2 0x1536 1530 91 SWAP2 1531 90 SWAP1 1532 61 PUSH2 0x2431 1535 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1530 stack[-2] = 0x1536 // @1531 stack[-1] = stack[-2] // @1531 stack[0] = stack[-1] // } // Block ends with call to 0x2431, returns to 0x1536 label_1536: // Incoming return from call to 0x2431 at 0x1535 // Inputs[2] // { // @1537 stack[-2] // @1537 stack[-1] // } 1536 5B JUMPDEST 1537 11 GT 1538 15 ISZERO 1539 61 PUSH2 0x1554 153C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1554, if !(stack[-1] > stack[-2]) label_153D: // Incoming jump from 0x153C, if not !(stack[-1] > stack[-2]) // Inputs[1] { @153F memory[0x40:0x60] } 153D 60 PUSH1 0x40 153F 51 MLOAD 1540 62 PUSH3 0x461bcd 1544 60 PUSH1 0xe5 1546 1B SHL 1547 81 DUP2 1548 52 MSTORE 1549 60 PUSH1 0x04 154B 01 ADD 154C 61 PUSH2 0x096c 154F 90 SWAP1 1550 61 PUSH2 0x2449 1553 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1548 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @154F stack[0] = 0x096c // @154F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2449, returns to 0x096C label_1554: // Incoming jump from 0x153C, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1557 storage[0x08] // @1561 msg.sender // } 1554 5B JUMPDEST 1555 60 PUSH1 0x08 1557 54 SLOAD 1558 60 PUSH1 0x01 155A 60 PUSH1 0x01 155C 60 PUSH1 0xa0 155E 1B SHL 155F 03 SUB 1560 16 AND 1561 33 CALLER 1562 14 EQ 1563 61 PUSH2 0x157e 1566 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x157e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_1567: // Incoming jump from 0x1566, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @1569 memory[0x40:0x60] } 1567 60 PUSH1 0x40 1569 51 MLOAD 156A 62 PUSH3 0x461bcd 156E 60 PUSH1 0xe5 1570 1B SHL 1571 81 DUP2 1572 52 MSTORE 1573 60 PUSH1 0x04 1575 01 ADD 1576 61 PUSH2 0x096c 1579 90 SWAP1 157A 61 PUSH2 0x2387 157D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1572 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1579 stack[0] = 0x096c // @1579 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_157E: // Incoming jump from 0x1566, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[2] // { // @1582 stack[-2] // @1583 stack[-3] // } 157E 5B JUMPDEST 157F 61 PUSH2 0x093d 1582 82 DUP3 1583 84 DUP5 1584 61 PUSH2 0x1a1f 1587 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @157F stack[0] = 0x093d // @1582 stack[1] = stack[-2] // @1583 stack[2] = stack[-3] // } // Block ends with call to 0x1a1f, returns to 0x093D label_1588: // Incoming jump from 0x078B // Inputs[2] // { // @158B storage[0x08] // @1595 msg.sender // } 1588 5B JUMPDEST 1589 60 PUSH1 0x08 158B 54 SLOAD 158C 60 PUSH1 0x01 158E 60 PUSH1 0x01 1590 60 PUSH1 0xa0 1592 1B SHL 1593 03 SUB 1594 16 AND 1595 33 CALLER 1596 14 EQ 1597 61 PUSH2 0x15b2 159A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15b2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] label_159B: // Incoming jump from 0x159A, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @159D memory[0x40:0x60] } 159B 60 PUSH1 0x40 159D 51 MLOAD 159E 62 PUSH3 0x461bcd 15A2 60 PUSH1 0xe5 15A4 1B SHL 15A5 81 DUP2 15A6 52 MSTORE 15A7 60 PUSH1 0x04 15A9 01 ADD 15AA 61 PUSH2 0x096c 15AD 90 SWAP1 15AE 61 PUSH2 0x2387 15B1 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15AD stack[0] = 0x096c // @15AD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2387, returns to 0x096C label_15B2: // Incoming jump from 0x159A, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x08] // Inputs[1] { @15BB stack[-1] } 15B2 5B JUMPDEST 15B3 60 PUSH1 0x01 15B5 60 PUSH1 0x01 15B7 60 PUSH1 0xa0 15B9 1B SHL 15BA 03 SUB 15BB 81 DUP2 15BC 16 AND 15BD 61 PUSH2 0x1617 15C0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1617, if stack[-1] & (0x01 << 0xa0) - 0x01 label_15C1: // Incoming jump from 0x15C0, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @15C3 memory[0x40:0x60] } 15C1 60 PUSH1 0x40 15C3 51 MLOAD 15C4 62 PUSH3 0x461bcd 15C8 60 PUSH1 0xe5 15CA 1B SHL 15CB 81 DUP2 15CC 52 MSTORE 15CD 60 PUSH1 0x20 15CF 60 PUSH1 0x04 15D1 82 DUP3 15D2 01 ADD 15D3 52 MSTORE 15D4 60 PUSH1 0x26 15D6 60 PUSH1 0x24 15D8 82 DUP3 15D9 01 ADD 15DA 52 MSTORE 15DB 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 15FC 60 PUSH1 0x44 15FE 82 DUP3 15FF 01 ADD 1600 52 MSTORE 1601 65 PUSH6 0x646472657373 1608 60 PUSH1 0xd0 160A 1B SHL 160B 60 PUSH1 0x64 160D 82 DUP3 160E 01 ADD 160F 52 MSTORE 1610 60 PUSH1 0x84 1612 01 ADD 1613 61 PUSH2 0x096c 1616 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @15CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15D3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15DA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1600 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @160F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1612 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x096c label_1617: // Incoming jump from 0x15C0, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @161B stack[-1] } 1617 5B JUMPDEST 1618 61 PUSH2 0x1620 161B 81 DUP2 161C 61 PUSH2 0x19cd 161F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1618 stack[0] = 0x1620 // @161B stack[1] = stack[-1] // } // Block ends with call to 0x19cd, returns to 0x1620 label_1620: // Incoming return from call to 0x19CD at 0x161F // Incoming jump from 0x1F4E, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1622 stack[-2] } 1620 5B JUMPDEST 1621 50 POP 1622 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1623: // Incoming call from 0x10D7, returns to 0x10D8 // Incoming call from 0x087A, returns to 0x087B // Inputs[1] { @1626 stack[-1] } 1623 5B JUMPDEST 1624 60 PUSH1 0x00 1626 81 DUP2 1627 60 PUSH1 0x01 1629 11 GT 162A 15 ISZERO 162B 80 DUP1 162C 15 ISZERO 162D 61 PUSH2 0x1637 1630 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1624 stack[0] = 0x00 // @162A stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x1637, if !!(0x01 > stack[-1]) label_1631: // Incoming jump from 0x1630, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @1634 storage[0x00] // @1635 stack[-3] // } 1631 50 POP 1632 60 PUSH1 0x00 1634 54 SLOAD 1635 82 DUP3 1636 10 LT 1637 5B JUMPDEST 1638 80 DUP1 1639 15 ISZERO 163A 61 PUSH2 0x07d8 163D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1636 stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x07d8, if !(stack[-3] < storage[0x00]) label_163E: // Incoming jump from 0x163D, if not !stack[-1] // Incoming jump from 0x163D, if not !(stack[-3] < storage[0x00]) // Inputs[4] // { // @1642 stack[-3] // @164D memory[0x00:0x40] // @164E storage[keccak256(memory[0x00:0x40])] // @165A stack[-4] // } 163E 50 POP 163F 50 POP 1640 60 PUSH1 0x00 1642 90 SWAP1 1643 81 DUP2 1644 52 MSTORE 1645 60 PUSH1 0x04 1647 60 PUSH1 0x20 1649 52 MSTORE 164A 60 PUSH1 0x40 164C 90 SWAP1 164D 20 SHA3 164E 54 SLOAD 164F 60 PUSH1 0x01 1651 60 PUSH1 0xe0 1653 1B SHL 1654 90 SWAP1 1655 04 DIV 1656 60 PUSH1 0xff 1658 16 AND 1659 15 ISZERO 165A 90 SWAP1 165B 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1644 memory[0x00:0x20] = stack[-3] // @1649 memory[0x20:0x40] = 0x04 // @165A stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_165C: // Incoming call from 0x093C, returns to 0x093D // Incoming call from 0x1785, returns to 0x1786 // Inputs[8] // { // @165F stack[-2] // @166B memory[0x00:0x40] // @166D storage[keccak256(memory[0x00:0x40])] // @1680 stack[-3] // @168A memory[0x40:0x60] // @168E stack[-1] // @16B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @16B7 stack[-4] // } 165C 5B JUMPDEST 165D 60 PUSH1 0x00 165F 82 DUP3 1660 81 DUP2 1661 52 MSTORE 1662 60 PUSH1 0x06 1664 60 PUSH1 0x20 1666 52 MSTORE 1667 60 PUSH1 0x40 1669 80 DUP1 166A 82 DUP3 166B 20 SHA3 166C 80 DUP1 166D 54 SLOAD 166E 60 PUSH1 0x01 1670 60 PUSH1 0x01 1672 60 PUSH1 0xa0 1674 1B SHL 1675 03 SUB 1676 19 NOT 1677 16 AND 1678 60 PUSH1 0x01 167A 60 PUSH1 0x01 167C 60 PUSH1 0xa0 167E 1B SHL 167F 03 SUB 1680 87 DUP8 1681 81 DUP2 1682 16 AND 1683 91 SWAP2 1684 82 DUP3 1685 17 OR 1686 90 SWAP1 1687 92 SWAP3 1688 55 SSTORE 1689 91 SWAP2 168A 51 MLOAD 168B 85 DUP6 168C 93 SWAP4 168D 91 SWAP2 168E 85 DUP6 168F 16 AND 1690 91 SWAP2 1691 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 16B2 91 SWAP2 16B3 A4 LOG4 16B4 50 POP 16B5 50 POP 16B6 50 POP 16B7 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1661 memory[0x00:0x20] = stack[-2] // @1666 memory[0x20:0x40] = 0x06 // @1688 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @16B3 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_16B8: // Incoming jump from 0x09D3 // Incoming jump from 0x1086 // Inputs[1] { @16BE stack[-1] } 16B8 5B JUMPDEST 16B9 60 PUSH1 0x00 16BB 61 PUSH2 0x16c3 16BE 82 DUP3 16BF 61 PUSH2 0x18a6 16C2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16B9 stack[0] = 0x00 // @16BB stack[1] = 0x16c3 // @16BE stack[2] = stack[-1] // } // Block ends with call to 0x18a6, returns to 0x16C3 label_16C3: // Incoming return from call to 0x18A6 at 0x16C2 // Inputs[4] // { // @16C4 stack[-1] // @16C4 stack[-2] // @16C6 stack[-5] // @16D4 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 16C3 5B JUMPDEST 16C4 90 SWAP1 16C5 50 POP 16C6 83 DUP4 16C7 60 PUSH1 0x01 16C9 60 PUSH1 0x01 16CB 60 PUSH1 0xa0 16CD 1B SHL 16CE 03 SUB 16CF 16 AND 16D0 81 DUP2 16D1 60 PUSH1 0x00 16D3 01 ADD 16D4 51 MLOAD 16D5 60 PUSH1 0x01 16D7 60 PUSH1 0x01 16D9 60 PUSH1 0xa0 16DB 1B SHL 16DC 03 SUB 16DD 16 AND 16DE 14 EQ 16DF 61 PUSH2 0x16fa 16E2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @16C4 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x16fa, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_16E3: // Incoming jump from 0x16E2, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @16E5 memory[0x40:0x60] // @16F4 memory[0x40:0x60] // @16F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16E3 60 PUSH1 0x40 16E5 51 MLOAD 16E6 62 PUSH3 0xa11481 16EA 60 PUSH1 0xe8 16EC 1B SHL 16ED 81 DUP2 16EE 52 MSTORE 16EF 60 PUSH1 0x04 16F1 01 ADD 16F2 60 PUSH1 0x40 16F4 51 MLOAD 16F5 80 DUP1 16F6 91 SWAP2 16F7 03 SUB 16F8 90 SWAP1 16F9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @16F9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_16FA: // Incoming jump from 0x16E2, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @16FD msg.sender // @1706 stack[-4] // } 16FA 5B JUMPDEST 16FB 60 PUSH1 0x00 16FD 33 CALLER 16FE 60 PUSH1 0x01 1700 60 PUSH1 0x01 1702 60 PUSH1 0xa0 1704 1B SHL 1705 03 SUB 1706 86 DUP7 1707 16 AND 1708 14 EQ 1709 80 DUP1 170A 61 PUSH2 0x1718 170D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @16FB stack[0] = 0x00 // @1708 stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x1718, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_170E: // Incoming jump from 0x170D, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @1712 stack[-6] // @1713 msg.sender // } 170E 50 POP 170F 61 PUSH2 0x1718 1712 85 DUP6 1713 33 CALLER 1714 61 PUSH2 0x071e 1717 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @170F stack[-1] = 0x1718 // @1712 stack[0] = stack[-6] // @1713 stack[1] = msg.sender // } // Block ends with call to 0x071e, returns to 0x1718 label_1718: // Incoming return from call to 0x071E at 0x1717 // Incoming jump from 0x170D, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @1719 stack[-1] } 1718 5B JUMPDEST 1719 80 DUP1 171A 61 PUSH2 0x1733 171D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1733, if stack[-1] label_171E: // Incoming jump from 0x171D, if not stack[-1] // Inputs[2] // { // @171F msg.sender // @1723 stack[-4] // } 171E 50 POP 171F 33 CALLER 1720 61 PUSH2 0x1728 1723 84 DUP5 1724 61 PUSH2 0x0870 1727 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @171F stack[-1] = msg.sender // @1720 stack[0] = 0x1728 // @1723 stack[1] = stack[-4] // } // Block ends with call to 0x0870, returns to 0x1728 label_1728: // Incoming return from call to 0x0870 at 0x1727 // Inputs[2] // { // @1731 stack[-1] // @1732 stack[-2] // } 1728 5B JUMPDEST 1729 60 PUSH1 0x01 172B 60 PUSH1 0x01 172D 60 PUSH1 0xa0 172F 1B SHL 1730 03 SUB 1731 16 AND 1732 14 EQ // Stack delta = -1 // Outputs[1] { @1732 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1733: // Incoming jump from 0x1732 // Incoming jump from 0x171D, if stack[-1] // Inputs[2] // { // @1734 stack[-2] // @1734 stack[-1] // } 1733 5B JUMPDEST 1734 90 SWAP1 1735 50 POP 1736 80 DUP1 1737 61 PUSH2 0x1753 173A 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1734 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1753, if stack[-1] label_173B: // Incoming jump from 0x173A, if not stack[-1] // Inputs[3] // { // @173D memory[0x40:0x60] // @174D memory[0x40:0x60] // @1752 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 173B 60 PUSH1 0x40 173D 51 MLOAD 173E 63 PUSH4 0x2ce44b5f 1743 60 PUSH1 0xe1 1745 1B SHL 1746 81 DUP2 1747 52 MSTORE 1748 60 PUSH1 0x04 174A 01 ADD 174B 60 PUSH1 0x40 174D 51 MLOAD 174E 80 DUP1 174F 91 SWAP2 1750 03 SUB 1751 90 SWAP1 1752 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1747 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @1752 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1753: // Incoming jump from 0x173A, if stack[-1] // Inputs[1] { @175C stack[-4] } 1753 5B JUMPDEST 1754 60 PUSH1 0x01 1756 60 PUSH1 0x01 1758 60 PUSH1 0xa0 175A 1B SHL 175B 03 SUB 175C 84 DUP5 175D 16 AND 175E 61 PUSH2 0x177a 1761 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x177a, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1762: // Incoming jump from 0x1761, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1764 memory[0x40:0x60] // @1774 memory[0x40:0x60] // @1779 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1762 60 PUSH1 0x40 1764 51 MLOAD 1765 63 PUSH4 0x3a954ecd 176A 60 PUSH1 0xe2 176C 1B SHL 176D 81 DUP2 176E 52 MSTORE 176F 60 PUSH1 0x04 1771 01 ADD 1772 60 PUSH1 0x40 1774 51 MLOAD 1775 80 DUP1 1776 91 SWAP2 1777 03 SUB 1778 90 SWAP1 1779 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @176E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @1779 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_177A: // Incoming jump from 0x1761, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1780 stack[-3] // @1781 stack[-5] // } 177A 5B JUMPDEST 177B 61 PUSH2 0x1786 177E 60 PUSH1 0x00 1780 84 DUP5 1781 87 DUP8 1782 61 PUSH2 0x165c 1785 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @177B stack[0] = 0x1786 // @177E stack[1] = 0x00 // @1780 stack[2] = stack[-3] // @1781 stack[3] = stack[-5] // } // Block ends with call to 0x165c, returns to 0x1786 label_1786: // Incoming return from call to 0x165C at 0x1785 // Inputs[12] // { // @178F stack[-5] // @17A2 memory[0x00:0x40] // @17A4 storage[keccak256(memory[0x00:0x40])] // @17C7 stack[-4] // @17CF memory[0x00:0x40] // @17D1 storage[keccak256(memory[0x00:0x40])] // @17E5 stack[-3] // @17EF memory[0x00:0x40] // @17F1 storage[keccak256(memory[0x00:0x40])] // @1804 block.timestamp // @1815 memory[0x00:0x40] // @1817 storage[keccak256(memory[0x00:0x40])] // } 1786 5B JUMPDEST 1787 60 PUSH1 0x01 1789 60 PUSH1 0x01 178B 60 PUSH1 0xa0 178D 1B SHL 178E 03 SUB 178F 85 DUP6 1790 81 DUP2 1791 16 AND 1792 60 PUSH1 0x00 1794 90 SWAP1 1795 81 DUP2 1796 52 MSTORE 1797 60 PUSH1 0x05 1799 60 PUSH1 0x20 179B 90 SWAP1 179C 81 DUP2 179D 52 MSTORE 179E 60 PUSH1 0x40 17A0 80 DUP1 17A1 83 DUP4 17A2 20 SHA3 17A3 80 DUP1 17A4 54 SLOAD 17A5 67 PUSH8 0xffffffffffffffff 17AE 19 NOT 17AF 80 DUP1 17B0 82 DUP3 17B1 16 AND 17B2 60 PUSH1 0x01 17B4 60 PUSH1 0x01 17B6 60 PUSH1 0x40 17B8 1B SHL 17B9 03 SUB 17BA 92 SWAP3 17BB 83 DUP4 17BC 16 AND 17BD 60 PUSH1 0x00 17BF 19 NOT 17C0 01 ADD 17C1 83 DUP4 17C2 16 AND 17C3 17 OR 17C4 90 SWAP1 17C5 92 SWAP3 17C6 55 SSTORE 17C7 89 DUP10 17C8 86 DUP7 17C9 16 AND 17CA 80 DUP1 17CB 86 DUP7 17CC 52 MSTORE 17CD 83 DUP4 17CE 86 DUP7 17CF 20 SHA3 17D0 80 DUP1 17D1 54 SLOAD 17D2 93 SWAP4 17D3 84 DUP5 17D4 16 AND 17D5 93 SWAP4 17D6 83 DUP4 17D7 16 AND 17D8 60 PUSH1 0x01 17DA 90 SWAP1 17DB 81 DUP2 17DC 01 ADD 17DD 84 DUP5 17DE 16 AND 17DF 94 SWAP5 17E0 90 SWAP1 17E1 94 SWAP5 17E2 17 OR 17E3 90 SWAP1 17E4 55 SSTORE 17E5 89 DUP10 17E6 86 DUP7 17E7 52 MSTORE 17E8 60 PUSH1 0x04 17EA 90 SWAP1 17EB 94 SWAP5 17EC 52 MSTORE 17ED 82 DUP3 17EE 85 DUP6 17EF 20 SHA3 17F0 80 DUP1 17F1 54 SLOAD 17F2 60 PUSH1 0x01 17F4 60 PUSH1 0x01 17F6 60 PUSH1 0xe0 17F8 1B SHL 17F9 03 SUB 17FA 19 NOT 17FB 16 AND 17FC 90 SWAP1 17FD 94 SWAP5 17FE 17 OR 17FF 60 PUSH1 0x01 1801 60 PUSH1 0xa0 1803 1B SHL 1804 42 TIMESTAMP 1805 90 SWAP1 1806 92 SWAP3 1807 16 AND 1808 91 SWAP2 1809 90 SWAP1 180A 91 SWAP2 180B 02 MUL 180C 17 OR 180D 83 DUP4 180E 55 SSTORE 180F 87 DUP8 1810 01 ADD 1811 80 DUP1 1812 84 DUP5 1813 52 MSTORE 1814 92 SWAP3 1815 20 SHA3 1816 80 DUP1 1817 54 SLOAD 1818 91 SWAP2 1819 93 SWAP4 181A 90 SWAP1 181B 91 SWAP2 181C 16 AND 181D 61 PUSH2 0x185a 1820 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @1796 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @179D memory[0x20:0x40] = 0x05 // @17C6 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & ~0x00 + ((0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @17CC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @17E4 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & 0x01 + ((0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @17E7 memory[0x00:0x20] = stack[-3] // @17EC memory[0x20:0x40] = 0x04 // @180E storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1813 memory[0x00:0x20] = stack[-3] + 0x01 // @1814 stack[1] = stack[-3] + 0x01 // @1819 stack[0] = keccak256(memory[0x00:0x40]) // @181B stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x185a, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_1821: // Incoming jump from 0x1820, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1823 storage[0x00] // @1824 stack[-2] // } 1821 60 PUSH1 0x00 1823 54 SLOAD 1824 82 DUP3 1825 14 EQ 1826 61 PUSH2 0x185a 1829 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x185a, if stack[-2] == storage[0x00] label_182A: // Incoming jump from 0x1829, if not stack[-2] == storage[0x00] // Inputs[5] // { // @182A stack[-1] // @182B storage[stack[-1]] // @182E stack[-5] // @1830 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1854 stack[-8] // } 182A 80 DUP1 182B 54 SLOAD 182C 60 PUSH1 0x20 182E 86 DUP7 182F 01 ADD 1830 51 MLOAD 1831 60 PUSH1 0x01 1833 60 PUSH1 0x01 1835 60 PUSH1 0x40 1837 1B SHL 1838 03 SUB 1839 16 AND 183A 60 PUSH1 0x01 183C 60 PUSH1 0xa0 183E 1B SHL 183F 02 MUL 1840 60 PUSH1 0x01 1842 60 PUSH1 0x01 1844 60 PUSH1 0xe0 1846 1B SHL 1847 03 SUB 1848 19 NOT 1849 90 SWAP1 184A 91 SWAP2 184B 16 AND 184C 60 PUSH1 0x01 184E 60 PUSH1 0x01 1850 60 PUSH1 0xa0 1852 1B SHL 1853 03 SUB 1854 8A DUP11 1855 16 AND 1856 17 OR 1857 17 OR 1858 81 DUP2 1859 55 SSTORE // Stack delta = +0 // Outputs[1] { @1859 storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * ((0x01 << 0x40) - 0x01 & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_185A: // Incoming jump from 0x1820, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x1859 // Incoming jump from 0x1829, if stack[-2] == storage[0x00] // Inputs[6] // { // @185E stack[-6] // @185F stack[-7] // @1869 stack[-8] // @1896 memory[0x40:0x60] // @1899 memory[0x40:0x60] // @189E memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 185A 5B JUMPDEST 185B 50 POP 185C 50 POP 185D 50 POP 185E 82 DUP3 185F 84 DUP5 1860 60 PUSH1 0x01 1862 60 PUSH1 0x01 1864 60 PUSH1 0xa0 1866 1B SHL 1867 03 SUB 1868 16 AND 1869 86 DUP7 186A 60 PUSH1 0x01 186C 60 PUSH1 0x01 186E 60 PUSH1 0xa0 1870 1B SHL 1871 03 SUB 1872 16 AND 1873 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1894 60 PUSH1 0x40 1896 51 MLOAD 1897 60 PUSH1 0x40 1899 51 MLOAD 189A 80 DUP1 189B 91 SWAP2 189C 03 SUB 189D 90 SWAP1 189E A4 LOG4 // Stack delta = -3 // Outputs[1] { @189E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block continues label_189F: // Incoming jump from 0x1EA3 // Incoming jump from 0x189E // Inputs[1] { @18A5 stack[-6] } 189F 5B JUMPDEST 18A0 50 POP 18A1 50 POP 18A2 50 POP 18A3 50 POP 18A4 50 POP 18A5 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_18A6: // Incoming call from 0x16C2, returns to 0x16C3 // Incoming call from 0x0D42, returns to 0x0D43 // Inputs[2] // { // @18AA memory[0x40:0x60] // @18C4 stack[-1] // } 18A6 5B JUMPDEST 18A7 60 PUSH1 0x40 18A9 80 DUP1 18AA 51 MLOAD 18AB 60 PUSH1 0x60 18AD 81 DUP2 18AE 01 ADD 18AF 82 DUP3 18B0 52 MSTORE 18B1 60 PUSH1 0x00 18B3 80 DUP1 18B4 82 DUP3 18B5 52 MSTORE 18B6 60 PUSH1 0x20 18B8 82 DUP3 18B9 01 ADD 18BA 81 DUP2 18BB 90 SWAP1 18BC 52 MSTORE 18BD 91 SWAP2 18BE 81 DUP2 18BF 01 ADD 18C0 91 SWAP2 18C1 90 SWAP1 18C2 91 SWAP2 18C3 52 MSTORE 18C4 81 DUP2 18C5 80 DUP1 18C6 60 PUSH1 0x01 18C8 11 GT 18C9 15 ISZERO 18CA 80 DUP1 18CB 15 ISZERO 18CC 61 PUSH2 0x18d6 18CF 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @18B0 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @18B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @18BC memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @18C2 stack[0] = memory[0x40:0x60] // @18C3 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @18C4 stack[1] = stack[-1] // @18C9 stack[2] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x18d6, if !!(0x01 > stack[-1]) label_18D0: // Incoming jump from 0x18CF, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @18D3 storage[0x00] // @18D4 stack[-2] // } 18D0 50 POP 18D1 60 PUSH1 0x00 18D3 54 SLOAD 18D4 81 DUP2 18D5 10 LT 18D6 5B JUMPDEST 18D7 15 ISZERO 18D8 61 PUSH2 0x19b4 18DB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x19b4, if !(stack[-2] < storage[0x00]) label_18DC: // Incoming jump from 0x18DB, if not !(stack[-2] < storage[0x00]) // Incoming jump from 0x18DB, if not !stack[-1] // Inputs[4] // { // @18DE stack[-1] // @18ED memory[0x00:0x40] // @18EF memory[0x40:0x60] // @18F7 storage[keccak256(memory[0x00:0x40])] // } 18DC 60 PUSH1 0x00 18DE 81 DUP2 18DF 81 DUP2 18E0 52 MSTORE 18E1 60 PUSH1 0x04 18E3 60 PUSH1 0x20 18E5 90 SWAP1 18E6 81 DUP2 18E7 52 MSTORE 18E8 60 PUSH1 0x40 18EA 91 SWAP2 18EB 82 DUP3 18EC 90 SWAP1 18ED 20 SHA3 18EE 82 DUP3 18EF 51 MLOAD 18F0 60 PUSH1 0x60 18F2 81 DUP2 18F3 01 ADD 18F4 84 DUP5 18F5 52 MSTORE 18F6 90 SWAP1 18F7 54 SLOAD 18F8 60 PUSH1 0x01 18FA 60 PUSH1 0x01 18FC 60 PUSH1 0xa0 18FE 1B SHL 18FF 03 SUB 1900 81 DUP2 1901 16 AND 1902 82 DUP3 1903 52 MSTORE 1904 60 PUSH1 0x01 1906 60 PUSH1 0xa0 1908 1B SHL 1909 81 DUP2 190A 04 DIV 190B 60 PUSH1 0x01 190D 60 PUSH1 0x01 190F 60 PUSH1 0x40 1911 1B SHL 1912 03 SUB 1913 16 AND 1914 92 SWAP3 1915 82 DUP3 1916 01 ADD 1917 92 SWAP3 1918 90 SWAP1 1919 92 SWAP3 191A 52 MSTORE 191B 60 PUSH1 0x01 191D 60 PUSH1 0xe0 191F 1B SHL 1920 90 SWAP1 1921 91 SWAP2 1922 04 DIV 1923 60 PUSH1 0xff 1925 16 AND 1926 15 ISZERO 1927 15 ISZERO 1928 91 SWAP2 1929 81 DUP2 192A 01 ADD 192B 82 DUP3 192C 90 SWAP1 192D 52 MSTORE 192E 90 SWAP1 192F 61 PUSH2 0x19b2 1932 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @18E0 memory[0x00:0x20] = stack[-1] // @18E7 memory[0x20:0x40] = 0x04 // @18F5 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1903 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @191A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @192D memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @192E stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x19b2, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_1933: // Incoming jump from 0x1932, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @1933 stack[-1] // @1934 memory[stack[-1]:stack[-1] + 0x20] // } 1933 80 DUP1 1934 51 MLOAD 1935 60 PUSH1 0x01 1937 60 PUSH1 0x01 1939 60 PUSH1 0xa0 193B 1B SHL 193C 03 SUB 193D 16 AND 193E 15 ISZERO 193F 61 PUSH2 0x1949 1942 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1949, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_1943: // Incoming jump from 0x1942, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1943 stack[-5] // @1943 stack[-1] // @1944 stack[-4] // } 1943 93 SWAP4 1944 92 SWAP3 1945 50 POP 1946 50 POP 1947 50 POP 1948 56 *JUMP // Stack delta = -4 // Outputs[1] { @1943 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1949: // Incoming jump from 0x19B1 // Incoming jump from 0x1942, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @194E stack[-2] // @1960 memory[0x00:0x40] // @1962 memory[0x40:0x60] // @196A storage[keccak256(memory[0x00:0x40])] // } 1949 5B JUMPDEST 194A 50 POP 194B 60 PUSH1 0x00 194D 19 NOT 194E 01 ADD 194F 60 PUSH1 0x00 1951 81 DUP2 1952 81 DUP2 1953 52 MSTORE 1954 60 PUSH1 0x04 1956 60 PUSH1 0x20 1958 90 SWAP1 1959 81 DUP2 195A 52 MSTORE 195B 60 PUSH1 0x40 195D 91 SWAP2 195E 82 DUP3 195F 90 SWAP1 1960 20 SHA3 1961 82 DUP3 1962 51 MLOAD 1963 60 PUSH1 0x60 1965 81 DUP2 1966 01 ADD 1967 84 DUP5 1968 52 MSTORE 1969 90 SWAP1 196A 54 SLOAD 196B 60 PUSH1 0x01 196D 60 PUSH1 0x01 196F 60 PUSH1 0xa0 1971 1B SHL 1972 03 SUB 1973 81 DUP2 1974 16 AND 1975 80 DUP1 1976 83 DUP4 1977 52 MSTORE 1978 60 PUSH1 0x01 197A 60 PUSH1 0xa0 197C 1B SHL 197D 82 DUP3 197E 04 DIV 197F 60 PUSH1 0x01 1981 60 PUSH1 0x01 1983 60 PUSH1 0x40 1985 1B SHL 1986 03 SUB 1987 16 AND 1988 93 SWAP4 1989 83 DUP4 198A 01 ADD 198B 93 SWAP4 198C 90 SWAP1 198D 93 SWAP4 198E 52 MSTORE 198F 60 PUSH1 0x01 1991 60 PUSH1 0xe0 1993 1B SHL 1994 90 SWAP1 1995 04 DIV 1996 60 PUSH1 0xff 1998 16 AND 1999 15 ISZERO 199A 15 ISZERO 199B 92 SWAP3 199C 81 DUP2 199D 01 ADD 199E 92 SWAP3 199F 90 SWAP1 19A0 92 SWAP3 19A1 52 MSTORE 19A2 15 ISZERO 19A3 61 PUSH2 0x19ad 19A6 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @194E stack[-2] = ~0x00 + stack[-2] // @1953 memory[0x00:0x20] = ~0x00 + stack[-2] // @195A memory[0x20:0x40] = 0x04 // @1968 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1977 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @198E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @19A0 stack[-1] = memory[0x40:0x60] // @19A1 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x19ad, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_19A7: // Incoming jump from 0x19A6, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @19A7 stack[-1] // @19A7 stack[-5] // @19A8 stack[-4] // } 19A7 93 SWAP4 19A8 92 SWAP3 19A9 50 POP 19AA 50 POP 19AB 50 POP 19AC 56 *JUMP // Stack delta = -4 // Outputs[1] { @19A7 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_19AD: // Incoming jump from 0x19A6, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 19AD 5B JUMPDEST 19AE 61 PUSH2 0x1949 19B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1949 label_19B2: // Incoming jump from 0x1932, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 19B2 5B JUMPDEST 19B3 50 POP // Stack delta = -1 // Block continues label_19B4: // Incoming jump from 0x19B3 // Incoming jump from 0x18DB, if !(stack[-2] < storage[0x00]) // Incoming jump from 0x18DB, if !stack[-1] // Inputs[3] // { // @19B7 memory[0x40:0x60] // @19C7 memory[0x40:0x60] // @19CC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19B4 5B JUMPDEST 19B5 60 PUSH1 0x40 19B7 51 MLOAD 19B8 63 PUSH4 0x6f96cda1 19BD 60 PUSH1 0xe1 19BF 1B SHL 19C0 81 DUP2 19C1 52 MSTORE 19C2 60 PUSH1 0x04 19C4 01 ADD 19C5 60 PUSH1 0x40 19C7 51 MLOAD 19C8 80 DUP1 19C9 91 SWAP2 19CA 03 SUB 19CB 90 SWAP1 19CC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @19CC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_19CD: // Incoming call from 0x0DCB, returns to 0x0DCC // Incoming call from 0x161F, returns to 0x1620 // Inputs[5] // { // @19D1 storage[0x08] // @19DA stack[-1] // @19EF memory[0x40:0x60] // @1A1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1A1E stack[-2] // } 19CD 5B JUMPDEST 19CE 60 PUSH1 0x08 19D0 80 DUP1 19D1 54 SLOAD 19D2 60 PUSH1 0x01 19D4 60 PUSH1 0x01 19D6 60 PUSH1 0xa0 19D8 1B SHL 19D9 03 SUB 19DA 83 DUP4 19DB 81 DUP2 19DC 16 AND 19DD 60 PUSH1 0x01 19DF 60 PUSH1 0x01 19E1 60 PUSH1 0xa0 19E3 1B SHL 19E4 03 SUB 19E5 19 NOT 19E6 83 DUP4 19E7 16 AND 19E8 81 DUP2 19E9 17 OR 19EA 90 SWAP1 19EB 93 SWAP4 19EC 55 SSTORE 19ED 60 PUSH1 0x40 19EF 51 MLOAD 19F0 91 SWAP2 19F1 16 AND 19F2 91 SWAP2 19F3 90 SWAP1 19F4 82 DUP3 19F5 90 SWAP1 19F6 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1A17 90 SWAP1 1A18 60 PUSH1 0x00 1A1A 90 SWAP1 1A1B A3 LOG3 1A1C 50 POP 1A1D 50 POP 1A1E 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @19EC storage[0x08] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x08] & ~((0x01 << 0xa0) - 0x01)) // @1A1B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1A1F: // Incoming call from 0x1587, returns to 0x093D // Incoming call from 0x0F65, returns to 0x093D // Incoming call from 0x1499, returns to 0x149A // Inputs[3] // { // @1A23 stack[-2] // @1A24 stack[-1] // @1A27 memory[0x40:0x60] // } 1A1F 5B JUMPDEST 1A20 61 PUSH2 0x0988 1A23 82 DUP3 1A24 82 DUP3 1A25 60 PUSH1 0x40 1A27 51 MLOAD 1A28 80 DUP1 1A29 60 PUSH1 0x20 1A2B 01 ADD 1A2C 60 PUSH1 0x40 1A2E 52 MSTORE 1A2F 80 DUP1 1A30 60 PUSH1 0x00 1A32 81 DUP2 1A33 52 MSTORE 1A34 50 POP 1A35 61 PUSH2 0x1c53 1A38 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1A20 stack[0] = 0x0988 // @1A23 stack[1] = stack[-2] // @1A24 stack[2] = stack[-1] // @1A27 stack[3] = memory[0x40:0x60] // @1A2E memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1A33 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1c53, returns to 0x0988 label_1A39: // Incoming jump from 0x1E1C // Inputs[6] // { // @1A3C memory[0x40:0x60] // @1A52 stack[-3] // @1A5F msg.sender // @1A61 stack[-4] // @1A63 stack[-2] // @1A65 stack[-1] // } 1A39 5B JUMPDEST 1A3A 60 PUSH1 0x40 1A3C 51 MLOAD 1A3D 63 PUSH4 0x0a85bd01 1A42 60 PUSH1 0xe1 1A44 1B SHL 1A45 81 DUP2 1A46 52 MSTORE 1A47 60 PUSH1 0x00 1A49 90 SWAP1 1A4A 60 PUSH1 0x01 1A4C 60 PUSH1 0x01 1A4E 60 PUSH1 0xa0 1A50 1B SHL 1A51 03 SUB 1A52 85 DUP6 1A53 16 AND 1A54 90 SWAP1 1A55 63 PUSH4 0x150b7a02 1A5A 90 SWAP1 1A5B 61 PUSH2 0x1a6e 1A5E 90 SWAP1 1A5F 33 CALLER 1A60 90 SWAP1 1A61 89 DUP10 1A62 90 SWAP1 1A63 88 DUP9 1A64 90 SWAP1 1A65 88 DUP9 1A66 90 SWAP1 1A67 60 PUSH1 0x04 1A69 01 ADD 1A6A 61 PUSH2 0x255a 1A6D 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1A46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1A49 stack[0] = 0x00 // @1A54 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1A5A stack[2] = 0x150b7a02 // @1A5E stack[3] = 0x1a6e // @1A60 stack[4] = msg.sender // @1A62 stack[5] = stack[-4] // @1A64 stack[6] = stack[-2] // @1A66 stack[7] = stack[-1] // @1A69 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x255a, returns to 0x1A6E label_1A6E: // Incoming return from call to 0x255A at 0x1A6D // Inputs[4] // { // @1A73 memory[0x40:0x60] // @1A75 stack[-1] // @1A7A stack[-3] // @1A7C address(stack[-3]).code.length // } 1A6E 5B JUMPDEST 1A6F 60 PUSH1 0x20 1A71 60 PUSH1 0x40 1A73 51 MLOAD 1A74 80 DUP1 1A75 83 DUP4 1A76 03 SUB 1A77 81 DUP2 1A78 60 PUSH1 0x00 1A7A 87 DUP8 1A7B 80 DUP1 1A7C 3B EXTCODESIZE 1A7D 15 ISZERO 1A7E 80 DUP1 1A7F 15 ISZERO 1A80 61 PUSH2 0x1a88 1A83 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1A6F stack[0] = 0x20 // @1A73 stack[1] = memory[0x40:0x60] // @1A76 stack[2] = stack[-1] - memory[0x40:0x60] // @1A77 stack[3] = memory[0x40:0x60] // @1A78 stack[4] = 0x00 // @1A7A stack[5] = stack[-3] // @1A7D stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1a88, if !!address(stack[-3]).code.length label_1A84: // Incoming jump from 0x1A83, if not !!address(stack[-3]).code.length // Inputs[1] { @1A87 memory[0x00:0x00] } 1A84 60 PUSH1 0x00 1A86 80 DUP1 1A87 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A87 revert(memory[0x00:0x00]); } // Block terminates label_1A88: // Incoming jump from 0x1A83, if !!address(stack[-3]).code.length // Inputs[10] // { // @1A8A msg.gas // @1A8B stack[-6] // @1A8B stack[-7] // @1A8B stack[-3] // @1A8B memory[stack[-4]:stack[-4] + stack[-5]] // @1A8B stack[-5] // @1A8B stack[-2] // @1A8B stack[-4] // @1A8B address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1A8C stack[-10] // } 1A88 5B JUMPDEST 1A89 50 POP 1A8A 5A GAS 1A8B F1 CALL 1A8C 92 SWAP3 1A8D 50 POP 1A8E 50 POP 1A8F 50 POP 1A90 80 DUP1 1A91 15 ISZERO 1A92 61 PUSH2 0x1ab8 1A95 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1A8B memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1A8C stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1ab8, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1A96: // Incoming jump from 0x1A95, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1A9A memory[0x40:0x60] // @1A9D returndata.length // } 1A96 50 POP 1A97 60 PUSH1 0x40 1A99 80 DUP1 1A9A 51 MLOAD 1A9B 60 PUSH1 0x1f 1A9D 3D RETURNDATASIZE 1A9E 90 SWAP1 1A9F 81 DUP2 1AA0 01 ADD 1AA1 60 PUSH1 0x1f 1AA3 19 NOT 1AA4 16 AND 1AA5 82 DUP3 1AA6 01 ADD 1AA7 90 SWAP1 1AA8 92 SWAP3 1AA9 52 MSTORE 1AAA 61 PUSH2 0x1ab5 1AAD 91 SWAP2 1AAE 81 DUP2 1AAF 01 ADD 1AB0 90 SWAP1 1AB1 61 PUSH2 0x2597 1AB4 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1AA9 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1AAD stack[-1] = 0x1ab5 // @1AB0 stack[1] = memory[0x40:0x60] // @1AB0 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2597 1AB5 5B JUMPDEST 1AB6 60 PUSH1 0x01 label_1AB8: // Incoming jump from 0x1A95, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1ABC stack[-1] } 1AB8 5B JUMPDEST 1AB9 61 PUSH2 0x1b13 1ABC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b13, if stack[-1] label_1ABD: // Incoming jump from 0x1ABC, if not stack[-1] // Inputs[1] { @1ABD returndata.length } 1ABD 3D RETURNDATASIZE 1ABE 80 DUP1 1ABF 80 DUP1 1AC0 15 ISZERO 1AC1 61 PUSH2 0x1ae6 1AC4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1ABD stack[0] = returndata.length // @1ABE stack[1] = returndata.length // } // Block ends with conditional jump to 0x1ae6, if !returndata.length label_1AC5: // Incoming jump from 0x1AC4, if not !returndata.length // Inputs[6] // { // @1AC7 memory[0x40:0x60] // @1AC8 stack[-2] // @1ACF returndata.length // @1AD7 returndata.length // @1ADA returndata.length // @1AE1 returndata[0x00:0x00 + returndata.length] // } 1AC5 60 PUSH1 0x40 1AC7 51 MLOAD 1AC8 91 SWAP2 1AC9 50 POP 1ACA 60 PUSH1 0x1f 1ACC 19 NOT 1ACD 60 PUSH1 0x3f 1ACF 3D RETURNDATASIZE 1AD0 01 ADD 1AD1 16 AND 1AD2 82 DUP3 1AD3 01 ADD 1AD4 60 PUSH1 0x40 1AD6 52 MSTORE 1AD7 3D RETURNDATASIZE 1AD8 82 DUP3 1AD9 52 MSTORE 1ADA 3D RETURNDATASIZE 1ADB 60 PUSH1 0x00 1ADD 60 PUSH1 0x20 1ADF 84 DUP5 1AE0 01 ADD 1AE1 3E RETURNDATACOPY 1AE2 61 PUSH2 0x1aeb 1AE5 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1AC8 stack[-2] = memory[0x40:0x60] // @1AD6 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1AD9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1AE1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1aeb label_1AE6: // Incoming jump from 0x1AC4, if !returndata.length // Inputs[2] // { // @1AE9 stack[-2] // @1AEE memory[0x60:0x80] // } 1AE6 5B JUMPDEST 1AE7 60 PUSH1 0x60 1AE9 91 SWAP2 1AEA 50 POP 1AEB 5B JUMPDEST 1AEC 50 POP 1AED 80 DUP1 1AEE 51 MLOAD 1AEF 61 PUSH2 0x1b0b 1AF2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1AE9 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1b0b, if memory[0x60:0x80] label_1AF3: // Incoming jump from 0x1AF2, if not memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1AF2, if not memory[0x60:0x80] // Inputs[3] // { // @1AF5 memory[0x40:0x60] // @1B05 memory[0x40:0x60] // @1B0A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AF3 60 PUSH1 0x40 1AF5 51 MLOAD 1AF6 63 PUSH4 0x68d2bf6b 1AFB 60 PUSH1 0xe1 1AFD 1B SHL 1AFE 81 DUP2 1AFF 52 MSTORE 1B00 60 PUSH1 0x04 1B02 01 ADD 1B03 60 PUSH1 0x40 1B05 51 MLOAD 1B06 80 DUP1 1B07 91 SWAP2 1B08 03 SUB 1B09 90 SWAP1 1B0A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AFF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1B0A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B0B: // Incoming jump from 0x1AF2, if memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1AF2, if memory[0x60:0x80] // Inputs[3] // { // @1B0C stack[-1] // @1B0D memory[stack[-1]:stack[-1] + 0x20] // @1B12 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1B0B 5B JUMPDEST 1B0C 80 DUP1 1B0D 51 MLOAD 1B0E 81 DUP2 1B0F 60 PUSH1 0x20 1B11 01 ADD 1B12 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B12 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1B13: // Incoming jump from 0x1ABC, if stack[-1] // Inputs[2] // { // @1B1D stack[-1] // @1B27 stack[-2] // } 1B13 5B JUMPDEST 1B14 60 PUSH1 0x01 1B16 60 PUSH1 0x01 1B18 60 PUSH1 0xe0 1B1A 1B SHL 1B1B 03 SUB 1B1C 19 NOT 1B1D 16 AND 1B1E 63 PUSH4 0x0a85bd01 1B23 60 PUSH1 0xe1 1B25 1B SHL 1B26 14 EQ 1B27 90 SWAP1 1B28 50 POP // Stack delta = -1 // Outputs[1] { @1B27 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_1B29: // Incoming return from call to 0x2050 at 0x210C // Incoming jump from 0x1B28 // Inputs[3] // { // @1B2A stack[-6] // @1B2A stack[-1] // @1B2B stack[-5] // } 1B29 5B JUMPDEST 1B2A 94 SWAP5 1B2B 93 SWAP4 1B2C 50 POP 1B2D 50 POP 1B2E 50 POP 1B2F 50 POP 1B30 56 *JUMP // Stack delta = -5 // Outputs[1] { @1B2A stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1B31: // Incoming jump from 0x11E7 // Inputs[1] { @1B37 storage[0x0c] } 1B31 5B JUMPDEST 1B32 60 PUSH1 0x60 1B34 60 PUSH1 0x0c 1B36 80 DUP1 1B37 54 SLOAD 1B38 61 PUSH2 0x07ed 1B3B 90 SWAP1 1B3C 61 PUSH2 0x234c 1B3F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B32 stack[0] = 0x60 // @1B34 stack[1] = 0x0c // @1B3B stack[2] = 0x07ed // @1B3B stack[3] = storage[0x0c] // } // Block ends with call to 0x234c, returns to 0x07ED 1B40 5B JUMPDEST 1B41 60 PUSH1 0x60 1B43 81 DUP2 1B44 61 PUSH2 0x1b64 1B47 57 *JUMPI 1B48 50 POP 1B49 50 POP 1B4A 60 PUSH1 0x40 1B4C 80 DUP1 1B4D 51 MLOAD 1B4E 80 DUP1 1B4F 82 DUP3 1B50 01 ADD 1B51 90 SWAP1 1B52 91 SWAP2 1B53 52 MSTORE 1B54 60 PUSH1 0x01 1B56 81 DUP2 1B57 52 MSTORE 1B58 60 PUSH1 0x03 1B5A 60 PUSH1 0xfc 1B5C 1B SHL 1B5D 60 PUSH1 0x20 1B5F 82 DUP3 1B60 01 ADD 1B61 52 MSTORE 1B62 90 SWAP1 1B63 56 *JUMP 1B64 5B JUMPDEST 1B65 81 DUP2 1B66 60 PUSH1 0x00 1B68 5B JUMPDEST 1B69 81 DUP2 1B6A 15 ISZERO 1B6B 61 PUSH2 0x1b8e 1B6E 57 *JUMPI 1B6F 80 DUP1 1B70 61 PUSH2 0x1b78 1B73 81 DUP2 1B74 61 PUSH2 0x23e8 1B77 56 *JUMP 1B78 5B JUMPDEST 1B79 91 SWAP2 1B7A 50 POP 1B7B 61 PUSH2 0x1b87 1B7E 90 SWAP1 1B7F 50 POP 1B80 60 PUSH1 0x0a 1B82 83 DUP4 1B83 61 PUSH2 0x25ca 1B86 56 *JUMP 1B87 5B JUMPDEST 1B88 91 SWAP2 1B89 50 POP 1B8A 61 PUSH2 0x1b68 1B8D 56 *JUMP 1B8E 5B JUMPDEST 1B8F 60 PUSH1 0x00 1B91 81 DUP2 1B92 60 PUSH1 0x01 1B94 60 PUSH1 0x01 1B96 60 PUSH1 0x40 1B98 1B SHL 1B99 03 SUB 1B9A 81 DUP2 1B9B 11 GT 1B9C 15 ISZERO 1B9D 61 PUSH2 0x1ba8 1BA0 57 *JUMPI 1BA1 61 PUSH2 0x1ba8 1BA4 61 PUSH2 0x203a 1BA7 56 *JUMP 1BA8 5B JUMPDEST 1BA9 60 PUSH1 0x40 1BAB 51 MLOAD 1BAC 90 SWAP1 1BAD 80 DUP1 1BAE 82 DUP3 1BAF 52 MSTORE 1BB0 80 DUP1 1BB1 60 PUSH1 0x1f 1BB3 01 ADD 1BB4 60 PUSH1 0x1f 1BB6 19 NOT 1BB7 16 AND 1BB8 60 PUSH1 0x20 1BBA 01 ADD 1BBB 82 DUP3 1BBC 01 ADD 1BBD 60 PUSH1 0x40 1BBF 52 MSTORE 1BC0 80 DUP1 1BC1 15 ISZERO 1BC2 61 PUSH2 0x1bd2 1BC5 57 *JUMPI 1BC6 60 PUSH1 0x20 1BC8 82 DUP3 1BC9 01 ADD 1BCA 81 DUP2 1BCB 80 DUP1 1BCC 36 CALLDATASIZE 1BCD 83 DUP4 1BCE 37 CALLDATACOPY 1BCF 01 ADD 1BD0 90 SWAP1 1BD1 50 POP 1BD2 5B JUMPDEST 1BD3 50 POP 1BD4 90 SWAP1 1BD5 50 POP 1BD6 5B JUMPDEST 1BD7 84 DUP5 1BD8 15 ISZERO 1BD9 61 PUSH2 0x1b29 1BDC 57 *JUMPI 1BDD 61 PUSH2 0x1be7 1BE0 60 PUSH1 0x01 1BE2 83 DUP4 1BE3 61 PUSH2 0x25de 1BE6 56 *JUMP 1BE7 5B JUMPDEST 1BE8 91 SWAP2 1BE9 50 POP 1BEA 61 PUSH2 0x1bf4 1BED 60 PUSH1 0x0a 1BEF 86 DUP7 1BF0 61 PUSH2 0x25f5 1BF3 56 *JUMP 1BF4 5B JUMPDEST 1BF5 61 PUSH2 0x1bff 1BF8 90 SWAP1 1BF9 60 PUSH1 0x30 1BFB 61 PUSH2 0x2431 1BFE 56 *JUMP 1BFF 5B JUMPDEST 1C00 60 PUSH1 0xf8 1C02 1B SHL 1C03 81 DUP2 1C04 83 DUP4 1C05 81 DUP2 1C06 51 MLOAD 1C07 81 DUP2 1C08 10 LT 1C09 61 PUSH2 0x1c14 1C0C 57 *JUMPI 1C0D 61 PUSH2 0x1c14 1C10 61 PUSH2 0x23bc 1C13 56 *JUMP 1C14 5B JUMPDEST 1C15 60 PUSH1 0x20 1C17 01 ADD 1C18 01 ADD 1C19 90 SWAP1 1C1A 60 PUSH1 0x01 1C1C 60 PUSH1 0x01 1C1E 60 PUSH1 0xf8 1C20 1B SHL 1C21 03 SUB 1C22 19 NOT 1C23 16 AND 1C24 90 SWAP1 1C25 81 DUP2 1C26 60 PUSH1 0x00 1C28 1A BYTE 1C29 90 SWAP1 1C2A 53 MSTORE8 1C2B 50 POP 1C2C 61 PUSH2 0x1c36 1C2F 60 PUSH1 0x0a 1C31 86 DUP7 1C32 61 PUSH2 0x25ca 1C35 56 *JUMP 1C36 5B JUMPDEST 1C37 94 SWAP5 1C38 50 POP 1C39 61 PUSH2 0x1bd6 1C3C 56 *JUMP label_1C3D: // Incoming call from 0x1438, returns to 0x1439 // Inputs[3] // { // @1C40 stack[-2] // @1C44 stack[-3] // @1C45 stack[-1] // } 1C3D 5B JUMPDEST 1C3E 60 PUSH1 0x00 1C40 82 DUP3 1C41 61 PUSH2 0x1c4a 1C44 85 DUP6 1C45 84 DUP5 1C46 61 PUSH2 0x1c60 1C49 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1C3E stack[0] = 0x00 // @1C40 stack[1] = stack[-2] // @1C41 stack[2] = 0x1c4a // @1C44 stack[3] = stack[-3] // @1C45 stack[4] = stack[-1] // } // Block ends with call to 0x1c60, returns to 0x1C4A label_1C4A: // Incoming return from call to 0x1C60 at 0x1C49 // Inputs[4] // { // @1C4B stack[-1] // @1C4B stack[-2] // @1C4C stack[-7] // @1C4D stack[-6] // } 1C4A 5B JUMPDEST 1C4B 14 EQ 1C4C 94 SWAP5 1C4D 93 SWAP4 1C4E 50 POP 1C4F 50 POP 1C50 50 POP 1C51 50 POP 1C52 56 *JUMP // Stack delta = -6 // Outputs[1] { @1C4C stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1C53: // Incoming call from 0x1A38, returns to 0x0988 // Inputs[3] // { // @1C57 stack[-3] // @1C58 stack[-2] // @1C59 stack[-1] // } 1C53 5B JUMPDEST 1C54 61 PUSH2 0x093d 1C57 83 DUP4 1C58 83 DUP4 1C59 83 DUP4 1C5A 60 PUSH1 0x01 1C5C 61 PUSH2 0x1cd4 1C5F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1C54 stack[0] = 0x093d // @1C57 stack[1] = stack[-3] // @1C58 stack[2] = stack[-2] // @1C59 stack[3] = stack[-1] // @1C5A stack[4] = 0x01 // } // Block ends with call to 0x1cd4, returns to 0x093D label_1C60: // Incoming call from 0x1C49, returns to 0x1C4A // Inputs[3] // { // @1C63 stack[-1] // @1C66 stack[-2] // @1C67 memory[stack[-2]:stack[-2] + 0x20] // } 1C60 5B JUMPDEST 1C61 60 PUSH1 0x00 1C63 81 DUP2 1C64 81 DUP2 1C65 5B JUMPDEST 1C66 84 DUP5 1C67 51 MLOAD 1C68 81 DUP2 1C69 10 LT 1C6A 15 ISZERO 1C6B 61 PUSH2 0x1ccc 1C6E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1C61 stack[0] = 0x00 // @1C63 stack[1] = stack[-1] // @1C64 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1ccc, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1C6F: // Incoming jump from 0x1C6E, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1C6E, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1C71 stack[-5] // @1C72 stack[-1] // @1C74 memory[stack[-5]:stack[-5] + 0x20] // } 1C6F 60 PUSH1 0x00 1C71 85 DUP6 1C72 82 DUP3 1C73 81 DUP2 1C74 51 MLOAD 1C75 81 DUP2 1C76 10 LT 1C77 61 PUSH2 0x1c82 1C7A 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1C6F stack[0] = 0x00 // @1C71 stack[1] = stack[-5] // @1C72 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x1c82, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1C7B: // Incoming jump from 0x1C7A, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 1C7B 61 PUSH2 0x1c82 1C7E 61 PUSH2 0x23bc 1C81 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C7B stack[0] = 0x1c82 } // Block ends with unconditional jump to 0x23bc label_1C82: // Incoming jump from 0x1C7A, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @1C85 stack[-1] // @1C89 stack[-2] // @1C8A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @1C8B stack[-3] // @1C8E stack[-5] // } 1C82 5B JUMPDEST 1C83 60 PUSH1 0x20 1C85 02 MUL 1C86 60 PUSH1 0x20 1C88 01 ADD 1C89 01 ADD 1C8A 51 MLOAD 1C8B 90 SWAP1 1C8C 50 POP 1C8D 80 DUP1 1C8E 83 DUP4 1C8F 11 GT 1C90 61 PUSH2 0x1ca8 1C93 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1C8B stack[-3] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with conditional jump to 0x1ca8, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] label_1C94: // Incoming jump from 0x1C93, if not stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[3] // { // @1C96 stack[-3] // @1C9B stack[-1] // @1CA1 memory[0x00:0x40] // } 1C94 60 PUSH1 0x00 1C96 83 DUP4 1C97 81 DUP2 1C98 52 MSTORE 1C99 60 PUSH1 0x20 1C9B 82 DUP3 1C9C 90 SWAP1 1C9D 52 MSTORE 1C9E 60 PUSH1 0x40 1CA0 90 SWAP1 1CA1 20 SHA3 1CA2 92 SWAP3 1CA3 50 POP 1CA4 61 PUSH2 0x1cb9 1CA7 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1C98 memory[0x00:0x20] = stack[-3] // @1C9D memory[0x20:0x40] = stack[-1] // @1CA2 stack[-3] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x1cb9 label_1CA8: // Incoming jump from 0x1C93, if stack[-5] > memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // Inputs[4] // { // @1CAB stack[-1] // @1CB0 stack[-3] // @1CB6 memory[0x00:0x40] // @1CBB stack[-2] // } 1CA8 5B JUMPDEST 1CA9 60 PUSH1 0x00 1CAB 81 DUP2 1CAC 81 DUP2 1CAD 52 MSTORE 1CAE 60 PUSH1 0x20 1CB0 84 DUP5 1CB1 90 SWAP1 1CB2 52 MSTORE 1CB3 60 PUSH1 0x40 1CB5 90 SWAP1 1CB6 20 SHA3 1CB7 92 SWAP3 1CB8 50 POP 1CB9 5B JUMPDEST 1CBA 50 POP 1CBB 80 DUP1 1CBC 61 PUSH2 0x1cc4 1CBF 81 DUP2 1CC0 61 PUSH2 0x23e8 1CC3 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @1CAD memory[0x00:0x20] = stack[-1] // @1CB2 memory[0x20:0x40] = stack[-3] // @1CB7 stack[-3] = keccak256(memory[0x00:0x40]) // @1CBB stack[-1] = stack[-2] // @1CBC stack[0] = 0x1cc4 // @1CBF stack[1] = stack[-2] // } // Block ends with call to 0x23e8, returns to 0x1CC4 label_1CC4: // Incoming return from call to 0x23E8 at 0x1CC3 // Incoming return from call to 0x23E8 at 0x1CC3 // Inputs[2] // { // @1CC5 stack[-1] // @1CC5 stack[-3] // } 1CC4 5B JUMPDEST 1CC5 91 SWAP2 1CC6 50 POP 1CC7 50 POP 1CC8 61 PUSH2 0x1c65 1CCB 56 *JUMP // Stack delta = -2 // Outputs[1] { @1CC5 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1c65 label_1CCC: // Incoming jump from 0x1C6E, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x1C6E, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @1CCE stack[-6] // @1CCE stack[-2] // @1CCF stack[-5] // } 1CCC 5B JUMPDEST 1CCD 50 POP 1CCE 93 SWAP4 1CCF 92 SWAP3 1CD0 50 POP 1CD1 50 POP 1CD2 50 POP 1CD3 56 *JUMP // Stack delta = -5 // Outputs[1] { @1CCE stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1CD4: // Incoming call from 0x1C5F, returns to 0x093D // Inputs[2] // { // @1CD7 storage[0x00] // @1CE0 stack[-4] // } 1CD4 5B JUMPDEST 1CD5 60 PUSH1 0x00 1CD7 54 SLOAD 1CD8 60 PUSH1 0x01 1CDA 60 PUSH1 0x01 1CDC 60 PUSH1 0xa0 1CDE 1B SHL 1CDF 03 SUB 1CE0 85 DUP6 1CE1 16 AND 1CE2 61 PUSH2 0x1cfd 1CE5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CD7 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1cfd, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1CE6: // Incoming jump from 0x1CE5, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1CE8 memory[0x40:0x60] // @1CF7 memory[0x40:0x60] // @1CFC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1CE6 60 PUSH1 0x40 1CE8 51 MLOAD 1CE9 62 PUSH3 0x2e0763 1CED 60 PUSH1 0xe8 1CEF 1B SHL 1CF0 81 DUP2 1CF1 52 MSTORE 1CF2 60 PUSH1 0x04 1CF4 01 ADD 1CF5 60 PUSH1 0x40 1CF7 51 MLOAD 1CF8 80 DUP1 1CF9 91 SWAP2 1CFA 03 SUB 1CFB 90 SWAP1 1CFC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1CF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @1CFC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1CFD: // Incoming jump from 0x1CE5, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1CFE stack[-4] } 1CFD 5B JUMPDEST 1CFE 83 DUP4 1CFF 61 PUSH2 0x1d1b 1D02 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1d1b, if stack[-4] label_1D03: // Incoming jump from 0x1D02, if not stack[-4] // Inputs[3] // { // @1D05 memory[0x40:0x60] // @1D15 memory[0x40:0x60] // @1D1A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1D03 60 PUSH1 0x40 1D05 51 MLOAD 1D06 63 PUSH4 0xb562e8dd 1D0B 60 PUSH1 0xe0 1D0D 1B SHL 1D0E 81 DUP2 1D0F 52 MSTORE 1D10 60 PUSH1 0x04 1D12 01 ADD 1D13 60 PUSH1 0x40 1D15 51 MLOAD 1D16 80 DUP1 1D17 91 SWAP2 1D18 03 SUB 1D19 90 SWAP1 1D1A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D0F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @1D1A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1D1B: // Incoming jump from 0x1D02, if stack[-4] // Inputs[9] // { // @1D24 stack[-5] // @1D36 memory[0x00:0x40] // @1D38 storage[keccak256(memory[0x00:0x40])] // @1D58 stack[-4] // @1D89 stack[-1] // @1D93 memory[0x00:0x40] // @1D95 storage[keccak256(memory[0x00:0x40])] // @1DA8 block.timestamp // @1DB7 stack[-2] // } 1D1B 5B JUMPDEST 1D1C 60 PUSH1 0x01 1D1E 60 PUSH1 0x01 1D20 60 PUSH1 0xa0 1D22 1B SHL 1D23 03 SUB 1D24 85 DUP6 1D25 16 AND 1D26 60 PUSH1 0x00 1D28 81 DUP2 1D29 81 DUP2 1D2A 52 MSTORE 1D2B 60 PUSH1 0x05 1D2D 60 PUSH1 0x20 1D2F 90 SWAP1 1D30 81 DUP2 1D31 52 MSTORE 1D32 60 PUSH1 0x40 1D34 80 DUP1 1D35 83 DUP4 1D36 20 SHA3 1D37 80 DUP1 1D38 54 SLOAD 1D39 6F PUSH16 0xffffffffffffffffffffffffffffffff 1D4A 19 NOT 1D4B 81 DUP2 1D4C 16 AND 1D4D 60 PUSH1 0x01 1D4F 60 PUSH1 0x01 1D51 60 PUSH1 0x40 1D53 1B SHL 1D54 03 SUB 1D55 80 DUP1 1D56 83 DUP4 1D57 16 AND 1D58 8C DUP13 1D59 01 ADD 1D5A 81 DUP2 1D5B 16 AND 1D5C 91 SWAP2 1D5D 82 DUP3 1D5E 17 OR 1D5F 68 PUSH9 0x010000000000000000 1D69 67 PUSH8 0xffffffffffffffff 1D72 19 NOT 1D73 90 SWAP1 1D74 94 SWAP5 1D75 16 AND 1D76 90 SWAP1 1D77 92 SWAP3 1D78 17 OR 1D79 83 DUP4 1D7A 90 SWAP1 1D7B 04 DIV 1D7C 81 DUP2 1D7D 16 AND 1D7E 8C DUP13 1D7F 01 ADD 1D80 81 DUP2 1D81 16 AND 1D82 90 SWAP1 1D83 92 SWAP3 1D84 02 MUL 1D85 17 OR 1D86 90 SWAP1 1D87 91 SWAP2 1D88 55 SSTORE 1D89 85 DUP6 1D8A 84 DUP5 1D8B 52 MSTORE 1D8C 60 PUSH1 0x04 1D8E 90 SWAP1 1D8F 92 SWAP3 1D90 52 MSTORE 1D91 90 SWAP1 1D92 91 SWAP2 1D93 20 SHA3 1D94 80 DUP1 1D95 54 SLOAD 1D96 60 PUSH1 0x01 1D98 60 PUSH1 0x01 1D9A 60 PUSH1 0xe0 1D9C 1B SHL 1D9D 03 SUB 1D9E 19 NOT 1D9F 16 AND 1DA0 90 SWAP1 1DA1 92 SWAP3 1DA2 17 OR 1DA3 60 PUSH1 0x01 1DA5 60 PUSH1 0xa0 1DA7 1B SHL 1DA8 42 TIMESTAMP 1DA9 90 SWAP1 1DAA 92 SWAP3 1DAB 16 AND 1DAC 91 SWAP2 1DAD 90 SWAP1 1DAE 91 SWAP2 1DAF 02 MUL 1DB0 17 OR 1DB1 90 SWAP1 1DB2 55 SSTORE 1DB3 80 DUP1 1DB4 80 DUP1 1DB5 85 DUP6 1DB6 01 ADD 1DB7 83 DUP4 1DB8 80 DUP1 1DB9 15 ISZERO 1DBA 61 PUSH2 0x1dcc 1DBD 57 *JUMPI // Stack delta = +3 // Outputs[9] // { // @1D2A memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1D31 memory[0x20:0x40] = 0x05 // @1D88 storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * ((0x01 << 0x40) - 0x01 & stack[-4] + ((0x01 << 0x40) - 0x01 & (((0x01 << 0x40) - 0x01 & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0x40) - 0x01)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | ((0x01 << 0x40) - 0x01 & stack[-4] + (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0x40) - 0x01)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffffffffffffffffffff) // @1D8B memory[0x00:0x20] = stack[-1] // @1D90 memory[0x20:0x40] = 0x04 // @1DB2 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x40) - 0x01 & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1DB3 stack[0] = stack[-1] // @1DB6 stack[1] = stack[-4] + stack[-1] // @1DB7 stack[2] = stack[-2] // } // Block ends with conditional jump to 0x1dcc, if !stack[-2] label_1DBE: // Incoming jump from 0x1DBD, if not !stack[-2] // Inputs[2] // { // @1DC7 stack[-8] // @1DC9 address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // } 1DBE 50 POP 1DBF 60 PUSH1 0x01 1DC1 60 PUSH1 0x01 1DC3 60 PUSH1 0xa0 1DC5 1B SHL 1DC6 03 SUB 1DC7 87 DUP8 1DC8 16 AND 1DC9 3B EXTCODESIZE 1DCA 15 ISZERO 1DCB 15 ISZERO 1DCC 5B JUMPDEST 1DCD 15 ISZERO 1DCE 61 PUSH2 0x1e55 1DD1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e55, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length label_1DD2: // Incoming jump from 0x1DD1, if not !stack[-1] // Incoming jump from 0x1DD1, if not !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @1DD5 memory[0x40:0x60] // @1DD6 stack[-2] // @1DE0 stack[-7] // @1E0A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1E18 stack[-5] // } 1DD2 5B JUMPDEST 1DD3 60 PUSH1 0x40 1DD5 51 MLOAD 1DD6 82 DUP3 1DD7 90 SWAP1 1DD8 60 PUSH1 0x01 1DDA 60 PUSH1 0x01 1DDC 60 PUSH1 0xa0 1DDE 1B SHL 1DDF 03 SUB 1DE0 89 DUP10 1DE1 16 AND 1DE2 90 SWAP1 1DE3 60 PUSH1 0x00 1DE5 90 SWAP1 1DE6 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1E07 90 SWAP1 1E08 82 DUP3 1E09 90 SWAP1 1E0A A4 LOG4 1E0B 61 PUSH2 0x1e1d 1E0E 60 PUSH1 0x00 1E10 88 DUP9 1E11 84 DUP5 1E12 80 DUP1 1E13 60 PUSH1 0x01 1E15 01 ADD 1E16 95 SWAP6 1E17 50 POP 1E18 88 DUP9 1E19 61 PUSH2 0x1a39 1E1C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1E0A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @1E0B stack[0] = 0x1e1d // @1E0E stack[1] = 0x00 // @1E10 stack[2] = stack[-7] // @1E11 stack[3] = stack[-2] // @1E16 stack[-2] = 0x01 + stack[-2] // @1E18 stack[4] = stack[-5] // } // Block ends with unconditional jump to 0x1a39 1E1D 5B JUMPDEST 1E1E 61 PUSH2 0x1e3a 1E21 57 *JUMPI 1E22 60 PUSH1 0x40 1E24 51 MLOAD 1E25 63 PUSH4 0x68d2bf6b 1E2A 60 PUSH1 0xe1 1E2C 1B SHL 1E2D 81 DUP2 1E2E 52 MSTORE 1E2F 60 PUSH1 0x04 1E31 01 ADD 1E32 60 PUSH1 0x40 1E34 51 MLOAD 1E35 80 DUP1 1E36 91 SWAP2 1E37 03 SUB 1E38 90 SWAP1 1E39 FD *REVERT 1E3A 5B JUMPDEST 1E3B 80 DUP1 1E3C 82 DUP3 1E3D 14 EQ 1E3E 15 ISZERO 1E3F 61 PUSH2 0x1dd2 1E42 57 *JUMPI 1E43 82 DUP3 1E44 60 PUSH1 0x00 1E46 54 SLOAD 1E47 14 EQ 1E48 61 PUSH2 0x1e50 1E4B 57 *JUMPI 1E4C 60 PUSH1 0x00 1E4E 80 DUP1 1E4F FD *REVERT 1E50 5B JUMPDEST 1E51 61 PUSH2 0x1e9b 1E54 56 *JUMP label_1E55: // Incoming jump from 0x1DD1, if !stack[-1] // Incoming jump from 0x1DD1, if !!!address(stack[-8] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @1E59 memory[0x40:0x60] // @1E5C stack[-2] // @1E68 stack[-7] // @1E92 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1E93 stack[-1] // } 1E55 5B JUMPDEST 1E56 5B JUMPDEST 1E57 60 PUSH1 0x40 1E59 51 MLOAD 1E5A 60 PUSH1 0x01 1E5C 83 DUP4 1E5D 01 ADD 1E5E 92 SWAP3 1E5F 90 SWAP1 1E60 60 PUSH1 0x01 1E62 60 PUSH1 0x01 1E64 60 PUSH1 0xa0 1E66 1B SHL 1E67 03 SUB 1E68 89 DUP10 1E69 16 AND 1E6A 90 SWAP1 1E6B 60 PUSH1 0x00 1E6D 90 SWAP1 1E6E 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1E8F 90 SWAP1 1E90 82 DUP3 1E91 90 SWAP1 1E92 A4 LOG4 1E93 80 DUP1 1E94 82 DUP3 1E95 14 EQ 1E96 15 ISZERO 1E97 61 PUSH2 0x1e56 1E9A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1E5E stack[-2] = stack[-2] + 0x01 // @1E92 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x1e56, if !(stack[-2] + 0x01 == stack[-1]) label_1E9B: // Incoming jump from 0x1E9A, if not !(stack[-2] + 0x01 == stack[-1]) // Incoming jump from 0x1E9A, if not !(stack[-2] + 0x01 == stack[-1]) // Inputs[1] { @1E9F stack[-2] } 1E9B 5B JUMPDEST 1E9C 50 POP 1E9D 60 PUSH1 0x00 1E9F 55 SSTORE 1EA0 61 PUSH2 0x189f 1EA3 56 *JUMP // Stack delta = -2 // Outputs[1] { @1E9F storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x189f label_1EA4: // Incoming jump from 0x0987 // Incoming jump from 0x0C9C // Incoming jump from 0x0E39 // Inputs[2] // { // @1EA5 stack[-3] // @1EA7 storage[stack[-3]] // } 1EA4 5B JUMPDEST 1EA5 82 DUP3 1EA6 80 DUP1 1EA7 54 SLOAD 1EA8 61 PUSH2 0x1eb0 1EAB 90 SWAP1 1EAC 61 PUSH2 0x234c 1EAF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1EA5 stack[0] = stack[-3] // @1EAB stack[1] = 0x1eb0 // @1EAB stack[2] = storage[stack[-3]] // } // Block ends with call to 0x234c, returns to 0x1EB0 label_1EB0: // Incoming return from call to 0x234C at 0x1EAF // Inputs[5] // { // @1EB1 stack[-1] // @1EB1 stack[-2] // @1EB9 memory[0x00:0x20] // @1EC4 stack[-4] // @1EC5 stack[-3] // } 1EB0 5B JUMPDEST 1EB1 90 SWAP1 1EB2 60 PUSH1 0x00 1EB4 52 MSTORE 1EB5 60 PUSH1 0x20 1EB7 60 PUSH1 0x00 1EB9 20 SHA3 1EBA 90 SWAP1 1EBB 60 PUSH1 0x1f 1EBD 01 ADD 1EBE 60 PUSH1 0x20 1EC0 90 SWAP1 1EC1 04 DIV 1EC2 81 DUP2 1EC3 01 ADD 1EC4 92 SWAP3 1EC5 82 DUP3 1EC6 61 PUSH2 0x1ed2 1EC9 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1EB4 memory[0x00:0x20] = stack[-2] // @1EBA stack[-2] = keccak256(memory[0x00:0x20]) // @1EC4 stack[-1] = stack[-4] // @1EC4 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1ed2, if stack[-3] label_1ECA: // Incoming jump from 0x1EC9, if not stack[-3] // Inputs[1] { @1ECC stack[-5] } 1ECA 60 PUSH1 0x00 1ECC 85 DUP6 1ECD 55 SSTORE 1ECE 61 PUSH2 0x1f18 1ED1 56 *JUMP // Stack delta = +0 // Outputs[1] { @1ECD storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1f18 label_1ED2: // Incoming jump from 0x1EC9, if stack[-3] // Inputs[1] { @1ED3 stack[-3] } 1ED2 5B JUMPDEST 1ED3 82 DUP3 1ED4 60 PUSH1 0x1f 1ED6 10 LT 1ED7 61 PUSH2 0x1eeb 1EDA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1eeb, if 0x1f < stack[-3] label_1EDB: // Incoming jump from 0x1EDA, if not 0x1f < stack[-3] // Inputs[4] // { // @1EDB stack[-1] // @1EDC memory[stack[-1]:stack[-1] + 0x20] // @1EE1 stack[-3] // @1EE5 stack[-5] // } 1EDB 80 DUP1 1EDC 51 MLOAD 1EDD 60 PUSH1 0xff 1EDF 19 NOT 1EE0 16 AND 1EE1 83 DUP4 1EE2 80 DUP1 1EE3 01 ADD 1EE4 17 OR 1EE5 85 DUP6 1EE6 55 SSTORE 1EE7 61 PUSH2 0x1f18 1EEA 56 *JUMP // Stack delta = +0 // Outputs[1] { @1EE6 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1f18 label_1EEB: // Incoming jump from 0x1EDA, if 0x1f < stack[-3] // Inputs[2] // { // @1EEC stack[-3] // @1EF2 stack[-5] // } 1EEB 5B JUMPDEST 1EEC 82 DUP3 1EED 80 DUP1 1EEE 01 ADD 1EEF 60 PUSH1 0x01 1EF1 01 ADD 1EF2 85 DUP6 1EF3 55 SSTORE 1EF4 82 DUP3 1EF5 15 ISZERO 1EF6 61 PUSH2 0x1f18 1EF9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1EF3 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1f18, if !stack[-3] label_1EFA: // Incoming jump from 0x1EF9, if not !stack[-3] // Inputs[2] // { // @1EFA stack[-3] // @1EFA stack[-1] // } 1EFA 91 SWAP2 1EFB 82 DUP3 1EFC 01 ADD 1EFD 5B JUMPDEST 1EFE 82 DUP3 1EFF 81 DUP2 1F00 11 GT 1F01 15 ISZERO 1F02 61 PUSH2 0x1f18 1F05 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1EFA stack[-3] = stack[-1] // @1EFC stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1f18, if !(stack[-1] + stack[-3] > stack[-1]) label_1F06: // Incoming jump from 0x1F05, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1F05, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @1F06 stack[-3] // @1F07 memory[stack[-3]:stack[-3] + 0x20] // @1F08 stack[-2] // @1F0A stack[-1] // } 1F06 82 DUP3 1F07 51 MLOAD 1F08 82 DUP3 1F09 55 SSTORE 1F0A 91 SWAP2 1F0B 60 PUSH1 0x20 1F0D 01 ADD 1F0E 91 SWAP2 1F0F 90 SWAP1 1F10 60 PUSH1 0x01 1F12 01 ADD 1F13 90 SWAP1 1F14 61 PUSH2 0x1efd 1F17 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1F09 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1F0E stack[-3] = 0x20 + stack[-3] // @1F13 stack[-2] = 0x01 + stack[-2] // @1F13 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1efd label_1F18: // Incoming jump from 0x1EEA // Incoming jump from 0x1F05, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1F05, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1ED1 // Incoming jump from 0x1EF9, if !stack[-3] // Inputs[2] // { // @1F1D stack[-4] // @1F1E stack[-3] // } 1F18 5B JUMPDEST 1F19 50 POP 1F1A 61 PUSH2 0x1f24 1F1D 92 SWAP3 1F1E 91 SWAP2 1F1F 50 POP 1F20 61 PUSH2 0x1f28 1F23 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1F1D stack[-4] = 0x1f24 // @1F1E stack[-3] = stack[-4] // } // Block ends with call to 0x1f28, returns to 0x1F24 label_1F24: // Incoming jump from 0x1F31, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1F31, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1F28 at 0x1F23 // Inputs[2] // { // @1F26 stack[-3] // @1F26 stack[-2] // } 1F24 5B JUMPDEST 1F25 50 POP 1F26 90 SWAP1 1F27 56 *JUMP // Stack delta = -2 // Outputs[1] { @1F26 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1F28: // Incoming call from 0x1F23, returns to 0x1F24 // Inputs[2] // { // @1F2A stack[-1] // @1F2B stack[-2] // } 1F28 5B JUMPDEST 1F29 5B JUMPDEST 1F2A 80 DUP1 1F2B 82 DUP3 1F2C 11 GT 1F2D 15 ISZERO 1F2E 61 PUSH2 0x1f24 1F31 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f24, if !(stack[-2] > stack[-1]) label_1F32: // Incoming jump from 0x1F31, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1F31, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1F34 stack[-1] } 1F32 60 PUSH1 0x00 1F34 81 DUP2 1F35 55 SSTORE 1F36 60 PUSH1 0x01 1F38 01 ADD 1F39 61 PUSH2 0x1f29 1F3C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1F35 storage[stack[-1]] = 0x00 // @1F38 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1f29 label_1F3D: // Incoming call from 0x1F6F, returns to 0x1236 // Incoming call from 0x25B3, returns to 0x1236 // Inputs[1] { @1F47 stack[-1] } 1F3D 5B JUMPDEST 1F3E 60 PUSH1 0x01 1F40 60 PUSH1 0x01 1F42 60 PUSH1 0xe0 1F44 1B SHL 1F45 03 SUB 1F46 19 NOT 1F47 81 DUP2 1F48 16 AND 1F49 81 DUP2 1F4A 14 EQ 1F4B 61 PUSH2 0x1620 1F4E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1620, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1F4F: // Incoming jump from 0x1F4E, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1F52 memory[0x00:0x00] } 1F4F 60 PUSH1 0x00 1F51 80 DUP1 1F52 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F52 revert(memory[0x00:0x00]); } // Block terminates label_1F53: // Incoming call from 0x0270, returns to 0x0271 // Inputs[2] // { // @1F58 stack[-1] // @1F59 stack[-2] // } 1F53 5B JUMPDEST 1F54 60 PUSH1 0x00 1F56 60 PUSH1 0x20 1F58 82 DUP3 1F59 84 DUP5 1F5A 03 SUB 1F5B 12 SLT 1F5C 15 ISZERO 1F5D 61 PUSH2 0x1f65 1F60 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F54 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f65, if !(stack[-2] - stack[-1] i< 0x20) label_1F61: // Incoming jump from 0x1F60, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F64 memory[0x00:0x00] } 1F61 60 PUSH1 0x00 1F63 80 DUP1 1F64 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F64 revert(memory[0x00:0x00]); } // Block terminates label_1F65: // Incoming jump from 0x1F60, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1F66 stack[-2] // @1F67 msg.data[stack[-2]:stack[-2] + 0x20] // } 1F65 5B JUMPDEST 1F66 81 DUP2 1F67 35 CALLDATALOAD 1F68 61 PUSH2 0x1236 1F6B 81 DUP2 1F6C 61 PUSH2 0x1f3d 1F6F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F67 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1F68 stack[1] = 0x1236 // @1F6B stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1f3d, returns to 0x1236 label_1F70: // Incoming call from 0x1FB3, returns to 0x1FB4 // Inputs[1] { @1F74 stack[-3] } 1F70 5B JUMPDEST 1F71 60 PUSH1 0x00 1F73 5B JUMPDEST 1F74 83 DUP4 1F75 81 DUP2 1F76 10 LT 1F77 15 ISZERO 1F78 61 PUSH2 0x1f8b 1F7B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F71 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f8b, if !(0x00 < stack[-3]) label_1F7C: // Incoming jump from 0x1F7B, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1F7B, if not !(0x00 < stack[-3]) // Inputs[4] // { // @1F7C stack[-2] // @1F7D stack[-1] // @1F7F memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1F80 stack[-3] // } 1F7C 81 DUP2 1F7D 81 DUP2 1F7E 01 ADD 1F7F 51 MLOAD 1F80 83 DUP4 1F81 82 DUP3 1F82 01 ADD 1F83 52 MSTORE 1F84 60 PUSH1 0x20 1F86 01 ADD 1F87 61 PUSH2 0x1f73 1F8A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1F83 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1F86 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1f73 label_1F8B: // Incoming jump from 0x1F7B, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1F7B, if !(0x00 < stack[-3]) // Inputs[2] // { // @1F8C stack[-4] // @1F8D stack[-1] // } 1F8B 5B JUMPDEST 1F8C 83 DUP4 1F8D 81 DUP2 1F8E 11 GT 1F8F 15 ISZERO 1F90 61 PUSH2 0x10c7 1F93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10c7, if !(stack[-1] > stack[-4]) label_1F94: // Incoming jump from 0x1F93, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @1F98 stack[-4] // @1F99 stack[-3] // @1F9B stack[-5] // } 1F94 50 POP 1F95 50 POP 1F96 60 PUSH1 0x00 1F98 91 SWAP2 1F99 01 ADD 1F9A 52 MSTORE 1F9B 56 *JUMP // Stack delta = -5 // Outputs[1] { @1F9A memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1F9C: // Incoming call from 0x1FDA, returns to 0x1236 // Incoming call from 0x258C, returns to 0x258D // Inputs[3] // { // @1F9F stack[-1] // @1FA0 memory[stack[-1]:stack[-1] + 0x20] // @1FA2 stack[-2] // } 1F9C 5B JUMPDEST 1F9D 60 PUSH1 0x00 1F9F 81 DUP2 1FA0 51 MLOAD 1FA1 80 DUP1 1FA2 84 DUP5 1FA3 52 MSTORE 1FA4 61 PUSH2 0x1fb4 1FA7 81 DUP2 1FA8 60 PUSH1 0x20 1FAA 86 DUP7 1FAB 01 ADD 1FAC 60 PUSH1 0x20 1FAE 86 DUP7 1FAF 01 ADD 1FB0 61 PUSH2 0x1f70 1FB3 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1F9D stack[0] = 0x00 // @1FA0 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1FA3 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1FA4 stack[2] = 0x1fb4 // @1FA7 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1FAB stack[4] = stack[-2] + 0x20 // @1FAF stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1f70, returns to 0x1FB4 label_1FB4: // Incoming return from call to 0x1F70 at 0x1FB3 // Inputs[4] // { // @1FB7 stack[-1] // @1FBC stack[-4] // @1FBD stack[-2] // @1FC3 stack[-5] // } 1FB4 5B JUMPDEST 1FB5 60 PUSH1 0x1f 1FB7 01 ADD 1FB8 60 PUSH1 0x1f 1FBA 19 NOT 1FBB 16 AND 1FBC 92 SWAP3 1FBD 90 SWAP1 1FBE 92 SWAP3 1FBF 01 ADD 1FC0 60 PUSH1 0x20 1FC2 01 ADD 1FC3 92 SWAP3 1FC4 91 SWAP2 1FC5 50 POP 1FC6 50 POP 1FC7 56 *JUMP // Stack delta = -4 // Outputs[1] { @1FC3 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1FC8: // Incoming jump from 0x02AC // Inputs[2] // { // @1FCB stack[-1] // @1FD6 stack[-2] // } 1FC8 5B JUMPDEST 1FC9 60 PUSH1 0x20 1FCB 81 DUP2 1FCC 52 MSTORE 1FCD 60 PUSH1 0x00 1FCF 61 PUSH2 0x1236 1FD2 60 PUSH1 0x20 1FD4 83 DUP4 1FD5 01 ADD 1FD6 84 DUP5 1FD7 61 PUSH2 0x1f9c 1FDA 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1FCC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1FCD stack[0] = 0x00 // @1FCF stack[1] = 0x1236 // @1FD5 stack[2] = stack[-1] + 0x20 // @1FD6 stack[3] = stack[-2] // } // Block ends with call to 0x1f9c, returns to 0x1236 label_1FDB: // Incoming call from 0x05CF, returns to 0x05D0 // Incoming call from 0x0553, returns to 0x0554 // Incoming call from 0x02C7, returns to 0x02C8 // Incoming call from 0x0624, returns to 0x0625 // Incoming call from 0x0684, returns to 0x0685 // Incoming call from 0x043B, returns to 0x043C // Incoming call from 0x04DF, returns to 0x04E0 // Inputs[2] // { // @1FE0 stack[-1] // @1FE1 stack[-2] // } 1FDB 5B JUMPDEST 1FDC 60 PUSH1 0x00 1FDE 60 PUSH1 0x20 1FE0 82 DUP3 1FE1 84 DUP5 1FE2 03 SUB 1FE3 12 SLT 1FE4 15 ISZERO 1FE5 61 PUSH2 0x1fed 1FE8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FDC stack[0] = 0x00 } // Block ends with conditional jump to 0x1fed, if !(stack[-2] - stack[-1] i< 0x20) label_1FE9: // Incoming jump from 0x1FE8, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1FEC memory[0x00:0x00] } 1FE9 60 PUSH1 0x00 1FEB 80 DUP1 1FEC FD *REVERT // Stack delta = +0 // Outputs[1] { @1FEC revert(memory[0x00:0x00]); } // Block terminates label_1FED: // Incoming jump from 0x1FE8, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1FEF stack[-2] // @1FEF msg.data[stack[-2]:stack[-2] + 0x20] // @1FF0 stack[-4] // @1FF1 stack[-3] // } 1FED 5B JUMPDEST 1FEE 50 POP 1FEF 35 CALLDATALOAD 1FF0 91 SWAP2 1FF1 90 SWAP1 1FF2 50 POP 1FF3 56 *JUMP // Stack delta = -3 // Outputs[1] { @1FF0 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1FF4: // Incoming call from 0x234B, returns to 0x21FD // Incoming call from 0x202B, returns to 0x202C // Incoming call from 0x2328, returns to 0x21FD // Incoming call from 0x2155, returns to 0x2156 // Incoming call from 0x231A, returns to 0x231B // Incoming call from 0x2163, returns to 0x2164 // Incoming call from 0x2224, returns to 0x2225 // Incoming call from 0x21EE, returns to 0x21EF // Incoming call from 0x2232, returns to 0x2233 // Incoming call from 0x218E, returns to 0x1236 // Inputs[2] // { // @1FF5 stack[-1] // @1FF6 msg.data[stack[-1]:stack[-1] + 0x20] // } 1FF4 5B JUMPDEST 1FF5 80 DUP1 1FF6 35 CALLDATALOAD 1FF7 60 PUSH1 0x01 1FF9 60 PUSH1 0x01 1FFB 60 PUSH1 0xa0 1FFD 1B SHL 1FFE 03 SUB 1FFF 81 DUP2 2000 16 AND 2001 81 DUP2 2002 14 EQ 2003 61 PUSH2 0x200b 2006 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FF6 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x200b, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_2007: // Incoming jump from 0x2006, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @200A memory[0x00:0x00] } 2007 60 PUSH1 0x00 2009 80 DUP1 200A FD *REVERT // Stack delta = +0 // Outputs[1] { @200A revert(memory[0x00:0x00]); } // Block terminates label_200B: // Incoming jump from 0x2118, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x2006, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @200C stack[-3] // @200C stack[-1] // @200D stack[-2] // } 200B 5B JUMPDEST 200C 91 SWAP2 200D 90 SWAP1 200E 50 POP 200F 56 *JUMP // Stack delta = -2 // Outputs[1] { @200C stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2010: // Incoming call from 0x02FF, returns to 0x0300 // Inputs[2] // { // @2016 stack[-1] // @2017 stack[-2] // } 2010 5B JUMPDEST 2011 60 PUSH1 0x00 2013 80 DUP1 2014 60 PUSH1 0x40 2016 83 DUP4 2017 85 DUP6 2018 03 SUB 2019 12 SLT 201A 15 ISZERO 201B 61 PUSH2 0x2023 201E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2011 stack[0] = 0x00 // @2013 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2023, if !(stack[-2] - stack[-1] i< 0x40) label_201F: // Incoming jump from 0x201E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2022 memory[0x00:0x00] } 201F 60 PUSH1 0x00 2021 80 DUP1 2022 FD *REVERT // Stack delta = +0 // Outputs[1] { @2022 revert(memory[0x00:0x00]); } // Block terminates label_2023: // Incoming jump from 0x201E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2027 stack[-3] } 2023 5B JUMPDEST 2024 61 PUSH2 0x202c 2027 83 DUP4 2028 61 PUSH2 0x1ff4 202B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2024 stack[0] = 0x202c // @2027 stack[1] = stack[-3] // } // Block ends with call to 0x1ff4, returns to 0x202C label_202C: // Incoming return from call to 0x1FF4 at 0x202B // Inputs[5] // { // @202D stack[-1] // @202D stack[-6] // @2030 stack[-4] // @2034 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2035 stack[-5] // } 202C 5B JUMPDEST 202D 94 SWAP5 202E 60 PUSH1 0x20 2030 93 SWAP4 2031 90 SWAP1 2032 93 SWAP4 2033 01 ADD 2034 35 CALLDATALOAD 2035 93 SWAP4 2036 50 POP 2037 50 POP 2038 50 POP 2039 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @202D stack[-6] = stack[-1] // @2035 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_203A: // Incoming jump from 0x2069 // Incoming jump from 0x0B12 // Incoming jump from 0x2091 // Inputs[1] { @204F memory[0x00:0x24] } 203A 5B JUMPDEST 203B 63 PUSH4 0x4e487b71 2040 60 PUSH1 0xe0 2042 1B SHL 2043 60 PUSH1 0x00 2045 52 MSTORE 2046 60 PUSH1 0x41 2048 60 PUSH1 0x04 204A 52 MSTORE 204B 60 PUSH1 0x24 204D 60 PUSH1 0x00 204F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2045 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @204A memory[0x04:0x24] = 0x41 // @204F revert(memory[0x00:0x24]); // } // Block terminates label_2050: // Incoming call from 0x210C, returns to 0x1B29 // Incoming call from 0x2274, returns to 0x2275 // Inputs[1] { @205C stack[-2] } 2050 5B JUMPDEST 2051 60 PUSH1 0x00 2053 60 PUSH1 0x01 2055 60 PUSH1 0x01 2057 60 PUSH1 0x40 2059 1B SHL 205A 03 SUB 205B 80 DUP1 205C 84 DUP5 205D 11 GT 205E 15 ISZERO 205F 61 PUSH2 0x206a 2062 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2051 stack[0] = 0x00 // @205A stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x206a, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_2063: // Incoming jump from 0x2062, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 2063 61 PUSH2 0x206a 2066 61 PUSH2 0x203a 2069 56 *JUMP // Stack delta = +1 // Outputs[1] { @2063 stack[0] = 0x206a } // Block ends with unconditional jump to 0x203a label_206A: // Incoming jump from 0x2062, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @206D memory[0x40:0x60] // @2070 stack[-4] // @207F stack[-1] // } 206A 5B JUMPDEST 206B 60 PUSH1 0x40 206D 51 MLOAD 206E 60 PUSH1 0x1f 2070 85 DUP6 2071 01 ADD 2072 60 PUSH1 0x1f 2074 19 NOT 2075 90 SWAP1 2076 81 DUP2 2077 16 AND 2078 60 PUSH1 0x3f 207A 01 ADD 207B 16 AND 207C 81 DUP2 207D 01 ADD 207E 90 SWAP1 207F 82 DUP3 2080 82 DUP3 2081 11 GT 2082 81 DUP2 2083 83 DUP4 2084 10 LT 2085 17 OR 2086 15 ISZERO 2087 61 PUSH2 0x2092 208A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @207E stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @207E stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x2092, 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_208B: // Incoming jump from 0x208A, 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])) 208B 61 PUSH2 0x2092 208E 61 PUSH2 0x203a 2091 56 *JUMP // Stack delta = +1 // Outputs[1] { @208B stack[0] = 0x2092 } // Block ends with unconditional jump to 0x203a label_2092: // Incoming jump from 0x208A, 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] // { // @2093 stack[-2] // @2097 stack[-1] // @2098 stack[-4] // @209A stack[-6] // @209D stack[-7] // @209F stack[-5] // } 2092 5B JUMPDEST 2093 81 DUP2 2094 60 PUSH1 0x40 2096 52 MSTORE 2097 80 DUP1 2098 93 SWAP4 2099 50 POP 209A 85 DUP6 209B 81 DUP2 209C 52 MSTORE 209D 86 DUP7 209E 86 DUP7 209F 86 DUP7 20A0 01 ADD 20A1 11 GT 20A2 15 ISZERO 20A3 61 PUSH2 0x20ab 20A6 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2096 memory[0x40:0x60] = stack[-2] // @2098 stack[-4] = stack[-1] // @209C memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x20ab, if !(stack[-5] + stack[-6] > stack[-7]) label_20A7: // Incoming jump from 0x20A6, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @20AA memory[0x00:0x00] } 20A7 60 PUSH1 0x00 20A9 80 DUP1 20AA FD *REVERT // Stack delta = +0 // Outputs[1] { @20AA revert(memory[0x00:0x00]); } // Block terminates label_20AB: // Incoming jump from 0x20A6, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @20AC stack[-6] // @20AD stack[-5] // @20B0 stack[-1] // @20B2 msg.data[stack[-5]:stack[-5] + stack[-6]] // @20BF stack[-4] // @20BF stack[-8] // @20C0 stack[-7] // } 20AB 5B JUMPDEST 20AC 85 DUP6 20AD 85 DUP6 20AE 60 PUSH1 0x20 20B0 83 DUP4 20B1 01 ADD 20B2 37 CALLDATACOPY 20B3 60 PUSH1 0x00 20B5 60 PUSH1 0x20 20B7 87 DUP8 20B8 83 DUP4 20B9 01 ADD 20BA 01 ADD 20BB 52 MSTORE 20BC 50 POP 20BD 50 POP 20BE 50 POP 20BF 93 SWAP4 20C0 92 SWAP3 20C1 50 POP 20C2 50 POP 20C3 50 POP 20C4 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @20B2 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @20BB memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @20BF stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_20C5: // Incoming call from 0x0345, returns to 0x0346 // Incoming call from 0x045B, returns to 0x045C // Incoming call from 0x0573, returns to 0x0574 // Inputs[2] // { // @20CA stack[-1] // @20CB stack[-2] // } 20C5 5B JUMPDEST 20C6 60 PUSH1 0x00 20C8 60 PUSH1 0x20 20CA 82 DUP3 20CB 84 DUP5 20CC 03 SUB 20CD 12 SLT 20CE 15 ISZERO 20CF 61 PUSH2 0x20d7 20D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20C6 stack[0] = 0x00 } // Block ends with conditional jump to 0x20d7, if !(stack[-2] - stack[-1] i< 0x20) label_20D3: // Incoming jump from 0x20D2, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20D6 memory[0x00:0x00] } 20D3 60 PUSH1 0x00 20D5 80 DUP1 20D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @20D6 revert(memory[0x00:0x00]); } // Block terminates label_20D7: // Incoming jump from 0x20D2, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @20D8 stack[-2] // @20D9 msg.data[stack[-2]:stack[-2] + 0x20] // } 20D7 5B JUMPDEST 20D8 81 DUP2 20D9 35 CALLDATALOAD 20DA 60 PUSH1 0x01 20DC 60 PUSH1 0x01 20DE 60 PUSH1 0x40 20E0 1B SHL 20E1 03 SUB 20E2 81 DUP2 20E3 11 GT 20E4 15 ISZERO 20E5 61 PUSH2 0x20ed 20E8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20D9 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x20ed, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_20E9: // Incoming jump from 0x20E8, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @20EC memory[0x00:0x00] } 20E9 60 PUSH1 0x00 20EB 80 DUP1 20EC FD *REVERT // Stack delta = +0 // Outputs[1] { @20EC revert(memory[0x00:0x00]); } // Block terminates label_20ED: // Incoming jump from 0x20E8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @20EE stack[-3] // @20EF stack[-1] // @20F4 stack[-4] // } 20ED 5B JUMPDEST 20EE 82 DUP3 20EF 01 ADD 20F0 60 PUSH1 0x1f 20F2 81 DUP2 20F3 01 ADD 20F4 84 DUP5 20F5 13 SGT 20F6 61 PUSH2 0x20fe 20F9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20EF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x20fe, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_20FA: // Incoming jump from 0x20F9, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @20FD memory[0x00:0x00] } 20FA 60 PUSH1 0x00 20FC 80 DUP1 20FD FD *REVERT // Stack delta = +0 // Outputs[1] { @20FD revert(memory[0x00:0x00]); } // Block terminates label_20FE: // Incoming jump from 0x20F9, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2102 stack[-4] // @2103 stack[-1] // @2104 msg.data[stack[-1]:stack[-1] + 0x20] // } 20FE 5B JUMPDEST 20FF 61 PUSH2 0x1b29 2102 84 DUP5 2103 82 DUP3 2104 35 CALLDATALOAD 2105 60 PUSH1 0x20 2107 84 DUP5 2108 01 ADD 2109 61 PUSH2 0x2050 210C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @20FF stack[0] = 0x1b29 // @2102 stack[1] = stack[-4] // @2104 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2108 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2050, returns to 0x1B29 label_210D: // Incoming call from 0x21FC, returns to 0x21FD // Incoming call from 0x2137, returns to 0x1236 // Inputs[2] // { // @210E stack[-1] // @210F msg.data[stack[-1]:stack[-1] + 0x20] // } 210D 5B JUMPDEST 210E 80 DUP1 210F 35 CALLDATALOAD 2110 80 DUP1 2111 15 ISZERO 2112 15 ISZERO 2113 81 DUP2 2114 14 EQ 2115 61 PUSH2 0x200b 2118 57 *JUMPI // Stack delta = +1 // Outputs[1] { @210F stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x200b, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_2119: // Incoming jump from 0x2118, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @211C memory[0x00:0x00] } 2119 60 PUSH1 0x00 211B 80 DUP1 211C FD *REVERT // Stack delta = +0 // Outputs[1] { @211C revert(memory[0x00:0x00]); } // Block terminates label_211D: // Incoming call from 0x0644, returns to 0x0645 // Incoming call from 0x06FD, returns to 0x06FE // Incoming call from 0x0365, returns to 0x0366 // Inputs[2] // { // @2122 stack[-1] // @2123 stack[-2] // } 211D 5B JUMPDEST 211E 60 PUSH1 0x00 2120 60 PUSH1 0x20 2122 82 DUP3 2123 84 DUP5 2124 03 SUB 2125 12 SLT 2126 15 ISZERO 2127 61 PUSH2 0x212f 212A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @211E stack[0] = 0x00 } // Block ends with conditional jump to 0x212f, if !(stack[-2] - stack[-1] i< 0x20) label_212B: // Incoming jump from 0x212A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @212E memory[0x00:0x00] } 212B 60 PUSH1 0x00 212D 80 DUP1 212E FD *REVERT // Stack delta = +0 // Outputs[1] { @212E revert(memory[0x00:0x00]); } // Block terminates label_212F: // Incoming jump from 0x212A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2133 stack[-2] } 212F 5B JUMPDEST 2130 61 PUSH2 0x1236 2133 82 DUP3 2134 61 PUSH2 0x210d 2137 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2130 stack[0] = 0x1236 // @2133 stack[1] = stack[-2] // } // Block ends with call to 0x210d, returns to 0x1236 label_2138: // Incoming call from 0x03EE, returns to 0x03EF // Incoming call from 0x03A3, returns to 0x03A4 // Inputs[2] // { // @2140 stack[-1] // @2141 stack[-2] // } 2138 5B JUMPDEST 2139 60 PUSH1 0x00 213B 80 DUP1 213C 60 PUSH1 0x00 213E 60 PUSH1 0x60 2140 84 DUP5 2141 86 DUP7 2142 03 SUB 2143 12 SLT 2144 15 ISZERO 2145 61 PUSH2 0x214d 2148 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2139 stack[0] = 0x00 // @213B stack[1] = 0x00 // @213C stack[2] = 0x00 // } // Block ends with conditional jump to 0x214d, if !(stack[-2] - stack[-1] i< 0x60) label_2149: // Incoming jump from 0x2148, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @214C memory[0x00:0x00] } 2149 60 PUSH1 0x00 214B 80 DUP1 214C FD *REVERT // Stack delta = +0 // Outputs[1] { @214C revert(memory[0x00:0x00]); } // Block terminates label_214D: // Incoming jump from 0x2148, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2151 stack[-4] } 214D 5B JUMPDEST 214E 61 PUSH2 0x2156 2151 84 DUP5 2152 61 PUSH2 0x1ff4 2155 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @214E stack[0] = 0x2156 // @2151 stack[1] = stack[-4] // } // Block ends with call to 0x1ff4, returns to 0x2156 label_2156: // Incoming return from call to 0x1FF4 at 0x2155 // Inputs[3] // { // @2157 stack[-4] // @2157 stack[-1] // @215E stack[-5] // } 2156 5B JUMPDEST 2157 92 SWAP3 2158 50 POP 2159 61 PUSH2 0x2164 215C 60 PUSH1 0x20 215E 85 DUP6 215F 01 ADD 2160 61 PUSH2 0x1ff4 2163 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2157 stack[-4] = stack[-1] // @2159 stack[-1] = 0x2164 // @215F stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1ff4, returns to 0x2164 label_2164: // Incoming return from call to 0x1FF4 at 0x2163 // Inputs[8] // { // @2165 stack[-1] // @2165 stack[-3] // @2169 stack[-5] // @216B msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @216C stack[-2] // @2170 stack[-6] // @2172 stack[-4] // @2172 stack[-7] // } 2164 5B JUMPDEST 2165 91 SWAP2 2166 50 POP 2167 60 PUSH1 0x40 2169 84 DUP5 216A 01 ADD 216B 35 CALLDATALOAD 216C 90 SWAP1 216D 50 POP 216E 92 SWAP3 216F 50 POP 2170 92 SWAP3 2171 50 POP 2172 92 SWAP3 2173 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @216E stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2170 stack[-6] = stack[-1] // @2172 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2174: // Incoming call from 0x040E, returns to 0x040F // Incoming call from 0x0786, returns to 0x0787 // Incoming call from 0x051E, returns to 0x051F // Incoming call from 0x06CD, returns to 0x06CE // Inputs[2] // { // @2179 stack[-1] // @217A stack[-2] // } 2174 5B JUMPDEST 2175 60 PUSH1 0x00 2177 60 PUSH1 0x20 2179 82 DUP3 217A 84 DUP5 217B 03 SUB 217C 12 SLT 217D 15 ISZERO 217E 61 PUSH2 0x2186 2181 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2175 stack[0] = 0x00 } // Block ends with conditional jump to 0x2186, if !(stack[-2] - stack[-1] i< 0x20) label_2182: // Incoming jump from 0x2181, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2185 memory[0x00:0x00] } 2182 60 PUSH1 0x00 2184 80 DUP1 2185 FD *REVERT // Stack delta = +0 // Outputs[1] { @2185 revert(memory[0x00:0x00]); } // Block terminates label_2186: // Incoming jump from 0x2181, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @218A stack[-2] } 2186 5B JUMPDEST 2187 61 PUSH2 0x1236 218A 82 DUP3 218B 61 PUSH2 0x1ff4 218E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2187 stack[0] = 0x1236 // @218A stack[1] = stack[-2] // } // Block ends with call to 0x1ff4, returns to 0x1236 label_218F: // Incoming call from 0x0420, returns to 0x0282 // Inputs[3] // { // @2193 stack[-1] // @2195 stack[-2] // @2196 memory[stack[-2]:stack[-2] + 0x20] // } 218F 5B JUMPDEST 2190 60 PUSH1 0x20 2192 80 DUP1 2193 82 DUP3 2194 52 MSTORE 2195 82 DUP3 2196 51 MLOAD 2197 82 DUP3 2198 82 DUP3 2199 01 ADD 219A 81 DUP2 219B 90 SWAP1 219C 52 MSTORE 219D 60 PUSH1 0x00 219F 91 SWAP2 21A0 90 SWAP1 21A1 84 DUP5 21A2 82 DUP3 21A3 01 ADD 21A4 90 SWAP1 21A5 60 PUSH1 0x40 21A7 85 DUP6 21A8 01 ADD 21A9 90 SWAP1 21AA 84 DUP5 21AB 5B JUMPDEST 21AC 81 DUP2 21AD 81 DUP2 21AE 10 LT 21AF 15 ISZERO 21B0 61 PUSH2 0x21c7 21B3 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @2194 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @219C memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @219F stack[0] = 0x00 // @21A0 stack[1] = 0x20 // @21A4 stack[2] = 0x20 + stack[-2] // @21A9 stack[3] = stack[-1] + 0x40 // @21A9 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @21AA stack[5] = 0x00 // } // Block ends with conditional jump to 0x21c7, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_21B4: // Incoming jump from 0x21B3, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x21B3, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @21B4 stack[-4] // @21B5 memory[stack[-4]:stack[-4] + 0x20] // @21B6 stack[-3] // @21B8 stack[-1] // @21B9 stack[-5] // } 21B4 83 DUP4 21B5 51 MLOAD 21B6 83 DUP4 21B7 52 MSTORE 21B8 92 SWAP3 21B9 84 DUP5 21BA 01 ADD 21BB 92 SWAP3 21BC 91 SWAP2 21BD 84 DUP5 21BE 01 ADD 21BF 91 SWAP2 21C0 60 PUSH1 0x01 21C2 01 ADD 21C3 61 PUSH2 0x21ab 21C6 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @21B7 memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @21BB stack[-4] = stack[-5] + stack[-4] // @21BF stack[-3] = stack[-5] + stack[-3] // @21C2 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x21ab label_21C7: // Incoming jump from 0x21B3, if !(stack[-1] < stack[-2]) // Incoming jump from 0x21B3, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @21C9 stack[-3] // @21C9 stack[-2] // @21CA stack[-9] // @21CB stack[-8] // } 21C7 5B JUMPDEST 21C8 50 POP 21C9 90 SWAP1 21CA 96 SWAP7 21CB 95 SWAP6 21CC 50 POP 21CD 50 POP 21CE 50 POP 21CF 50 POP 21D0 50 POP 21D1 50 POP 21D2 56 *JUMP // Stack delta = -8 // Outputs[1] { @21CA stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] label_21D3: // Incoming jump from 0x05EF // Inputs[2] // { // @21D9 stack[-1] // @21DA stack[-2] // } 21D3 5B JUMPDEST 21D4 60 PUSH1 0x00 21D6 80 DUP1 21D7 60 PUSH1 0x40 21D9 83 DUP4 21DA 85 DUP6 21DB 03 SUB 21DC 12 SLT 21DD 15 ISZERO 21DE 61 PUSH2 0x21e6 21E1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21D4 stack[0] = 0x00 // @21D6 stack[1] = 0x00 // } // Block ends with conditional jump to 0x21e6, if !(stack[-2] - stack[-1] i< 0x40) label_21E2: // Incoming jump from 0x21E1, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @21E5 memory[0x00:0x00] } 21E2 60 PUSH1 0x00 21E4 80 DUP1 21E5 FD *REVERT // Stack delta = +0 // Outputs[1] { @21E5 revert(memory[0x00:0x00]); } // Block terminates label_21E6: // Incoming jump from 0x21E1, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @21EA stack[-3] } 21E6 5B JUMPDEST 21E7 61 PUSH2 0x21ef 21EA 83 DUP4 21EB 61 PUSH2 0x1ff4 21EE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21E7 stack[0] = 0x21ef // @21EA stack[1] = stack[-3] // } // Block ends with call to 0x1ff4, returns to 0x21EF label_21EF: // Incoming return from call to 0x1FF4 at 0x21EE // Inputs[3] // { // @21F0 stack[-1] // @21F0 stack[-3] // @21F7 stack[-4] // } 21EF 5B JUMPDEST 21F0 91 SWAP2 21F1 50 POP 21F2 61 PUSH2 0x21fd 21F5 60 PUSH1 0x20 21F7 84 DUP5 21F8 01 ADD 21F9 61 PUSH2 0x210d 21FC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @21F0 stack[-3] = stack[-1] // @21F2 stack[-1] = 0x21fd // @21F8 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x210d, returns to 0x21FD label_21FD: // Incoming return from call to 0x1FF4 at 0x2328 // Incoming return from call to 0x1FF4 at 0x234B // Incoming return from call to 0x210D at 0x21FC // Inputs[6] // { // @21FE stack[-2] // @21FE stack[-1] // @2200 stack[-5] // @2202 stack[-6] // @2202 stack[-3] // @2203 stack[-4] // } 21FD 5B JUMPDEST 21FE 90 SWAP1 21FF 50 POP 2200 92 SWAP3 2201 50 POP 2202 92 SWAP3 2203 90 SWAP1 2204 50 POP 2205 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2200 stack[-5] = stack[-1] // @2202 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2206: // Incoming call from 0x0664, returns to 0x0665 // Inputs[2] // { // @220F stack[-1] // @2210 stack[-2] // } 2206 5B JUMPDEST 2207 60 PUSH1 0x00 2209 80 DUP1 220A 60 PUSH1 0x00 220C 80 DUP1 220D 60 PUSH1 0x80 220F 85 DUP6 2210 87 DUP8 2211 03 SUB 2212 12 SLT 2213 15 ISZERO 2214 61 PUSH2 0x221c 2217 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2207 stack[0] = 0x00 // @2209 stack[1] = 0x00 // @220A stack[2] = 0x00 // @220C stack[3] = 0x00 // } // Block ends with conditional jump to 0x221c, if !(stack[-2] - stack[-1] i< 0x80) label_2218: // Incoming jump from 0x2217, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @221B memory[0x00:0x00] } 2218 60 PUSH1 0x00 221A 80 DUP1 221B FD *REVERT // Stack delta = +0 // Outputs[1] { @221B revert(memory[0x00:0x00]); } // Block terminates label_221C: // Incoming jump from 0x2217, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2220 stack[-5] } 221C 5B JUMPDEST 221D 61 PUSH2 0x2225 2220 85 DUP6 2221 61 PUSH2 0x1ff4 2224 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @221D stack[0] = 0x2225 // @2220 stack[1] = stack[-5] // } // Block ends with call to 0x1ff4, returns to 0x2225 label_2225: // Incoming return from call to 0x1FF4 at 0x2224 // Inputs[3] // { // @2226 stack[-1] // @2226 stack[-5] // @222D stack[-6] // } 2225 5B JUMPDEST 2226 93 SWAP4 2227 50 POP 2228 61 PUSH2 0x2233 222B 60 PUSH1 0x20 222D 86 DUP7 222E 01 ADD 222F 61 PUSH2 0x1ff4 2232 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2226 stack[-5] = stack[-1] // @2228 stack[-1] = 0x2233 // @222E stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1ff4, returns to 0x2233 label_2233: // Incoming return from call to 0x1FF4 at 0x2232 // Inputs[6] // { // @2234 stack[-1] // @2234 stack[-4] // @2238 stack[-6] // @223A msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @223B stack[-3] // @2241 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2233 5B JUMPDEST 2234 92 SWAP3 2235 50 POP 2236 60 PUSH1 0x40 2238 85 DUP6 2239 01 ADD 223A 35 CALLDATALOAD 223B 91 SWAP2 223C 50 POP 223D 60 PUSH1 0x60 223F 85 DUP6 2240 01 ADD 2241 35 CALLDATALOAD 2242 60 PUSH1 0x01 2244 60 PUSH1 0x01 2246 60 PUSH1 0x40 2248 1B SHL 2249 03 SUB 224A 81 DUP2 224B 11 GT 224C 15 ISZERO 224D 61 PUSH2 0x2255 2250 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2234 stack[-4] = stack[-1] // @223B stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2241 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2255, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) label_2251: // Incoming jump from 0x2250, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2254 memory[0x00:0x00] } 2251 60 PUSH1 0x00 2253 80 DUP1 2254 FD *REVERT // Stack delta = +0 // Outputs[1] { @2254 revert(memory[0x00:0x00]); } // Block terminates label_2255: // Incoming jump from 0x2250, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2256 stack[-6] // @2257 stack[-1] // @225C stack[-7] // } 2255 5B JUMPDEST 2256 85 DUP6 2257 01 ADD 2258 60 PUSH1 0x1f 225A 81 DUP2 225B 01 ADD 225C 87 DUP8 225D 13 SGT 225E 61 PUSH2 0x2266 2261 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2257 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x2266, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_2262: // Incoming jump from 0x2261, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @2265 memory[0x00:0x00] } 2262 60 PUSH1 0x00 2264 80 DUP1 2265 FD *REVERT // Stack delta = +0 // Outputs[1] { @2265 revert(memory[0x00:0x00]); } // Block terminates label_2266: // Incoming jump from 0x2261, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @226A stack[-7] // @226B stack[-1] // @226C msg.data[stack[-1]:stack[-1] + 0x20] // } 2266 5B JUMPDEST 2267 61 PUSH2 0x2275 226A 87 DUP8 226B 82 DUP3 226C 35 CALLDATALOAD 226D 60 PUSH1 0x20 226F 84 DUP5 2270 01 ADD 2271 61 PUSH2 0x2050 2274 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2267 stack[0] = 0x2275 // @226A stack[1] = stack[-7] // @226C stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2270 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2050, returns to 0x2275 label_2275: // Incoming return from call to 0x2050 at 0x2274 // Inputs[8] // { // @2276 stack[-3] // @2276 stack[-1] // @2279 stack[-6] // @227A stack[-9] // @227B stack[-5] // @227C stack[-8] // @227E stack[-7] // @227E stack[-4] // } 2275 5B JUMPDEST 2276 91 SWAP2 2277 50 POP 2278 50 POP 2279 92 SWAP3 227A 95 SWAP6 227B 91 SWAP2 227C 94 SWAP5 227D 50 POP 227E 92 SWAP3 227F 50 POP 2280 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2279 stack[-6] = stack[-1] // @227A stack[-9] = stack[-6] // @227C stack[-8] = stack[-5] // @227E stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2281: // Incoming call from 0x0697, returns to 0x0698 // Inputs[2] // { // @2289 stack[-1] // @228A stack[-2] // } 2281 5B JUMPDEST 2282 60 PUSH1 0x00 2284 80 DUP1 2285 60 PUSH1 0x00 2287 60 PUSH1 0x40 2289 84 DUP5 228A 86 DUP7 228B 03 SUB 228C 12 SLT 228D 15 ISZERO 228E 61 PUSH2 0x2296 2291 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2282 stack[0] = 0x00 // @2284 stack[1] = 0x00 // @2285 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2296, if !(stack[-2] - stack[-1] i< 0x40) label_2292: // Incoming jump from 0x2291, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2295 memory[0x00:0x00] } 2292 60 PUSH1 0x00 2294 80 DUP1 2295 FD *REVERT // Stack delta = +0 // Outputs[1] { @2295 revert(memory[0x00:0x00]); } // Block terminates label_2296: // Incoming jump from 0x2291, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @2297 stack[-4] // @2298 msg.data[stack[-4]:stack[-4] + 0x20] // @2299 stack[-3] // @229F msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2296 5B JUMPDEST 2297 83 DUP4 2298 35 CALLDATALOAD 2299 92 SWAP3 229A 50 POP 229B 60 PUSH1 0x20 229D 84 DUP5 229E 01 ADD 229F 35 CALLDATALOAD 22A0 60 PUSH1 0x01 22A2 60 PUSH1 0x01 22A4 60 PUSH1 0x40 22A6 1B SHL 22A7 03 SUB 22A8 80 DUP1 22A9 82 DUP3 22AA 11 GT 22AB 15 ISZERO 22AC 61 PUSH2 0x22b4 22AF 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2299 stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @229F stack[0] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @22A7 stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x22b4, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) label_22B0: // Incoming jump from 0x22AF, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @22B3 memory[0x00:0x00] } 22B0 60 PUSH1 0x00 22B2 80 DUP1 22B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @22B3 revert(memory[0x00:0x00]); } // Block terminates label_22B4: // Incoming jump from 0x22AF, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @22B5 stack[-2] // @22B6 stack[-6] // @22BA stack[-7] // } 22B4 5B JUMPDEST 22B5 81 DUP2 22B6 86 DUP7 22B7 01 ADD 22B8 91 SWAP2 22B9 50 POP 22BA 86 DUP7 22BB 60 PUSH1 0x1f 22BD 83 DUP4 22BE 01 ADD 22BF 12 SLT 22C0 61 PUSH2 0x22c8 22C3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22B8 stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x22c8, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_22C4: // Incoming jump from 0x22C3, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @22C7 memory[0x00:0x00] } 22C4 60 PUSH1 0x00 22C6 80 DUP1 22C7 FD *REVERT // Stack delta = +0 // Outputs[1] { @22C7 revert(memory[0x00:0x00]); } // Block terminates label_22C8: // Incoming jump from 0x22C3, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @22C9 stack[-2] // @22CA msg.data[stack[-2]:stack[-2] + 0x20] // @22CB stack[-1] // } 22C8 5B JUMPDEST 22C9 81 DUP2 22CA 35 CALLDATALOAD 22CB 81 DUP2 22CC 81 DUP2 22CD 11 GT 22CE 15 ISZERO 22CF 61 PUSH2 0x22d7 22D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22CA stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x22d7, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_22D3: // Incoming jump from 0x22D2, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @22D6 memory[0x00:0x00] } 22D3 60 PUSH1 0x00 22D5 80 DUP1 22D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @22D6 revert(memory[0x00:0x00]); } // Block terminates label_22D7: // Incoming jump from 0x22D2, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @22D8 stack[-8] // @22DB stack[-1] // @22DF stack[-3] // } 22D7 5B JUMPDEST 22D8 87 DUP8 22D9 60 PUSH1 0x20 22DB 82 DUP3 22DC 60 PUSH1 0x05 22DE 1B SHL 22DF 85 DUP6 22E0 01 ADD 22E1 01 ADD 22E2 11 GT 22E3 15 ISZERO 22E4 61 PUSH2 0x22ec 22E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x22ec, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) label_22E8: // Incoming jump from 0x22E7, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[1] { @22EB memory[0x00:0x00] } 22E8 60 PUSH1 0x00 22EA 80 DUP1 22EB FD *REVERT // Stack delta = +0 // Outputs[1] { @22EB revert(memory[0x00:0x00]); } // Block terminates label_22EC: // Incoming jump from 0x22E7, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-8]) // Inputs[8] // { // @22EF stack[-3] // @22F1 stack[-5] // @22F3 stack[-1] // @22F4 stack[-4] // @22F9 stack[-7] // @22FB stack[-8] // @22FD stack[-6] // @22FD stack[-9] // } 22EC 5B JUMPDEST 22ED 60 PUSH1 0x20 22EF 83 DUP4 22F0 01 ADD 22F1 94 SWAP5 22F2 50 POP 22F3 80 DUP1 22F4 93 SWAP4 22F5 50 POP 22F6 50 POP 22F7 50 POP 22F8 50 POP 22F9 92 SWAP3 22FA 50 POP 22FB 92 SWAP3 22FC 50 POP 22FD 92 SWAP3 22FE 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @22F9 stack[-7] = stack[-1] // @22FB stack[-8] = stack[-3] + 0x20 // @22FD stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-9] label_22FF: // Incoming jump from 0x071D // Inputs[2] // { // @2305 stack[-1] // @2306 stack[-2] // } 22FF 5B JUMPDEST 2300 60 PUSH1 0x00 2302 80 DUP1 2303 60 PUSH1 0x40 2305 83 DUP4 2306 85 DUP6 2307 03 SUB 2308 12 SLT 2309 15 ISZERO 230A 61 PUSH2 0x2312 230D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2300 stack[0] = 0x00 // @2302 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2312, if !(stack[-2] - stack[-1] i< 0x40) label_230E: // Incoming jump from 0x230D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2311 memory[0x00:0x00] } 230E 60 PUSH1 0x00 2310 80 DUP1 2311 FD *REVERT // Stack delta = +0 // Outputs[1] { @2311 revert(memory[0x00:0x00]); } // Block terminates label_2312: // Incoming jump from 0x230D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2316 stack[-3] } 2312 5B JUMPDEST 2313 61 PUSH2 0x231b 2316 83 DUP4 2317 61 PUSH2 0x1ff4 231A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2313 stack[0] = 0x231b // @2316 stack[1] = stack[-3] // } // Block ends with call to 0x1ff4, returns to 0x231B label_231B: // Incoming return from call to 0x1FF4 at 0x231A // Inputs[3] // { // @231C stack[-3] // @231C stack[-1] // @2323 stack[-4] // } 231B 5B JUMPDEST 231C 91 SWAP2 231D 50 POP 231E 61 PUSH2 0x21fd 2321 60 PUSH1 0x20 2323 84 DUP5 2324 01 ADD 2325 61 PUSH2 0x1ff4 2328 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @231C stack[-3] = stack[-1] // @231E stack[-1] = 0x21fd // @2324 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1ff4, returns to 0x21FD label_2329: // Incoming call from 0x0766, returns to 0x0767 // Inputs[2] // { // @232F stack[-1] // @2330 stack[-2] // } 2329 5B JUMPDEST 232A 60 PUSH1 0x00 232C 80 DUP1 232D 60 PUSH1 0x40 232F 83 DUP4 2330 85 DUP6 2331 03 SUB 2332 12 SLT 2333 15 ISZERO 2334 61 PUSH2 0x233c 2337 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @232A stack[0] = 0x00 // @232C stack[1] = 0x00 // } // Block ends with conditional jump to 0x233c, if !(stack[-2] - stack[-1] i< 0x40) label_2338: // Incoming jump from 0x2337, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @233B memory[0x00:0x00] } 2338 60 PUSH1 0x00 233A 80 DUP1 233B FD *REVERT // Stack delta = +0 // Outputs[1] { @233B revert(memory[0x00:0x00]); } // Block terminates label_233C: // Incoming jump from 0x2337, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @233D stack[-3] // @233E msg.data[stack[-3]:stack[-3] + 0x20] // @233F stack[-2] // } 233C 5B JUMPDEST 233D 82 DUP3 233E 35 CALLDATALOAD 233F 91 SWAP2 2340 50 POP 2341 61 PUSH2 0x21fd 2344 60 PUSH1 0x20 2346 84 DUP5 2347 01 ADD 2348 61 PUSH2 0x1ff4 234B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @233F stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @2341 stack[0] = 0x21fd // @2347 stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x1ff4, returns to 0x21FD label_234C: // Incoming call from 0x1B3F, returns to 0x07ED // Incoming call from 0x0D37, returns to 0x0CAA // Incoming call from 0x0818, returns to 0x0819 // Incoming call from 0x1184, returns to 0x1185 // Incoming call from 0x1158, returns to 0x1159 // Incoming call from 0x0E48, returns to 0x07ED // Incoming call from 0x0CA9, returns to 0x0CAA // Incoming call from 0x0CD5, returns to 0x0CD6 // Incoming call from 0x1EAF, returns to 0x1EB0 // Incoming call from 0x07EC, returns to 0x07ED // Incoming call from 0x1008, returns to 0x0CAA // Inputs[1] { @234F stack[-1] } 234C 5B JUMPDEST 234D 60 PUSH1 0x01 234F 81 DUP2 2350 81 DUP2 2351 1C SHR 2352 90 SWAP1 2353 82 DUP3 2354 16 AND 2355 80 DUP1 2356 61 PUSH2 0x2360 2359 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2352 stack[0] = stack[-1] >> 0x01 // @2354 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2360, if stack[-1] & 0x01 label_235A: // Incoming jump from 0x2359, if not stack[-1] & 0x01 // Inputs[2] // { // @235C stack[-2] // @2365 stack[-1] // } 235A 60 PUSH1 0x7f 235C 82 DUP3 235D 16 AND 235E 91 SWAP2 235F 50 POP 2360 5B JUMPDEST 2361 60 PUSH1 0x20 2363 82 DUP3 2364 10 LT 2365 81 DUP2 2366 14 EQ 2367 15 ISZERO 2368 61 PUSH2 0x2381 236B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @235E stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2381, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_236C: // Incoming jump from 0x236B, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x236B, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @2380 memory[0x00:0x24] } 236C 63 PUSH4 0x4e487b71 2371 60 PUSH1 0xe0 2373 1B SHL 2374 60 PUSH1 0x00 2376 52 MSTORE 2377 60 PUSH1 0x22 2379 60 PUSH1 0x04 237B 52 MSTORE 237C 60 PUSH1 0x24 237E 60 PUSH1 0x00 2380 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2376 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @237B memory[0x04:0x24] = 0x22 // @2380 revert(memory[0x00:0x24]); // } // Block terminates label_2381: // Incoming jump from 0x236B, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x236B, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @2383 stack[-4] // @2383 stack[-2] // @2384 stack[-3] // } 2381 5B JUMPDEST 2382 50 POP 2383 91 SWAP2 2384 90 SWAP1 2385 50 POP 2386 56 *JUMP // Stack delta = -3 // Outputs[1] { @2383 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2387: // Incoming call from 0x0DF7, returns to 0x096C // Incoming call from 0x09B5, returns to 0x096C // Incoming call from 0x096B, returns to 0x096C // Incoming call from 0x0DC1, returns to 0x096C // Incoming call from 0x15B1, returns to 0x096C // Incoming call from 0x1061, returns to 0x096C // Incoming call from 0x0E26, returns to 0x096C // Incoming call from 0x0C5A, returns to 0x096C // Incoming call from 0x1032, returns to 0x096C // Incoming call from 0x157D, returns to 0x096C // Incoming call from 0x0C89, returns to 0x096C // Incoming call from 0x09FD, returns to 0x096C // Incoming call from 0x14CB, returns to 0x096C // Inputs[2] // { // @238B stack[-1] // @23BA stack[-2] // } 2387 5B JUMPDEST 2388 60 PUSH1 0x20 238A 80 DUP1 238B 82 DUP3 238C 52 MSTORE 238D 81 DUP2 238E 81 DUP2 238F 01 ADD 2390 52 MSTORE 2391 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 23B2 60 PUSH1 0x40 23B4 82 DUP3 23B5 01 ADD 23B6 52 MSTORE 23B7 60 PUSH1 0x60 23B9 01 ADD 23BA 90 SWAP1 23BB 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @238C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2390 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @23B6 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @23BA stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_23BC: // Incoming jump from 0x1C81 // Incoming jump from 0x0BF9 // Inputs[1] { @23D1 memory[0x00:0x24] } 23BC 5B JUMPDEST 23BD 63 PUSH4 0x4e487b71 23C2 60 PUSH1 0xe0 23C4 1B SHL 23C5 60 PUSH1 0x00 23C7 52 MSTORE 23C8 60 PUSH1 0x32 23CA 60 PUSH1 0x04 23CC 52 MSTORE 23CD 60 PUSH1 0x24 23CF 60 PUSH1 0x00 23D1 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @23C7 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @23CC memory[0x04:0x24] = 0x32 // @23D1 revert(memory[0x00:0x24]); // } // Block terminates label_23D2: // Incoming jump from 0x23FB // Incoming jump from 0x2443 // Incoming jump from 0x2490 // Inputs[1] { @23E7 memory[0x00:0x24] } 23D2 5B JUMPDEST 23D3 63 PUSH4 0x4e487b71 23D8 60 PUSH1 0xe0 23DA 1B SHL 23DB 60 PUSH1 0x00 23DD 52 MSTORE 23DE 60 PUSH1 0x11 23E0 60 PUSH1 0x04 23E2 52 MSTORE 23E3 60 PUSH1 0x24 23E5 60 PUSH1 0x00 23E7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @23DD memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @23E2 memory[0x04:0x24] = 0x11 // @23E7 revert(memory[0x00:0x24]); // } // Block terminates label_23E8: // Incoming call from 0x0C0E, returns to 0x0C0F // Incoming call from 0x0C1C, returns to 0x0C1D // Incoming call from 0x1CC3, returns to 0x1CC4 // Incoming call from 0x1CC3, returns to 0x1CC4 // Inputs[1] { @23EE stack[-1] } 23E8 5B JUMPDEST 23E9 60 PUSH1 0x00 23EB 60 PUSH1 0x00 23ED 19 NOT 23EE 82 DUP3 23EF 14 EQ 23F0 15 ISZERO 23F1 61 PUSH2 0x23fc 23F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23E9 stack[0] = 0x00 } // Block ends with conditional jump to 0x23fc, if !(stack[-1] == ~0x00) label_23F5: // Incoming jump from 0x23F4, if not !(stack[-1] == ~0x00) 23F5 61 PUSH2 0x23fc 23F8 61 PUSH2 0x23d2 23FB 56 *JUMP // Stack delta = +1 // Outputs[1] { @23F5 stack[0] = 0x23fc } // Block ends with unconditional jump to 0x23d2 label_23FC: // Incoming jump from 0x23F4, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2400 stack[-2] // @2401 stack[-3] // } 23FC 5B JUMPDEST 23FD 50 POP 23FE 60 PUSH1 0x01 2400 01 ADD 2401 90 SWAP1 2402 56 *JUMP // Stack delta = -2 // Outputs[1] { @2401 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2403: // Incoming call from 0x0E77, returns to 0x096C // Incoming call from 0x126B, returns to 0x096C // Incoming call from 0x1516, returns to 0x096C // Inputs[2] // { // @2407 stack[-1] // @242F stack[-2] // } 2403 5B JUMPDEST 2404 60 PUSH1 0x20 2406 80 DUP1 2407 82 DUP3 2408 52 MSTORE 2409 60 PUSH1 0x14 240B 90 SWAP1 240C 82 DUP3 240D 01 ADD 240E 52 MSTORE 240F 73 PUSH20 0x496e76616c6964206d696e7420616d6f756e7421 2424 60 PUSH1 0x60 2426 1B SHL 2427 60 PUSH1 0x40 2429 82 DUP3 242A 01 ADD 242B 52 MSTORE 242C 60 PUSH1 0x60 242E 01 ADD 242F 90 SWAP1 2430 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2408 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @240E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x14 // @242B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x496e76616c6964206d696e7420616d6f756e7421 << 0x60 // @242F stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2431: // Incoming call from 0x128A, returns to 0x128B // Incoming call from 0x0E96, returns to 0x0E97 // Incoming call from 0x1535, returns to 0x1536 // Inputs[2] // { // @2434 stack[-2] // @2436 stack[-1] // } 2431 5B JUMPDEST 2432 60 PUSH1 0x00 2434 82 DUP3 2435 19 NOT 2436 82 DUP3 2437 11 GT 2438 15 ISZERO 2439 61 PUSH2 0x2444 243C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2432 stack[0] = 0x00 } // Block ends with conditional jump to 0x2444, if !(stack[-1] > ~stack[-2]) label_243D: // Incoming jump from 0x243C, if not !(stack[-1] > ~stack[-2]) 243D 61 PUSH2 0x2444 2440 61 PUSH2 0x23d2 2443 56 *JUMP // Stack delta = +1 // Outputs[1] { @243D stack[0] = 0x2444 } // Block ends with unconditional jump to 0x23d2 label_2444: // Incoming jump from 0x243C, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2446 stack[-2] // @2446 stack[-3] // @2447 stack[-4] // } 2444 5B JUMPDEST 2445 50 POP 2446 01 ADD 2447 90 SWAP1 2448 56 *JUMP // Stack delta = -3 // Outputs[1] { @2447 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2449: // Incoming call from 0x0EB4, returns to 0x096C // Incoming call from 0x12A8, returns to 0x096C // Incoming call from 0x1553, returns to 0x096C // Inputs[2] // { // @244D stack[-1] // @2475 stack[-2] // } 2449 5B JUMPDEST 244A 60 PUSH1 0x20 244C 80 DUP1 244D 82 DUP3 244E 52 MSTORE 244F 60 PUSH1 0x14 2451 90 SWAP1 2452 82 DUP3 2453 01 ADD 2454 52 MSTORE 2455 73 PUSH20 0x4d617820737570706c7920657863656564656421 246A 60 PUSH1 0x60 246C 1B SHL 246D 60 PUSH1 0x40 246F 82 DUP3 2470 01 ADD 2471 52 MSTORE 2472 60 PUSH1 0x60 2474 01 ADD 2475 90 SWAP1 2476 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @244E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2454 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x14 // @2471 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4d617820737570706c7920657863656564656421 << 0x60 // @2475 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2477: // Incoming call from 0x12B7, returns to 0x12B8 // Incoming call from 0x0EC3, returns to 0x0EC4 // Inputs[2] // { // @247A stack[-1] // @247F stack[-2] // } 2477 5B JUMPDEST 2478 60 PUSH1 0x00 247A 81 DUP2 247B 60 PUSH1 0x00 247D 19 NOT 247E 04 DIV 247F 83 DUP4 2480 11 GT 2481 82 DUP3 2482 15 ISZERO 2483 15 ISZERO 2484 16 AND 2485 15 ISZERO 2486 61 PUSH2 0x2491 2489 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2478 stack[0] = 0x00 } // Block ends with conditional jump to 0x2491, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_248A: // Incoming jump from 0x2489, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 248A 61 PUSH2 0x2491 248D 61 PUSH2 0x23d2 2490 56 *JUMP // Stack delta = +1 // Outputs[1] { @248A stack[0] = 0x2491 } // Block ends with unconditional jump to 0x23d2 label_2491: // Incoming jump from 0x2489, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2493 stack[-3] // @2493 stack[-2] // @2494 stack[-4] // } 2491 5B JUMPDEST 2492 50 POP 2493 02 MUL 2494 90 SWAP1 2495 56 *JUMP // Stack delta = -3 // Outputs[1] { @2494 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] 2496 5B JUMPDEST 2497 60 PUSH1 0x00 2499 84 DUP5 249A 51 MLOAD 249B 60 PUSH1 0x20 249D 61 PUSH2 0x24a9 24A0 82 DUP3 24A1 85 DUP6 24A2 83 DUP4 24A3 8A DUP11 24A4 01 ADD 24A5 61 PUSH2 0x1f70 24A8 56 *JUMP 24A9 5B JUMPDEST 24AA 85 DUP6 24AB 51 MLOAD 24AC 91 SWAP2 24AD 84 DUP5 24AE 01 ADD 24AF 91 SWAP2 24B0 61 PUSH2 0x24bc 24B3 81 DUP2 24B4 84 DUP5 24B5 84 DUP5 24B6 8A DUP11 24B7 01 ADD 24B8 61 PUSH2 0x1f70 24BB 56 *JUMP 24BC 5B JUMPDEST 24BD 85 DUP6 24BE 54 SLOAD 24BF 92 SWAP3 24C0 01 ADD 24C1 91 SWAP2 24C2 60 PUSH1 0x00 24C4 90 SWAP1 24C5 60 PUSH1 0x01 24C7 81 DUP2 24C8 81 DUP2 24C9 1C SHR 24CA 90 SWAP1 24CB 80 DUP1 24CC 83 DUP4 24CD 16 AND 24CE 80 DUP1 24CF 61 PUSH2 0x24d9 24D2 57 *JUMPI 24D3 60 PUSH1 0x7f 24D5 83 DUP4 24D6 16 AND 24D7 92 SWAP3 24D8 50 POP 24D9 5B JUMPDEST 24DA 85 DUP6 24DB 83 DUP4 24DC 10 LT 24DD 81 DUP2 24DE 14 EQ 24DF 15 ISZERO 24E0 61 PUSH2 0x24f7 24E3 57 *JUMPI 24E4 63 PUSH4 0x4e487b71 24E9 60 PUSH1 0xe0 24EB 1B SHL 24EC 85 DUP6 24ED 52 MSTORE 24EE 60 PUSH1 0x22 24F0 60 PUSH1 0x04 24F2 52 MSTORE 24F3 60 PUSH1 0x24 24F5 85 DUP6 24F6 FD *REVERT 24F7 5B JUMPDEST 24F8 80 DUP1 24F9 80 DUP1 24FA 15 ISZERO 24FB 61 PUSH2 0x250b 24FE 57 *JUMPI 24FF 60 PUSH1 0x01 2501 81 DUP2 2502 14 EQ 2503 61 PUSH2 0x251c 2506 57 *JUMPI 2507 61 PUSH2 0x2549 250A 56 *JUMP 250B 5B JUMPDEST 250C 60 PUSH1 0xff 250E 19 NOT 250F 85 DUP6 2510 16 AND 2511 88 DUP9 2512 52 MSTORE 2513 83 DUP4 2514 88 DUP9 2515 01 ADD 2516 95 SWAP6 2517 50 POP 2518 61 PUSH2 0x2549 251B 56 *JUMP 251C 5B JUMPDEST 251D 60 PUSH1 0x00 251F 8B DUP12 2520 81 DUP2 2521 52 MSTORE 2522 60 PUSH1 0x20 2524 90 SWAP1 2525 20 SHA3 2526 60 PUSH1 0x00 2528 5B JUMPDEST 2529 85 DUP6 252A 81 DUP2 252B 10 LT 252C 15 ISZERO 252D 61 PUSH2 0x2541 2530 57 *JUMPI 2531 81 DUP2 2532 54 SLOAD 2533 8A DUP11 2534 82 DUP3 2535 01 ADD 2536 52 MSTORE 2537 90 SWAP1 2538 84 DUP5 2539 01 ADD 253A 90 SWAP1 253B 88 DUP9 253C 01 ADD 253D 61 PUSH2 0x2528 2540 56 *JUMP 2541 5B JUMPDEST 2542 50 POP 2543 50 POP 2544 83 DUP4 2545 88 DUP9 2546 01 ADD 2547 95 SWAP6 2548 50 POP 2549 5B JUMPDEST 254A 50 POP 254B 93 SWAP4 254C 9B SWAP12 254D 9A SWAP11 254E 50 POP 254F 50 POP 2550 50 POP 2551 50 POP 2552 50 POP 2553 50 POP 2554 50 POP 2555 50 POP 2556 50 POP 2557 50 POP 2558 50 POP 2559 56 *JUMP label_255A: // Incoming call from 0x1A6D, returns to 0x1A6E // Inputs[5] // { // @2563 stack[-5] // @2566 stack[-1] // @2568 stack[-4] // @2573 stack[-3] // @2588 stack[-2] // } 255A 5B JUMPDEST 255B 60 PUSH1 0x01 255D 60 PUSH1 0x01 255F 60 PUSH1 0xa0 2561 1B SHL 2562 03 SUB 2563 85 DUP6 2564 81 DUP2 2565 16 AND 2566 82 DUP3 2567 52 MSTORE 2568 84 DUP5 2569 16 AND 256A 60 PUSH1 0x20 256C 82 DUP3 256D 01 ADD 256E 52 MSTORE 256F 60 PUSH1 0x40 2571 81 DUP2 2572 01 ADD 2573 83 DUP4 2574 90 SWAP1 2575 52 MSTORE 2576 60 PUSH1 0x80 2578 60 PUSH1 0x60 257A 82 DUP3 257B 01 ADD 257C 81 DUP2 257D 90 SWAP1 257E 52 MSTORE 257F 60 PUSH1 0x00 2581 90 SWAP1 2582 61 PUSH2 0x258d 2585 90 SWAP1 2586 83 DUP4 2587 01 ADD 2588 84 DUP5 2589 61 PUSH2 0x1f9c 258C 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @2567 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @256E memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2575 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @257E memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @2581 stack[0] = 0x00 // @2585 stack[1] = 0x258d // @2587 stack[2] = stack[-1] + 0x80 // @2588 stack[3] = stack[-2] // } // Block ends with call to 0x1f9c, returns to 0x258D label_258D: // Incoming return from call to 0x1F9C at 0x258C // Inputs[3] // { // @258E stack[-8] // @258E stack[-1] // @258F stack[-7] // } 258D 5B JUMPDEST 258E 96 SWAP7 258F 95 SWAP6 2590 50 POP 2591 50 POP 2592 50 POP 2593 50 POP 2594 50 POP 2595 50 POP 2596 56 *JUMP // Stack delta = -7 // Outputs[1] { @258E stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2597: // Incoming jump from 0x1AB4 // Inputs[2] // { // @259C stack[-1] // @259D stack[-2] // } 2597 5B JUMPDEST 2598 60 PUSH1 0x00 259A 60 PUSH1 0x20 259C 82 DUP3 259D 84 DUP5 259E 03 SUB 259F 12 SLT 25A0 15 ISZERO 25A1 61 PUSH2 0x25a9 25A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2598 stack[0] = 0x00 } // Block ends with conditional jump to 0x25a9, if !(stack[-2] - stack[-1] i< 0x20) label_25A5: // Incoming jump from 0x25A4, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @25A8 memory[0x00:0x00] } 25A5 60 PUSH1 0x00 25A7 80 DUP1 25A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @25A8 revert(memory[0x00:0x00]); } // Block terminates label_25A9: // Incoming jump from 0x25A4, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @25AA stack[-2] // @25AB memory[stack[-2]:stack[-2] + 0x20] // } 25A9 5B JUMPDEST 25AA 81 DUP2 25AB 51 MLOAD 25AC 61 PUSH2 0x1236 25AF 81 DUP2 25B0 61 PUSH2 0x1f3d 25B3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @25AB stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @25AC stack[1] = 0x1236 // @25AF stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1f3d, returns to 0x1236 25B4 5B JUMPDEST 25B5 63 PUSH4 0x4e487b71 25BA 60 PUSH1 0xe0 25BC 1B SHL 25BD 60 PUSH1 0x00 25BF 52 MSTORE 25C0 60 PUSH1 0x12 25C2 60 PUSH1 0x04 25C4 52 MSTORE 25C5 60 PUSH1 0x24 25C7 60 PUSH1 0x00 25C9 FD *REVERT 25CA 5B JUMPDEST 25CB 60 PUSH1 0x00 25CD 82 DUP3 25CE 61 PUSH2 0x25d9 25D1 57 *JUMPI 25D2 61 PUSH2 0x25d9 25D5 61 PUSH2 0x25b4 25D8 56 *JUMP 25D9 5B JUMPDEST 25DA 50 POP 25DB 04 DIV 25DC 90 SWAP1 25DD 56 *JUMP 25DE 5B JUMPDEST 25DF 60 PUSH1 0x00 25E1 82 DUP3 25E2 82 DUP3 25E3 10 LT 25E4 15 ISZERO 25E5 61 PUSH2 0x25f0 25E8 57 *JUMPI 25E9 61 PUSH2 0x25f0 25EC 61 PUSH2 0x23d2 25EF 56 *JUMP 25F0 5B JUMPDEST 25F1 50 POP 25F2 03 SUB 25F3 90 SWAP1 25F4 56 *JUMP 25F5 5B JUMPDEST 25F6 60 PUSH1 0x00 25F8 82 DUP3 25F9 61 PUSH2 0x2604 25FC 57 *JUMPI 25FD 61 PUSH2 0x2604 2600 61 PUSH2 0x25b4 2603 56 *JUMP 2604 5B JUMPDEST 2605 50 POP 2606 06 MOD 2607 90 SWAP1 2608 56 *JUMP 2609 FE *ASSERT 260A A2 LOG2 260B 64 PUSH5 0x6970667358 2611 22 22 2612 12 SLT 2613 20 SHA3 2614 35 CALLDATALOAD 2615 EA EA 2616 98 SWAP9 2617 33 CALLER 2618 92 SWAP3 2619 80 DUP1 261A F2 CALLCODE 261B 88 DUP9 261C 46 CHAINID 261D 7A PUSH27 0x8a220c55d40cf9df372b1399f79801f7eccec60b056164736f6c63 2639 43 NUMBER 263A 00 *STOP 263B 08 ADDMOD 263C 09 MULMOD 263D 00 *STOP 263E 33 CALLER