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 0x0288 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0288, 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 0x92eefe9b 0019 11 GT 001A 61 PUSH2 0x015a 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x015a, if 0x92eefe9b > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x92eefe9b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xc5ebeaec 0024 11 GT 0025 61 PUSH2 0x00c1 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c1, if 0xc5ebeaec > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xc5ebeaec > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xf3fdb15a 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xf3fdb15a > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xf3fdb15a > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xf3fdb15a 003A 14 EQ 003B 61 PUSH2 0x0a76 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a76, if 0xf3fdb15a == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xf3fdb15a == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf77c4791 0045 14 EQ 0046 61 PUSH2 0x0aa7 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aa7, if 0xf77c4791 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf77c4791 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf851a440 0050 14 EQ 0051 61 PUSH2 0x0abc 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0abc, if 0xf851a440 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf851a440 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf8f9da28 005B 14 EQ 005C 61 PUSH2 0x0ad1 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ad1, if 0xf8f9da28 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf8f9da28 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xfca7820b 0066 14 EQ 0067 61 PUSH2 0x0ae6 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ae6, if 0xfca7820b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xfca7820b == stack[-1] // Inputs[1] { @006B stack[-1] } 006B 80 DUP1 006C 63 PUSH4 0xfcb64147 0071 14 EQ 0072 61 PUSH2 0x0b10 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b10, if 0xfcb64147 == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xfcb64147 == stack[-1] 0076 61 PUSH2 0x0288 0079 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0288 label_007A: // Incoming jump from 0x0033, if 0xf3fdb15a > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0xc5ebeaec 0081 14 EQ 0082 61 PUSH2 0x0841 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0841, if 0xc5ebeaec == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc5ebeaec == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc7b7cc13 008C 14 EQ 008D 61 PUSH2 0x086b 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x086b, if 0xc7b7cc13 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc7b7cc13 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xd90a730e 0097 14 EQ 0098 61 PUSH2 0x09cd 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09cd, if 0xd90a730e == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xd90a730e == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xdd62ed3e 00A2 14 EQ 00A3 61 PUSH2 0x09e2 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09e2, if 0xdd62ed3e == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xdd62ed3e == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xe5974619 00AD 14 EQ 00AE 61 PUSH2 0x0a1d 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a1d, if 0xe5974619 == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xe5974619 == stack[-1] // Inputs[1] { @00B2 stack[-1] } 00B2 80 DUP1 00B3 63 PUSH4 0xf2b3abbd 00B8 14 EQ 00B9 61 PUSH2 0x0a43 00BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a43, if 0xf2b3abbd == stack[-1] label_00BD: // Incoming jump from 0x00BC, if not 0xf2b3abbd == stack[-1] 00BD 61 PUSH2 0x0288 00C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0288 label_00C1: // Incoming jump from 0x0028, if 0xc5ebeaec > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C1 5B JUMPDEST 00C2 80 DUP1 00C3 63 PUSH4 0xaa5af0fd 00C8 11 GT 00C9 61 PUSH2 0x0113 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0113, if 0xaa5af0fd > stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xaa5af0fd > stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xaa5af0fd 00D3 14 EQ 00D4 61 PUSH2 0x0738 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0738, if 0xaa5af0fd == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xaa5af0fd == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0xaae40a2a 00DE 14 EQ 00DF 61 PUSH2 0x074d 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x074d, if 0xaae40a2a == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xaae40a2a == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xae9d70b0 00E9 14 EQ 00EA 61 PUSH2 0x077b 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x077b, if 0xae9d70b0 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xae9d70b0 == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0xb2a02ff1 00F4 14 EQ 00F5 61 PUSH2 0x0790 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0790, if 0xb2a02ff1 == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0xb2a02ff1 == stack[-1] // Inputs[1] { @00F9 stack[-1] } 00F9 80 DUP1 00FA 63 PUSH4 0xbd6d894d 00FF 14 EQ 0100 61 PUSH2 0x07d3 0103 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07d3, if 0xbd6d894d == stack[-1] label_0104: // Incoming jump from 0x0103, if not 0xbd6d894d == stack[-1] // Inputs[1] { @0104 stack[-1] } 0104 80 DUP1 0105 63 PUSH4 0xc37f68e2 010A 14 EQ 010B 61 PUSH2 0x07e8 010E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e8, if 0xc37f68e2 == stack[-1] label_010F: // Incoming jump from 0x010E, if not 0xc37f68e2 == stack[-1] 010F 61 PUSH2 0x0288 0112 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0288 label_0113: // Incoming jump from 0x00CC, if 0xaa5af0fd > stack[-1] // Inputs[1] { @0114 stack[-1] } 0113 5B JUMPDEST 0114 80 DUP1 0115 63 PUSH4 0x92eefe9b 011A 14 EQ 011B 61 PUSH2 0x063c 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063c, if 0x92eefe9b == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x92eefe9b == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x954f92a3 0125 14 EQ 0126 61 PUSH2 0x066f 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x066f, if 0x954f92a3 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x954f92a3 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x95d89b41 0130 14 EQ 0131 61 PUSH2 0x06a2 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06a2, if 0x95d89b41 == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0135 stack[-1] } 0135 80 DUP1 0136 63 PUSH4 0x95dd9193 013B 14 EQ 013C 61 PUSH2 0x06b7 013F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b7, if 0x95dd9193 == stack[-1] label_0140: // Incoming jump from 0x013F, if not 0x95dd9193 == stack[-1] // Inputs[1] { @0140 stack[-1] } 0140 80 DUP1 0141 63 PUSH4 0xa6afed95 0146 14 EQ 0147 61 PUSH2 0x06ea 014A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ea, if 0xa6afed95 == stack[-1] label_014B: // Incoming jump from 0x014A, if not 0xa6afed95 == stack[-1] // Inputs[1] { @014B stack[-1] } 014B 80 DUP1 014C 63 PUSH4 0xa9059cbb 0151 14 EQ 0152 61 PUSH2 0x06ff 0155 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06ff, if 0xa9059cbb == stack[-1] label_0156: // Incoming jump from 0x0155, if not 0xa9059cbb == stack[-1] 0156 61 PUSH2 0x0288 0159 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0288 label_015A: // Incoming jump from 0x001D, if 0x92eefe9b > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @015B stack[-1] } 015A 5B JUMPDEST 015B 80 DUP1 015C 63 PUSH4 0x3af9e669 0161 11 GT 0162 61 PUSH2 0x01fe 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fe, if 0x3af9e669 > stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x3af9e669 > stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x6c540baf 016C 11 GT 016D 61 PUSH2 0x01b7 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b7, if 0x6c540baf > stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x6c540baf > stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x6c540baf 0177 14 EQ 0178 61 PUSH2 0x056b 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056b, if 0x6c540baf == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x6c540baf == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x704b6c02 0182 14 EQ 0183 61 PUSH2 0x0580 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0580, if 0x704b6c02 == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x704b6c02 == stack[-1] // Inputs[1] { @0187 stack[-1] } 0187 80 DUP1 0188 63 PUSH4 0x70a08231 018D 14 EQ 018E 61 PUSH2 0x05b5 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b5, if 0x70a08231 == stack[-1] label_0192: // Incoming jump from 0x0191, if not 0x70a08231 == stack[-1] // Inputs[1] { @0192 stack[-1] } 0192 80 DUP1 0193 63 PUSH4 0x73acee98 0198 14 EQ 0199 61 PUSH2 0x05e8 019C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05e8, if 0x73acee98 == stack[-1] label_019D: // Incoming jump from 0x019C, if not 0x73acee98 == stack[-1] // Inputs[1] { @019D stack[-1] } 019D 80 DUP1 019E 63 PUSH4 0x852a12e3 01A3 14 EQ 01A4 61 PUSH2 0x05fd 01A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05fd, if 0x852a12e3 == stack[-1] label_01A8: // Incoming jump from 0x01A7, if not 0x852a12e3 == stack[-1] // Inputs[1] { @01A8 stack[-1] } 01A8 80 DUP1 01A9 63 PUSH4 0x8f840ddd 01AE 14 EQ 01AF 61 PUSH2 0x0627 01B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0627, if 0x8f840ddd == stack[-1] label_01B3: // Incoming jump from 0x01B2, if not 0x8f840ddd == stack[-1] 01B3 61 PUSH2 0x0288 01B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0288 label_01B7: // Incoming jump from 0x0170, if 0x6c540baf > stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B7 5B JUMPDEST 01B8 80 DUP1 01B9 63 PUSH4 0x3af9e669 01BE 14 EQ 01BF 61 PUSH2 0x0490 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0490, if 0x3af9e669 == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x3af9e669 == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x3b1d21a2 01C9 14 EQ 01CA 61 PUSH2 0x04c3 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c3, if 0x3b1d21a2 == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x3b1d21a2 == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x47bd3718 01D4 14 EQ 01D5 61 PUSH2 0x04d8 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d8, if 0x47bd3718 == stack[-1] label_01D9: // Incoming jump from 0x01D8, if not 0x47bd3718 == stack[-1] // Inputs[1] { @01D9 stack[-1] } 01D9 80 DUP1 01DA 63 PUSH4 0x4dc3487d 01DF 14 EQ 01E0 61 PUSH2 0x04ed 01E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ed, if 0x4dc3487d == stack[-1] label_01E4: // Incoming jump from 0x01E3, if not 0x4dc3487d == stack[-1] // Inputs[1] { @01E4 stack[-1] } 01E4 80 DUP1 01E5 63 PUSH4 0x4e4d9fea 01EA 14 EQ 01EB 61 PUSH2 0x0520 01EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0520, if 0x4e4d9fea == stack[-1] label_01EF: // Incoming jump from 0x01EE, if not 0x4e4d9fea == stack[-1] // Inputs[1] { @01EF stack[-1] } 01EF 80 DUP1 01F0 63 PUSH4 0x601a0bf1 01F5 14 EQ 01F6 61 PUSH2 0x0541 01F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0541, if 0x601a0bf1 == stack[-1] label_01FA: // Incoming jump from 0x01F9, if not 0x601a0bf1 == stack[-1] 01FA 61 PUSH2 0x0288 01FD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0288 label_01FE: // Incoming jump from 0x0165, if 0x3af9e669 > stack[-1] // Inputs[1] { @01FF stack[-1] } 01FE 5B JUMPDEST 01FF 80 DUP1 0200 63 PUSH4 0x18160ddd 0205 11 GT 0206 61 PUSH2 0x0250 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0250, if 0x18160ddd > stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x18160ddd > stack[-1] // Inputs[1] { @020A stack[-1] } 020A 80 DUP1 020B 63 PUSH4 0x18160ddd 0210 14 EQ 0211 61 PUSH2 0x03ce 0214 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ce, if 0x18160ddd == stack[-1] label_0215: // Incoming jump from 0x0214, if not 0x18160ddd == stack[-1] // Inputs[1] { @0215 stack[-1] } 0215 80 DUP1 0216 63 PUSH4 0x182df0f5 021B 14 EQ 021C 61 PUSH2 0x03e3 021F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e3, if 0x182df0f5 == stack[-1] label_0220: // Incoming jump from 0x021F, if not 0x182df0f5 == stack[-1] // Inputs[1] { @0220 stack[-1] } 0220 80 DUP1 0221 63 PUSH4 0x23b872dd 0226 14 EQ 0227 61 PUSH2 0x03f8 022A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f8, if 0x23b872dd == stack[-1] label_022B: // Incoming jump from 0x022A, if not 0x23b872dd == stack[-1] // Inputs[1] { @022B stack[-1] } 022B 80 DUP1 022C 63 PUSH4 0x2ebf040e 0231 14 EQ 0232 61 PUSH2 0x043b 0235 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043b, if 0x2ebf040e == stack[-1] label_0236: // Incoming jump from 0x0235, if not 0x2ebf040e == stack[-1] // Inputs[1] { @0236 stack[-1] } 0236 80 DUP1 0237 63 PUSH4 0x313ce567 023C 14 EQ 023D 61 PUSH2 0x0450 0240 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0450, if 0x313ce567 == stack[-1] label_0241: // Incoming jump from 0x0240, if not 0x313ce567 == stack[-1] // Inputs[1] { @0241 stack[-1] } 0241 80 DUP1 0242 63 PUSH4 0x3ac4202f 0247 14 EQ 0248 61 PUSH2 0x047b 024B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047b, if 0x3ac4202f == stack[-1] label_024C: // Incoming jump from 0x024B, if not 0x3ac4202f == stack[-1] 024C 61 PUSH2 0x0288 024F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0288 label_0250: // Incoming jump from 0x0209, if 0x18160ddd > stack[-1] // Inputs[1] { @0251 stack[-1] } 0250 5B JUMPDEST 0251 80 DUP1 0252 63 PUSH4 0x06fdde03 0257 14 EQ 0258 61 PUSH2 0x0295 025B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0295, if 0x06fdde03 == stack[-1] label_025C: // Incoming jump from 0x025B, if not 0x06fdde03 == stack[-1] // Inputs[1] { @025C stack[-1] } 025C 80 DUP1 025D 63 PUSH4 0x095ea7b3 0262 14 EQ 0263 61 PUSH2 0x031f 0266 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x031f, if 0x095ea7b3 == stack[-1] label_0267: // Incoming jump from 0x0266, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0267 stack[-1] } 0267 80 DUP1 0268 63 PUSH4 0x1249c58b 026D 14 EQ 026E 61 PUSH2 0x036c 0271 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036c, if 0x1249c58b == stack[-1] label_0272: // Incoming jump from 0x0271, if not 0x1249c58b == stack[-1] // Inputs[1] { @0272 stack[-1] } 0272 80 DUP1 0273 63 PUSH4 0x173b9904 0278 14 EQ 0279 61 PUSH2 0x0386 027C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0386, if 0x173b9904 == stack[-1] label_027D: // Incoming jump from 0x027C, if not 0x173b9904 == stack[-1] // Inputs[1] { @027D stack[-1] } 027D 80 DUP1 027E 63 PUSH4 0x17bfdfbc 0283 14 EQ 0284 61 PUSH2 0x039b 0287 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x039b, if 0x17bfdfbc == stack[-1] label_0288: // Incoming jump from 0x0287, if not 0x17bfdfbc == stack[-1] // Incoming jump from 0x00C0 // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x01FD // Incoming jump from 0x0112 // Incoming jump from 0x0079 // Incoming jump from 0x0159 // Incoming jump from 0x024F // Incoming jump from 0x01B6 // Inputs[2] // { // @028C msg.sender // @028D msg.value // } 0288 5B JUMPDEST 0289 61 PUSH2 0x0292 028C 33 CALLER 028D 34 CALLVALUE 028E 61 PUSH2 0x0b18 0291 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0289 stack[0] = 0x0292 // @028C stack[1] = msg.sender // @028D stack[2] = msg.value // } // Block ends with unconditional jump to 0x0b18 0292 5B JUMPDEST 0293 50 POP 0294 00 *STOP label_0295: // Incoming jump from 0x025B, if 0x06fdde03 == stack[-1] // Inputs[1] { @0296 msg.value } 0295 5B JUMPDEST 0296 34 CALLVALUE 0297 80 DUP1 0298 15 ISZERO 0299 61 PUSH2 0x02a1 029C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0296 stack[0] = msg.value } // Block ends with conditional jump to 0x02a1, if !msg.value label_029D: // Incoming jump from 0x029C, if not !msg.value // Inputs[1] { @02A0 memory[0x00:0x00] } 029D 60 PUSH1 0x00 029F 80 DUP1 02A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A0 revert(memory[0x00:0x00]); } // Block terminates label_02A1: // Incoming jump from 0x029C, if !msg.value 02A1 5B JUMPDEST 02A2 50 POP 02A3 61 PUSH2 0x02aa 02A6 61 PUSH2 0x109e 02A9 56 *JUMP // Stack delta = +0 // Outputs[1] { @02A3 stack[-1] = 0x02aa } // Block ends with call to 0x109e, returns to 0x02AA label_02AA: // Incoming return from call to 0x197E at 0x06B6 // Incoming return from call to 0x109E at 0x02A9 // Inputs[4] // { // @02AE memory[0x40:0x60] // @02B4 stack[-1] // @02B5 memory[stack[-1]:stack[-1] + 0x20] // @02BB memory[stack[-1]:stack[-1] + 0x20] // } 02AA 5B JUMPDEST 02AB 60 PUSH1 0x40 02AD 80 DUP1 02AE 51 MLOAD 02AF 60 PUSH1 0x20 02B1 80 DUP1 02B2 82 DUP3 02B3 52 MSTORE 02B4 83 DUP4 02B5 51 MLOAD 02B6 81 DUP2 02B7 83 DUP4 02B8 01 ADD 02B9 52 MSTORE 02BA 83 DUP4 02BB 51 MLOAD 02BC 91 SWAP2 02BD 92 SWAP3 02BE 83 DUP4 02BF 92 SWAP3 02C0 90 SWAP1 02C1 83 DUP4 02C2 01 ADD 02C3 91 SWAP2 02C4 85 DUP6 02C5 01 ADD 02C6 90 SWAP1 02C7 80 DUP1 02C8 83 DUP4 02C9 83 DUP4 02CA 60 PUSH1 0x00 02CC 5B JUMPDEST 02CD 83 DUP4 02CE 81 DUP2 02CF 10 LT 02D0 15 ISZERO 02D1 61 PUSH2 0x02e4 02D4 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @02B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x20 // @02B9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @02BD stack[0] = memory[0x40:0x60] // @02BF stack[1] = memory[0x40:0x60] // @02C3 stack[2] = memory[0x40:0x60] + 0x40 // @02C6 stack[3] = stack[-1] + 0x20 // @02C6 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @02C7 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @02C8 stack[6] = memory[0x40:0x60] + 0x40 // @02C9 stack[7] = stack[-1] + 0x20 // @02CA stack[8] = 0x00 // } // Block ends with conditional jump to 0x02e4, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_02D5: // Incoming jump from 0x02D4, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x02D4, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @02D5 stack[-2] // @02D6 stack[-1] // @02D8 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @02D9 stack[-3] // } 02D5 81 DUP2 02D6 81 DUP2 02D7 01 ADD 02D8 51 MLOAD 02D9 83 DUP4 02DA 82 DUP3 02DB 01 ADD 02DC 52 MSTORE 02DD 60 PUSH1 0x20 02DF 01 ADD 02E0 61 PUSH2 0x02cc 02E3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02DC memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @02DF stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x02cc label_02E4: // Incoming jump from 0x02D4, if !(stack[-1] < stack[-4]) // Incoming jump from 0x02D4, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @02E9 stack[-5] // @02E9 stack[-6] // @02EB stack[-7] // } 02E4 5B JUMPDEST 02E5 50 POP 02E6 50 POP 02E7 50 POP 02E8 50 POP 02E9 90 SWAP1 02EA 50 POP 02EB 90 SWAP1 02EC 81 DUP2 02ED 01 ADD 02EE 90 SWAP1 02EF 60 PUSH1 0x1f 02F1 16 AND 02F2 80 DUP1 02F3 15 ISZERO 02F4 61 PUSH2 0x0311 02F7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @02EE stack[-7] = stack[-5] + stack[-7] // @02F1 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0311, if !(0x1f & stack[-5]) label_02F8: // Incoming jump from 0x02F7, if not !(0x1f & stack[-5]) // Inputs[6] // { // @02F8 stack[-1] // @02F9 stack[-2] // @02FC memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0313 stack[-5] // @0319 memory[0x40:0x60] // @031E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 02F8 80 DUP1 02F9 82 DUP3 02FA 03 SUB 02FB 80 DUP1 02FC 51 MLOAD 02FD 60 PUSH1 0x01 02FF 83 DUP4 0300 60 PUSH1 0x20 0302 03 SUB 0303 61 PUSH2 0x0100 0306 0A EXP 0307 03 SUB 0308 19 NOT 0309 16 AND 030A 81 DUP2 030B 52 MSTORE 030C 60 PUSH1 0x20 030E 01 ADD 030F 91 SWAP2 0310 50 POP 0311 5B JUMPDEST 0312 50 POP 0313 92 SWAP3 0314 50 POP 0315 50 POP 0316 50 POP 0317 60 PUSH1 0x40 0319 51 MLOAD 031A 80 DUP1 031B 91 SWAP2 031C 03 SUB 031D 90 SWAP1 031E F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @030B memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @031E return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_031F: // Incoming jump from 0x0266, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0320 msg.value } 031F 5B JUMPDEST 0320 34 CALLVALUE 0321 80 DUP1 0322 15 ISZERO 0323 61 PUSH2 0x032b 0326 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0320 stack[0] = msg.value } // Block ends with conditional jump to 0x032b, if !msg.value label_0327: // Incoming jump from 0x0326, if not !msg.value // Inputs[1] { @032A memory[0x00:0x00] } 0327 60 PUSH1 0x00 0329 80 DUP1 032A FD *REVERT // Stack delta = +0 // Outputs[1] { @032A revert(memory[0x00:0x00]); } // Block terminates label_032B: // Incoming jump from 0x0326, if !msg.value // Inputs[1] { @0333 msg.data.length } 032B 5B JUMPDEST 032C 50 POP 032D 61 PUSH2 0x0358 0330 60 PUSH1 0x04 0332 80 DUP1 0333 36 CALLDATASIZE 0334 03 SUB 0335 60 PUSH1 0x40 0337 81 DUP2 0338 10 LT 0339 15 ISZERO 033A 61 PUSH2 0x0342 033D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @032D stack[-1] = 0x0358 // @0330 stack[0] = 0x04 // @0334 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0342, returns to 0x0358, if !(msg.data.length - 0x04 < 0x40) label_033E: // Incoming jump from 0x033D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0341 memory[0x00:0x00] } 033E 60 PUSH1 0x00 0340 80 DUP1 0341 FD *REVERT // Stack delta = +0 // Outputs[1] { @0341 revert(memory[0x00:0x00]); } // Block terminates label_0342: // Incoming call from 0x033D, returns to 0x0358, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @034C stack[-2] // @034D msg.data[stack[-2]:stack[-2] + 0x20] // @0353 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0342 5B JUMPDEST 0343 50 POP 0344 60 PUSH1 0x01 0346 60 PUSH1 0x01 0348 60 PUSH1 0xa0 034A 1B SHL 034B 03 SUB 034C 81 DUP2 034D 35 CALLDATALOAD 034E 16 AND 034F 90 SWAP1 0350 60 PUSH1 0x20 0352 01 ADD 0353 35 CALLDATALOAD 0354 61 PUSH2 0x112c 0357 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @034F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0353 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x112c label_0358: // Incoming return from call to 0x0342 at 0x033D // Incoming return from call to 0x14C1 at 0x048F // Incoming return from call to 0x0722 at 0x071D // Incoming return from call to 0x041B at 0x0416 // Inputs[4] // { // @035C memory[0x40:0x60] // @035D stack[-1] // @0362 memory[0x40:0x60] // @036B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0358 5B JUMPDEST 0359 60 PUSH1 0x40 035B 80 DUP1 035C 51 MLOAD 035D 91 SWAP2 035E 15 ISZERO 035F 15 ISZERO 0360 82 DUP3 0361 52 MSTORE 0362 51 MLOAD 0363 90 SWAP1 0364 81 DUP2 0365 90 SWAP1 0366 03 SUB 0367 60 PUSH1 0x20 0369 01 ADD 036A 90 SWAP1 036B F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0361 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @036B return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_036C: // Incoming jump from 0x0271, if 0x1249c58b == stack[-1] 036C 5B JUMPDEST 036D 61 PUSH2 0x0374 0370 61 PUSH2 0x1197 0373 56 *JUMP // Stack delta = +1 // Outputs[1] { @036D stack[0] = 0x0374 } // Block ends with unconditional jump to 0x1197 label_0374: // Incoming return from call to 0x0A66 at 0x0A61 // Incoming return from call to 0x1A38 at 0x06FE // Incoming return from call to 0x1A38 at 0x06FE // Incoming return from call to 0x1E84 at 0x078F // Incoming return from call to 0x05D8 at 0x05D3 // Incoming return from call to 0x21CA at 0x09E1 // Incoming return from call to 0x175C at 0x05FC // Incoming return from call to 0x18B0 at 0x063B // Incoming return from call to 0x03BE at 0x03B9 // Incoming return from call to 0x06DA at 0x06D5 // Incoming return from call to 0x0B09 at 0x0B04 // Incoming return from call to 0x07B3 at 0x07AE // Incoming return from call to 0x0A05 at 0x0A00 // Incoming return from call to 0x1F9F at 0x07E7 // Incoming return from call to 0x04B3 at 0x04AE // Incoming return from call to 0x065F at 0x065A // Incoming return from call to 0x1271 at 0x03F7 // Incoming return from call to 0x22C3 at 0x0AE5 // Incoming return from call to 0x1E41 at 0x074C // Incoming return from call to 0x11A9 at 0x039A // Incoming return from call to 0x1572 at 0x04EC // Incoming return from call to 0x0510 at 0x050B // Incoming return from call to 0x126B at 0x03E2 // Incoming return from call to 0x1688 at 0x057F // Incoming return from call to 0x0692 at 0x068D // Inputs[4] // { // @0378 memory[0x40:0x60] // @0379 stack[-1] // @037C memory[0x40:0x60] // @0385 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0374 5B JUMPDEST 0375 60 PUSH1 0x40 0377 80 DUP1 0378 51 MLOAD 0379 91 SWAP2 037A 82 DUP3 037B 52 MSTORE 037C 51 MLOAD 037D 90 SWAP1 037E 81 DUP2 037F 90 SWAP1 0380 03 SUB 0381 60 PUSH1 0x20 0383 01 ADD 0384 90 SWAP1 0385 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @037B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0385 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0386: // Incoming jump from 0x027C, if 0x173b9904 == stack[-1] // Inputs[1] { @0387 msg.value } 0386 5B JUMPDEST 0387 34 CALLVALUE 0388 80 DUP1 0389 15 ISZERO 038A 61 PUSH2 0x0392 038D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0387 stack[0] = msg.value } // Block ends with conditional jump to 0x0392, if !msg.value label_038E: // Incoming jump from 0x038D, if not !msg.value // Inputs[1] { @0391 memory[0x00:0x00] } 038E 60 PUSH1 0x00 0390 80 DUP1 0391 FD *REVERT // Stack delta = +0 // Outputs[1] { @0391 revert(memory[0x00:0x00]); } // Block terminates label_0392: // Incoming jump from 0x038D, if !msg.value 0392 5B JUMPDEST 0393 50 POP 0394 61 PUSH2 0x0374 0397 61 PUSH2 0x11a9 039A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0394 stack[-1] = 0x0374 } // Block ends with call to 0x11a9, returns to 0x0374 label_039B: // Incoming jump from 0x0287, if 0x17bfdfbc == stack[-1] // Inputs[1] { @039C msg.value } 039B 5B JUMPDEST 039C 34 CALLVALUE 039D 80 DUP1 039E 15 ISZERO 039F 61 PUSH2 0x03a7 03A2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @039C stack[0] = msg.value } // Block ends with conditional jump to 0x03a7, if !msg.value label_03A3: // Incoming jump from 0x03A2, if not !msg.value // Inputs[1] { @03A6 memory[0x00:0x00] } 03A3 60 PUSH1 0x00 03A5 80 DUP1 03A6 FD *REVERT // Stack delta = +0 // Outputs[1] { @03A6 revert(memory[0x00:0x00]); } // Block terminates label_03A7: // Incoming jump from 0x03A2, if !msg.value // Inputs[1] { @03AF msg.data.length } 03A7 5B JUMPDEST 03A8 50 POP 03A9 61 PUSH2 0x0374 03AC 60 PUSH1 0x04 03AE 80 DUP1 03AF 36 CALLDATASIZE 03B0 03 SUB 03B1 60 PUSH1 0x20 03B3 81 DUP2 03B4 10 LT 03B5 15 ISZERO 03B6 61 PUSH2 0x03be 03B9 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03A9 stack[-1] = 0x0374 // @03AC stack[0] = 0x04 // @03B0 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03be, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_03BA: // Incoming jump from 0x03B9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @03BD memory[0x00:0x00] } 03BA 60 PUSH1 0x00 03BC 80 DUP1 03BD FD *REVERT // Stack delta = +0 // Outputs[1] { @03BD revert(memory[0x00:0x00]); } // Block terminates label_03BE: // Incoming call from 0x03B9, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @03C0 msg.data[stack[-2]:stack[-2] + 0x20] // @03C0 stack[-2] // } 03BE 5B JUMPDEST 03BF 50 POP 03C0 35 CALLDATALOAD 03C1 60 PUSH1 0x01 03C3 60 PUSH1 0x01 03C5 60 PUSH1 0xa0 03C7 1B SHL 03C8 03 SUB 03C9 16 AND 03CA 61 PUSH2 0x11af 03CD 56 *JUMP // Stack delta = -1 // Outputs[1] { @03C9 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x11af label_03CE: // Incoming jump from 0x0214, if 0x18160ddd == stack[-1] // Inputs[1] { @03CF msg.value } 03CE 5B JUMPDEST 03CF 34 CALLVALUE 03D0 80 DUP1 03D1 15 ISZERO 03D2 61 PUSH2 0x03da 03D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CF stack[0] = msg.value } // Block ends with conditional jump to 0x03da, if !msg.value label_03D6: // Incoming jump from 0x03D5, if not !msg.value // Inputs[1] { @03D9 memory[0x00:0x00] } 03D6 60 PUSH1 0x00 03D8 80 DUP1 03D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D9 revert(memory[0x00:0x00]); } // Block terminates label_03DA: // Incoming jump from 0x03D5, if !msg.value 03DA 5B JUMPDEST 03DB 50 POP 03DC 61 PUSH2 0x0374 03DF 61 PUSH2 0x126b 03E2 56 *JUMP // Stack delta = +0 // Outputs[1] { @03DC stack[-1] = 0x0374 } // Block ends with call to 0x126b, returns to 0x0374 label_03E3: // Incoming jump from 0x021F, if 0x182df0f5 == stack[-1] // Inputs[1] { @03E4 msg.value } 03E3 5B JUMPDEST 03E4 34 CALLVALUE 03E5 80 DUP1 03E6 15 ISZERO 03E7 61 PUSH2 0x03ef 03EA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E4 stack[0] = msg.value } // Block ends with conditional jump to 0x03ef, if !msg.value label_03EB: // Incoming jump from 0x03EA, if not !msg.value // Inputs[1] { @03EE memory[0x00:0x00] } 03EB 60 PUSH1 0x00 03ED 80 DUP1 03EE FD *REVERT // Stack delta = +0 // Outputs[1] { @03EE revert(memory[0x00:0x00]); } // Block terminates label_03EF: // Incoming jump from 0x03EA, if !msg.value 03EF 5B JUMPDEST 03F0 50 POP 03F1 61 PUSH2 0x0374 03F4 61 PUSH2 0x1271 03F7 56 *JUMP // Stack delta = +0 // Outputs[1] { @03F1 stack[-1] = 0x0374 } // Block ends with call to 0x1271, returns to 0x0374 label_03F8: // Incoming jump from 0x022A, if 0x23b872dd == stack[-1] // Inputs[1] { @03F9 msg.value } 03F8 5B JUMPDEST 03F9 34 CALLVALUE 03FA 80 DUP1 03FB 15 ISZERO 03FC 61 PUSH2 0x0404 03FF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F9 stack[0] = msg.value } // Block ends with conditional jump to 0x0404, if !msg.value label_0400: // Incoming jump from 0x03FF, if not !msg.value // Inputs[1] { @0403 memory[0x00:0x00] } 0400 60 PUSH1 0x00 0402 80 DUP1 0403 FD *REVERT // Stack delta = +0 // Outputs[1] { @0403 revert(memory[0x00:0x00]); } // Block terminates label_0404: // Incoming jump from 0x03FF, if !msg.value // Inputs[1] { @040C msg.data.length } 0404 5B JUMPDEST 0405 50 POP 0406 61 PUSH2 0x0358 0409 60 PUSH1 0x04 040B 80 DUP1 040C 36 CALLDATASIZE 040D 03 SUB 040E 60 PUSH1 0x60 0410 81 DUP2 0411 10 LT 0412 15 ISZERO 0413 61 PUSH2 0x041b 0416 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0406 stack[-1] = 0x0358 // @0409 stack[0] = 0x04 // @040D stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x041b, returns to 0x0358, if !(msg.data.length - 0x04 < 0x60) label_0417: // Incoming jump from 0x0416, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @041A memory[0x00:0x00] } 0417 60 PUSH1 0x00 0419 80 DUP1 041A FD *REVERT // Stack delta = +0 // Outputs[1] { @041A revert(memory[0x00:0x00]); } // Block terminates label_041B: // Incoming call from 0x0416, returns to 0x0358, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @0425 stack[-2] // @0426 msg.data[stack[-2]:stack[-2] + 0x20] // @042E msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0436 msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 041B 5B JUMPDEST 041C 50 POP 041D 60 PUSH1 0x01 041F 60 PUSH1 0x01 0421 60 PUSH1 0xa0 0423 1B SHL 0424 03 SUB 0425 81 DUP2 0426 35 CALLDATALOAD 0427 81 DUP2 0428 16 AND 0429 91 SWAP2 042A 60 PUSH1 0x20 042C 81 DUP2 042D 01 ADD 042E 35 CALLDATALOAD 042F 90 SWAP1 0430 91 SWAP2 0431 16 AND 0432 90 SWAP1 0433 60 PUSH1 0x40 0435 01 ADD 0436 35 CALLDATALOAD 0437 61 PUSH2 0x12d5 043A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0429 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0432 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @0436 stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x12d5 label_043B: // Incoming jump from 0x0235, if 0x2ebf040e == stack[-1] // Inputs[1] { @043C msg.value } 043B 5B JUMPDEST 043C 34 CALLVALUE 043D 80 DUP1 043E 15 ISZERO 043F 61 PUSH2 0x0447 0442 57 *JUMPI // Stack delta = +1 // Outputs[1] { @043C stack[0] = msg.value } // Block ends with conditional jump to 0x0447, if !msg.value label_0443: // Incoming jump from 0x0442, if not !msg.value // Inputs[1] { @0446 memory[0x00:0x00] } 0443 60 PUSH1 0x00 0445 80 DUP1 0446 FD *REVERT // Stack delta = +0 // Outputs[1] { @0446 revert(memory[0x00:0x00]); } // Block terminates label_0447: // Incoming jump from 0x0442, if !msg.value 0447 5B JUMPDEST 0448 50 POP 0449 61 PUSH2 0x0374 044C 61 PUSH2 0x1352 044F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0449 stack[-1] = 0x0374 } // Block ends with unconditional jump to 0x1352 label_0450: // Incoming jump from 0x0240, if 0x313ce567 == stack[-1] // Inputs[1] { @0451 msg.value } 0450 5B JUMPDEST 0451 34 CALLVALUE 0452 80 DUP1 0453 15 ISZERO 0454 61 PUSH2 0x045c 0457 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0451 stack[0] = msg.value } // Block ends with conditional jump to 0x045c, if !msg.value label_0458: // Incoming jump from 0x0457, if not !msg.value // Inputs[1] { @045B memory[0x00:0x00] } 0458 60 PUSH1 0x00 045A 80 DUP1 045B FD *REVERT // Stack delta = +0 // Outputs[1] { @045B revert(memory[0x00:0x00]); } // Block terminates label_045C: // Incoming jump from 0x0457, if !msg.value 045C 5B JUMPDEST 045D 50 POP 045E 61 PUSH2 0x0465 0461 61 PUSH2 0x14b8 0464 56 *JUMP // Stack delta = +0 // Outputs[1] { @045E stack[-1] = 0x0465 } // Block ends with call to 0x14b8, returns to 0x0465 label_0465: // Incoming return from call to 0x14B8 at 0x0464 // Inputs[4] // { // @0469 memory[0x40:0x60] // @046D stack[-1] // @0471 memory[0x40:0x60] // @047A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0465 5B JUMPDEST 0466 60 PUSH1 0x40 0468 80 DUP1 0469 51 MLOAD 046A 60 PUSH1 0xff 046C 90 SWAP1 046D 92 SWAP3 046E 16 AND 046F 82 DUP3 0470 52 MSTORE 0471 51 MLOAD 0472 90 SWAP1 0473 81 DUP2 0474 90 SWAP1 0475 03 SUB 0476 60 PUSH1 0x20 0478 01 ADD 0479 90 SWAP1 047A F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0470 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @047A return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_047B: // Incoming jump from 0x024B, if 0x3ac4202f == stack[-1] // Inputs[1] { @047C msg.value } 047B 5B JUMPDEST 047C 34 CALLVALUE 047D 80 DUP1 047E 15 ISZERO 047F 61 PUSH2 0x0487 0482 57 *JUMPI // Stack delta = +1 // Outputs[1] { @047C stack[0] = msg.value } // Block ends with conditional jump to 0x0487, if !msg.value label_0483: // Incoming jump from 0x0482, if not !msg.value // Inputs[1] { @0486 memory[0x00:0x00] } 0483 60 PUSH1 0x00 0485 80 DUP1 0486 FD *REVERT // Stack delta = +0 // Outputs[1] { @0486 revert(memory[0x00:0x00]); } // Block terminates label_0487: // Incoming jump from 0x0482, if !msg.value 0487 5B JUMPDEST 0488 50 POP 0489 61 PUSH2 0x0358 048C 61 PUSH2 0x14c1 048F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0489 stack[-1] = 0x0358 } // Block ends with call to 0x14c1, returns to 0x0358 label_0490: // Incoming jump from 0x01C2, if 0x3af9e669 == stack[-1] // Inputs[1] { @0491 msg.value } 0490 5B JUMPDEST 0491 34 CALLVALUE 0492 80 DUP1 0493 15 ISZERO 0494 61 PUSH2 0x049c 0497 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0491 stack[0] = msg.value } // Block ends with conditional jump to 0x049c, if !msg.value label_0498: // Incoming jump from 0x0497, if not !msg.value // Inputs[1] { @049B memory[0x00:0x00] } 0498 60 PUSH1 0x00 049A 80 DUP1 049B FD *REVERT // Stack delta = +0 // Outputs[1] { @049B revert(memory[0x00:0x00]); } // Block terminates label_049C: // Incoming jump from 0x0497, if !msg.value // Inputs[1] { @04A4 msg.data.length } 049C 5B JUMPDEST 049D 50 POP 049E 61 PUSH2 0x0374 04A1 60 PUSH1 0x04 04A3 80 DUP1 04A4 36 CALLDATASIZE 04A5 03 SUB 04A6 60 PUSH1 0x20 04A8 81 DUP2 04A9 10 LT 04AA 15 ISZERO 04AB 61 PUSH2 0x04b3 04AE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @049E stack[-1] = 0x0374 // @04A1 stack[0] = 0x04 // @04A5 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x04b3, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_04AF: // Incoming jump from 0x04AE, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @04B2 memory[0x00:0x00] } 04AF 60 PUSH1 0x00 04B1 80 DUP1 04B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B2 revert(memory[0x00:0x00]); } // Block terminates label_04B3: // Incoming call from 0x04AE, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @04B5 stack[-2] // @04B5 msg.data[stack[-2]:stack[-2] + 0x20] // } 04B3 5B JUMPDEST 04B4 50 POP 04B5 35 CALLDATALOAD 04B6 60 PUSH1 0x01 04B8 60 PUSH1 0x01 04BA 60 PUSH1 0xa0 04BC 1B SHL 04BD 03 SUB 04BE 16 AND 04BF 61 PUSH2 0x14c6 04C2 56 *JUMP // Stack delta = -1 // Outputs[1] { @04BE stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x14c6 label_04C3: // Incoming jump from 0x01CD, if 0x3b1d21a2 == stack[-1] // Inputs[1] { @04C4 msg.value } 04C3 5B JUMPDEST 04C4 34 CALLVALUE 04C5 80 DUP1 04C6 15 ISZERO 04C7 61 PUSH2 0x04cf 04CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C4 stack[0] = msg.value } // Block ends with conditional jump to 0x04cf, if !msg.value label_04CB: // Incoming jump from 0x04CA, if not !msg.value // Inputs[1] { @04CE memory[0x00:0x00] } 04CB 60 PUSH1 0x00 04CD 80 DUP1 04CE FD *REVERT // Stack delta = +0 // Outputs[1] { @04CE revert(memory[0x00:0x00]); } // Block terminates label_04CF: // Incoming jump from 0x04CA, if !msg.value 04CF 5B JUMPDEST 04D0 50 POP 04D1 61 PUSH2 0x0374 04D4 61 PUSH2 0x1568 04D7 56 *JUMP // Stack delta = +0 // Outputs[1] { @04D1 stack[-1] = 0x0374 } // Block ends with unconditional jump to 0x1568 label_04D8: // Incoming jump from 0x01D8, if 0x47bd3718 == stack[-1] // Inputs[1] { @04D9 msg.value } 04D8 5B JUMPDEST 04D9 34 CALLVALUE 04DA 80 DUP1 04DB 15 ISZERO 04DC 61 PUSH2 0x04e4 04DF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D9 stack[0] = msg.value } // Block ends with conditional jump to 0x04e4, if !msg.value label_04E0: // Incoming jump from 0x04DF, if not !msg.value // Inputs[1] { @04E3 memory[0x00:0x00] } 04E0 60 PUSH1 0x00 04E2 80 DUP1 04E3 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E3 revert(memory[0x00:0x00]); } // Block terminates label_04E4: // Incoming jump from 0x04DF, if !msg.value 04E4 5B JUMPDEST 04E5 50 POP 04E6 61 PUSH2 0x0374 04E9 61 PUSH2 0x1572 04EC 56 *JUMP // Stack delta = +0 // Outputs[1] { @04E6 stack[-1] = 0x0374 } // Block ends with call to 0x1572, returns to 0x0374 label_04ED: // Incoming jump from 0x01E3, if 0x4dc3487d == stack[-1] // Inputs[1] { @04EE msg.value } 04ED 5B JUMPDEST 04EE 34 CALLVALUE 04EF 80 DUP1 04F0 15 ISZERO 04F1 61 PUSH2 0x04f9 04F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04EE stack[0] = msg.value } // Block ends with conditional jump to 0x04f9, if !msg.value label_04F5: // Incoming jump from 0x04F4, if not !msg.value // Inputs[1] { @04F8 memory[0x00:0x00] } 04F5 60 PUSH1 0x00 04F7 80 DUP1 04F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F8 revert(memory[0x00:0x00]); } // Block terminates label_04F9: // Incoming jump from 0x04F4, if !msg.value // Inputs[1] { @0501 msg.data.length } 04F9 5B JUMPDEST 04FA 50 POP 04FB 61 PUSH2 0x0374 04FE 60 PUSH1 0x04 0500 80 DUP1 0501 36 CALLDATASIZE 0502 03 SUB 0503 60 PUSH1 0x20 0505 81 DUP2 0506 10 LT 0507 15 ISZERO 0508 61 PUSH2 0x0510 050B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @04FB stack[-1] = 0x0374 // @04FE stack[0] = 0x04 // @0502 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0510, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_050C: // Incoming jump from 0x050B, if not !(msg.data.length - 0x04 < 0x20) // 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 call from 0x050B, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0512 stack[-2] // @0512 msg.data[stack[-2]:stack[-2] + 0x20] // } 0510 5B JUMPDEST 0511 50 POP 0512 35 CALLDATALOAD 0513 60 PUSH1 0x01 0515 60 PUSH1 0x01 0517 60 PUSH1 0xa0 0519 1B SHL 051A 03 SUB 051B 16 AND 051C 61 PUSH2 0x1578 051F 56 *JUMP // Stack delta = -1 // Outputs[1] { @051B stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1578 label_0520: // Incoming jump from 0x01EE, if 0x4e4d9fea == stack[-1] 0520 5B JUMPDEST 0521 61 PUSH2 0x0528 0524 61 PUSH2 0x158a 0527 56 *JUMP // Stack delta = +1 // Outputs[1] { @0521 stack[0] = 0x0528 } // Block ends with unconditional jump to 0x158a 0528 5B JUMPDEST 0529 60 PUSH1 0x40 052B 80 DUP1 052C 51 MLOAD 052D 92 SWAP3 052E 83 DUP4 052F 52 MSTORE 0530 60 PUSH1 0x20 0532 83 DUP4 0533 01 ADD 0534 91 SWAP2 0535 90 SWAP1 0536 91 SWAP2 0537 52 MSTORE 0538 80 DUP1 0539 51 MLOAD 053A 91 SWAP2 053B 82 DUP3 053C 90 SWAP1 053D 03 SUB 053E 01 ADD 053F 90 SWAP1 0540 F3 *RETURN label_0541: // Incoming jump from 0x01F9, if 0x601a0bf1 == stack[-1] // Inputs[1] { @0542 msg.value } 0541 5B JUMPDEST 0542 34 CALLVALUE 0543 80 DUP1 0544 15 ISZERO 0545 61 PUSH2 0x054d 0548 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0542 stack[0] = msg.value } // Block ends with conditional jump to 0x054d, if !msg.value label_0549: // Incoming jump from 0x0548, if not !msg.value // Inputs[1] { @054C memory[0x00:0x00] } 0549 60 PUSH1 0x00 054B 80 DUP1 054C FD *REVERT // Stack delta = +0 // Outputs[1] { @054C revert(memory[0x00:0x00]); } // Block terminates label_054D: // Incoming jump from 0x0548, if !msg.value // Inputs[1] { @0555 msg.data.length } 054D 5B JUMPDEST 054E 50 POP 054F 61 PUSH2 0x0374 0552 60 PUSH1 0x04 0554 80 DUP1 0555 36 CALLDATASIZE 0556 03 SUB 0557 60 PUSH1 0x20 0559 81 DUP2 055A 10 LT 055B 15 ISZERO 055C 61 PUSH2 0x0564 055F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @054F stack[-1] = 0x0374 // @0552 stack[0] = 0x04 // @0556 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0564, if !(msg.data.length - 0x04 < 0x20) label_0560: // Incoming jump from 0x055F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0563 memory[0x00:0x00] } 0560 60 PUSH1 0x00 0562 80 DUP1 0563 FD *REVERT // Stack delta = +0 // Outputs[1] { @0563 revert(memory[0x00:0x00]); } // Block terminates label_0564: // Incoming jump from 0x055F, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0566 msg.data[stack[-2]:stack[-2] + 0x20] // @0566 stack[-2] // } 0564 5B JUMPDEST 0565 50 POP 0566 35 CALLDATALOAD 0567 61 PUSH2 0x162d 056A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0566 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x162d label_056B: // Incoming jump from 0x017B, if 0x6c540baf == stack[-1] // Inputs[1] { @056C msg.value } 056B 5B JUMPDEST 056C 34 CALLVALUE 056D 80 DUP1 056E 15 ISZERO 056F 61 PUSH2 0x0577 0572 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056C stack[0] = msg.value } // Block ends with conditional jump to 0x0577, if !msg.value label_0573: // Incoming jump from 0x0572, if not !msg.value // Inputs[1] { @0576 memory[0x00:0x00] } 0573 60 PUSH1 0x00 0575 80 DUP1 0576 FD *REVERT // Stack delta = +0 // Outputs[1] { @0576 revert(memory[0x00:0x00]); } // Block terminates label_0577: // Incoming jump from 0x0572, if !msg.value 0577 5B JUMPDEST 0578 50 POP 0579 61 PUSH2 0x0374 057C 61 PUSH2 0x1688 057F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0579 stack[-1] = 0x0374 } // Block ends with call to 0x1688, returns to 0x0374 label_0580: // Incoming jump from 0x0186, if 0x704b6c02 == stack[-1] // Inputs[1] { @0581 msg.value } 0580 5B JUMPDEST 0581 34 CALLVALUE 0582 80 DUP1 0583 15 ISZERO 0584 61 PUSH2 0x058c 0587 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0581 stack[0] = msg.value } // Block ends with conditional jump to 0x058c, if !msg.value label_0588: // Incoming jump from 0x0587, if not !msg.value // Inputs[1] { @058B memory[0x00:0x00] } 0588 60 PUSH1 0x00 058A 80 DUP1 058B FD *REVERT // Stack delta = +0 // Outputs[1] { @058B revert(memory[0x00:0x00]); } // Block terminates label_058C: // Incoming jump from 0x0587, if !msg.value // Inputs[1] { @0594 msg.data.length } 058C 5B JUMPDEST 058D 50 POP 058E 61 PUSH2 0x05b3 0591 60 PUSH1 0x04 0593 80 DUP1 0594 36 CALLDATASIZE 0595 03 SUB 0596 60 PUSH1 0x20 0598 81 DUP2 0599 10 LT 059A 15 ISZERO 059B 61 PUSH2 0x05a3 059E 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @058E stack[-1] = 0x05b3 // @0591 stack[0] = 0x04 // @0595 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05a3, returns to 0x05B3, if !(msg.data.length - 0x04 < 0x20) label_059F: // Incoming jump from 0x059E, if not !(msg.data.length - 0x04 < 0x20) // 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 call from 0x059E, returns to 0x05B3, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @05A5 stack[-2] // @05A5 msg.data[stack[-2]:stack[-2] + 0x20] // } 05A3 5B JUMPDEST 05A4 50 POP 05A5 35 CALLDATALOAD 05A6 60 PUSH1 0x01 05A8 60 PUSH1 0x01 05AA 60 PUSH1 0xa0 05AC 1B SHL 05AD 03 SUB 05AE 16 AND 05AF 61 PUSH2 0x168e 05B2 56 *JUMP // Stack delta = -1 // Outputs[1] { @05AE stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x168e label_05B3: // Incoming return from call to 0x05A3 at 0x059E // Incoming return from call to 0x0763 at 0x075E 05B3 5B JUMPDEST 05B4 00 *STOP // Stack delta = +0 // Outputs[1] { @05B4 stop(); } // Block terminates label_05B5: // Incoming jump from 0x0191, if 0x70a08231 == stack[-1] // Inputs[1] { @05B6 msg.value } 05B5 5B JUMPDEST 05B6 34 CALLVALUE 05B7 80 DUP1 05B8 15 ISZERO 05B9 61 PUSH2 0x05c1 05BC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B6 stack[0] = msg.value } // Block ends with conditional jump to 0x05c1, if !msg.value label_05BD: // Incoming jump from 0x05BC, if not !msg.value // Inputs[1] { @05C0 memory[0x00:0x00] } 05BD 60 PUSH1 0x00 05BF 80 DUP1 05C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05C0 revert(memory[0x00:0x00]); } // Block terminates label_05C1: // Incoming jump from 0x05BC, if !msg.value // Inputs[1] { @05C9 msg.data.length } 05C1 5B JUMPDEST 05C2 50 POP 05C3 61 PUSH2 0x0374 05C6 60 PUSH1 0x04 05C8 80 DUP1 05C9 36 CALLDATASIZE 05CA 03 SUB 05CB 60 PUSH1 0x20 05CD 81 DUP2 05CE 10 LT 05CF 15 ISZERO 05D0 61 PUSH2 0x05d8 05D3 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @05C3 stack[-1] = 0x0374 // @05C6 stack[0] = 0x04 // @05CA stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05d8, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_05D4: // Incoming jump from 0x05D3, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @05D7 memory[0x00:0x00] } 05D4 60 PUSH1 0x00 05D6 80 DUP1 05D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D7 revert(memory[0x00:0x00]); } // Block terminates label_05D8: // Incoming call from 0x05D3, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @05DA stack[-2] // @05DA msg.data[stack[-2]:stack[-2] + 0x20] // } 05D8 5B JUMPDEST 05D9 50 POP 05DA 35 CALLDATALOAD 05DB 60 PUSH1 0x01 05DD 60 PUSH1 0x01 05DF 60 PUSH1 0xa0 05E1 1B SHL 05E2 03 SUB 05E3 16 AND 05E4 61 PUSH2 0x1741 05E7 56 *JUMP // Stack delta = -1 // Outputs[1] { @05E3 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1741 label_05E8: // Incoming jump from 0x019C, if 0x73acee98 == stack[-1] // Inputs[1] { @05E9 msg.value } 05E8 5B JUMPDEST 05E9 34 CALLVALUE 05EA 80 DUP1 05EB 15 ISZERO 05EC 61 PUSH2 0x05f4 05EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05E9 stack[0] = msg.value } // Block ends with conditional jump to 0x05f4, if !msg.value label_05F0: // Incoming jump from 0x05EF, if not !msg.value // Inputs[1] { @05F3 memory[0x00:0x00] } 05F0 60 PUSH1 0x00 05F2 80 DUP1 05F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05F3 revert(memory[0x00:0x00]); } // Block terminates label_05F4: // Incoming jump from 0x05EF, if !msg.value 05F4 5B JUMPDEST 05F5 50 POP 05F6 61 PUSH2 0x0374 05F9 61 PUSH2 0x175c 05FC 56 *JUMP // Stack delta = +0 // Outputs[1] { @05F6 stack[-1] = 0x0374 } // Block ends with call to 0x175c, returns to 0x0374 label_05FD: // Incoming jump from 0x01A7, if 0x852a12e3 == stack[-1] // Inputs[1] { @05FE msg.value } 05FD 5B JUMPDEST 05FE 34 CALLVALUE 05FF 80 DUP1 0600 15 ISZERO 0601 61 PUSH2 0x0609 0604 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05FE stack[0] = msg.value } // Block ends with conditional jump to 0x0609, if !msg.value label_0605: // Incoming jump from 0x0604, if not !msg.value // Inputs[1] { @0608 memory[0x00:0x00] } 0605 60 PUSH1 0x00 0607 80 DUP1 0608 FD *REVERT // Stack delta = +0 // Outputs[1] { @0608 revert(memory[0x00:0x00]); } // Block terminates label_0609: // Incoming jump from 0x0604, if !msg.value // Inputs[1] { @0611 msg.data.length } 0609 5B JUMPDEST 060A 50 POP 060B 61 PUSH2 0x0374 060E 60 PUSH1 0x04 0610 80 DUP1 0611 36 CALLDATASIZE 0612 03 SUB 0613 60 PUSH1 0x20 0615 81 DUP2 0616 10 LT 0617 15 ISZERO 0618 61 PUSH2 0x0620 061B 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @060B stack[-1] = 0x0374 // @060E stack[0] = 0x04 // @0612 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0620, if !(msg.data.length - 0x04 < 0x20) label_061C: // Incoming jump from 0x061B, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @061F memory[0x00:0x00] } 061C 60 PUSH1 0x00 061E 80 DUP1 061F FD *REVERT // Stack delta = +0 // Outputs[1] { @061F revert(memory[0x00:0x00]); } // Block terminates label_0620: // Incoming jump from 0x061B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0622 stack[-2] // @0622 msg.data[stack[-2]:stack[-2] + 0x20] // } 0620 5B JUMPDEST 0621 50 POP 0622 35 CALLDATALOAD 0623 61 PUSH2 0x180f 0626 56 *JUMP // Stack delta = -1 // Outputs[1] { @0622 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x180f label_0627: // Incoming jump from 0x01B2, if 0x8f840ddd == stack[-1] // Inputs[1] { @0628 msg.value } 0627 5B JUMPDEST 0628 34 CALLVALUE 0629 80 DUP1 062A 15 ISZERO 062B 61 PUSH2 0x0633 062E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0628 stack[0] = msg.value } // Block ends with conditional jump to 0x0633, if !msg.value label_062F: // Incoming jump from 0x062E, if not !msg.value // Inputs[1] { @0632 memory[0x00:0x00] } 062F 60 PUSH1 0x00 0631 80 DUP1 0632 FD *REVERT // Stack delta = +0 // Outputs[1] { @0632 revert(memory[0x00:0x00]); } // Block terminates label_0633: // Incoming jump from 0x062E, if !msg.value 0633 5B JUMPDEST 0634 50 POP 0635 61 PUSH2 0x0374 0638 61 PUSH2 0x18b0 063B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0635 stack[-1] = 0x0374 } // Block ends with call to 0x18b0, returns to 0x0374 label_063C: // Incoming jump from 0x011E, if 0x92eefe9b == stack[-1] // Inputs[1] { @063D msg.value } 063C 5B JUMPDEST 063D 34 CALLVALUE 063E 80 DUP1 063F 15 ISZERO 0640 61 PUSH2 0x0648 0643 57 *JUMPI // Stack delta = +1 // Outputs[1] { @063D stack[0] = msg.value } // Block ends with conditional jump to 0x0648, if !msg.value label_0644: // Incoming jump from 0x0643, if not !msg.value // Inputs[1] { @0647 memory[0x00:0x00] } 0644 60 PUSH1 0x00 0646 80 DUP1 0647 FD *REVERT // Stack delta = +0 // Outputs[1] { @0647 revert(memory[0x00:0x00]); } // Block terminates label_0648: // Incoming jump from 0x0643, if !msg.value // Inputs[1] { @0650 msg.data.length } 0648 5B JUMPDEST 0649 50 POP 064A 61 PUSH2 0x0374 064D 60 PUSH1 0x04 064F 80 DUP1 0650 36 CALLDATASIZE 0651 03 SUB 0652 60 PUSH1 0x20 0654 81 DUP2 0655 10 LT 0656 15 ISZERO 0657 61 PUSH2 0x065f 065A 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @064A stack[-1] = 0x0374 // @064D stack[0] = 0x04 // @0651 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x065f, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_065B: // Incoming jump from 0x065A, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @065E memory[0x00:0x00] } 065B 60 PUSH1 0x00 065D 80 DUP1 065E FD *REVERT // Stack delta = +0 // Outputs[1] { @065E revert(memory[0x00:0x00]); } // Block terminates label_065F: // Incoming call from 0x065A, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0661 msg.data[stack[-2]:stack[-2] + 0x20] // @0661 stack[-2] // } 065F 5B JUMPDEST 0660 50 POP 0661 35 CALLDATALOAD 0662 60 PUSH1 0x01 0664 60 PUSH1 0x01 0666 60 PUSH1 0xa0 0668 1B SHL 0669 03 SUB 066A 16 AND 066B 61 PUSH2 0x18b6 066E 56 *JUMP // Stack delta = -1 // Outputs[1] { @066A stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x18b6 label_066F: // Incoming jump from 0x0129, if 0x954f92a3 == stack[-1] // Inputs[1] { @0670 msg.value } 066F 5B JUMPDEST 0670 34 CALLVALUE 0671 80 DUP1 0672 15 ISZERO 0673 61 PUSH2 0x067b 0676 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0670 stack[0] = msg.value } // Block ends with conditional jump to 0x067b, if !msg.value label_0677: // Incoming jump from 0x0676, if not !msg.value // Inputs[1] { @067A memory[0x00:0x00] } 0677 60 PUSH1 0x00 0679 80 DUP1 067A FD *REVERT // Stack delta = +0 // Outputs[1] { @067A revert(memory[0x00:0x00]); } // Block terminates label_067B: // Incoming jump from 0x0676, if !msg.value // Inputs[1] { @0683 msg.data.length } 067B 5B JUMPDEST 067C 50 POP 067D 61 PUSH2 0x0374 0680 60 PUSH1 0x04 0682 80 DUP1 0683 36 CALLDATASIZE 0684 03 SUB 0685 60 PUSH1 0x20 0687 81 DUP2 0688 10 LT 0689 15 ISZERO 068A 61 PUSH2 0x0692 068D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @067D stack[-1] = 0x0374 // @0680 stack[0] = 0x04 // @0684 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0692, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_068E: // Incoming jump from 0x068D, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0691 memory[0x00:0x00] } 068E 60 PUSH1 0x00 0690 80 DUP1 0691 FD *REVERT // Stack delta = +0 // Outputs[1] { @0691 revert(memory[0x00:0x00]); } // Block terminates label_0692: // Incoming call from 0x068D, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0694 stack[-2] // @0694 msg.data[stack[-2]:stack[-2] + 0x20] // } 0692 5B JUMPDEST 0693 50 POP 0694 35 CALLDATALOAD 0695 60 PUSH1 0x01 0697 60 PUSH1 0x01 0699 60 PUSH1 0xa0 069B 1B SHL 069C 03 SUB 069D 16 AND 069E 61 PUSH2 0x196c 06A1 56 *JUMP // Stack delta = -1 // Outputs[1] { @069D stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x196c label_06A2: // Incoming jump from 0x0134, if 0x95d89b41 == stack[-1] // Inputs[1] { @06A3 msg.value } 06A2 5B JUMPDEST 06A3 34 CALLVALUE 06A4 80 DUP1 06A5 15 ISZERO 06A6 61 PUSH2 0x06ae 06A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06A3 stack[0] = msg.value } // Block ends with conditional jump to 0x06ae, if !msg.value label_06AA: // Incoming jump from 0x06A9, if not !msg.value // Inputs[1] { @06AD memory[0x00:0x00] } 06AA 60 PUSH1 0x00 06AC 80 DUP1 06AD FD *REVERT // Stack delta = +0 // Outputs[1] { @06AD revert(memory[0x00:0x00]); } // Block terminates label_06AE: // Incoming jump from 0x06A9, if !msg.value 06AE 5B JUMPDEST 06AF 50 POP 06B0 61 PUSH2 0x02aa 06B3 61 PUSH2 0x197e 06B6 56 *JUMP // Stack delta = +0 // Outputs[1] { @06B0 stack[-1] = 0x02aa } // Block ends with call to 0x197e, returns to 0x02AA label_06B7: // Incoming jump from 0x013F, if 0x95dd9193 == stack[-1] // Inputs[1] { @06B8 msg.value } 06B7 5B JUMPDEST 06B8 34 CALLVALUE 06B9 80 DUP1 06BA 15 ISZERO 06BB 61 PUSH2 0x06c3 06BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06B8 stack[0] = msg.value } // Block ends with conditional jump to 0x06c3, if !msg.value label_06BF: // Incoming jump from 0x06BE, if not !msg.value // Inputs[1] { @06C2 memory[0x00:0x00] } 06BF 60 PUSH1 0x00 06C1 80 DUP1 06C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C2 revert(memory[0x00:0x00]); } // Block terminates label_06C3: // Incoming jump from 0x06BE, if !msg.value // Inputs[1] { @06CB msg.data.length } 06C3 5B JUMPDEST 06C4 50 POP 06C5 61 PUSH2 0x0374 06C8 60 PUSH1 0x04 06CA 80 DUP1 06CB 36 CALLDATASIZE 06CC 03 SUB 06CD 60 PUSH1 0x20 06CF 81 DUP2 06D0 10 LT 06D1 15 ISZERO 06D2 61 PUSH2 0x06da 06D5 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @06C5 stack[-1] = 0x0374 // @06C8 stack[0] = 0x04 // @06CC stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06da, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_06D6: // Incoming jump from 0x06D5, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06D9 memory[0x00:0x00] } 06D6 60 PUSH1 0x00 06D8 80 DUP1 06D9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06D9 revert(memory[0x00:0x00]); } // Block terminates label_06DA: // Incoming call from 0x06D5, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @06DC stack[-2] // @06DC msg.data[stack[-2]:stack[-2] + 0x20] // } 06DA 5B JUMPDEST 06DB 50 POP 06DC 35 CALLDATALOAD 06DD 60 PUSH1 0x01 06DF 60 PUSH1 0x01 06E1 60 PUSH1 0xa0 06E3 1B SHL 06E4 03 SUB 06E5 16 AND 06E6 61 PUSH2 0x19d9 06E9 56 *JUMP // Stack delta = -1 // Outputs[1] { @06E5 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x19d9 label_06EA: // Incoming jump from 0x014A, if 0xa6afed95 == stack[-1] // Inputs[1] { @06EB msg.value } 06EA 5B JUMPDEST 06EB 34 CALLVALUE 06EC 80 DUP1 06ED 15 ISZERO 06EE 61 PUSH2 0x06f6 06F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06EB stack[0] = msg.value } // Block ends with conditional jump to 0x06f6, if !msg.value label_06F2: // Incoming jump from 0x06F1, if not !msg.value // Inputs[1] { @06F5 memory[0x00:0x00] } 06F2 60 PUSH1 0x00 06F4 80 DUP1 06F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @06F5 revert(memory[0x00:0x00]); } // Block terminates label_06F6: // Incoming jump from 0x06F1, if !msg.value 06F6 5B JUMPDEST 06F7 50 POP 06F8 61 PUSH2 0x0374 06FB 61 PUSH2 0x1a38 06FE 56 *JUMP // Stack delta = +0 // Outputs[1] { @06F8 stack[-1] = 0x0374 } // Block ends with call to 0x1a38, returns to 0x0374 label_06FF: // Incoming jump from 0x0155, if 0xa9059cbb == stack[-1] // Inputs[1] { @0700 msg.value } 06FF 5B JUMPDEST 0700 34 CALLVALUE 0701 80 DUP1 0702 15 ISZERO 0703 61 PUSH2 0x070b 0706 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0700 stack[0] = msg.value } // Block ends with conditional jump to 0x070b, if !msg.value label_0707: // Incoming jump from 0x0706, if not !msg.value // Inputs[1] { @070A memory[0x00:0x00] } 0707 60 PUSH1 0x00 0709 80 DUP1 070A FD *REVERT // Stack delta = +0 // Outputs[1] { @070A revert(memory[0x00:0x00]); } // Block terminates label_070B: // Incoming jump from 0x0706, if !msg.value // Inputs[1] { @0713 msg.data.length } 070B 5B JUMPDEST 070C 50 POP 070D 61 PUSH2 0x0358 0710 60 PUSH1 0x04 0712 80 DUP1 0713 36 CALLDATASIZE 0714 03 SUB 0715 60 PUSH1 0x40 0717 81 DUP2 0718 10 LT 0719 15 ISZERO 071A 61 PUSH2 0x0722 071D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @070D stack[-1] = 0x0358 // @0710 stack[0] = 0x04 // @0714 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0722, returns to 0x0358, if !(msg.data.length - 0x04 < 0x40) label_071E: // Incoming jump from 0x071D, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0721 memory[0x00:0x00] } 071E 60 PUSH1 0x00 0720 80 DUP1 0721 FD *REVERT // Stack delta = +0 // Outputs[1] { @0721 revert(memory[0x00:0x00]); } // Block terminates label_0722: // Incoming call from 0x071D, returns to 0x0358, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @072C stack[-2] // @072D msg.data[stack[-2]:stack[-2] + 0x20] // @0733 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0722 5B JUMPDEST 0723 50 POP 0724 60 PUSH1 0x01 0726 60 PUSH1 0x01 0728 60 PUSH1 0xa0 072A 1B SHL 072B 03 SUB 072C 81 DUP2 072D 35 CALLDATALOAD 072E 16 AND 072F 90 SWAP1 0730 60 PUSH1 0x20 0732 01 ADD 0733 35 CALLDATALOAD 0734 61 PUSH2 0x1dc5 0737 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @072F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // @0733 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1dc5 label_0738: // Incoming jump from 0x00D7, if 0xaa5af0fd == stack[-1] // Inputs[1] { @0739 msg.value } 0738 5B JUMPDEST 0739 34 CALLVALUE 073A 80 DUP1 073B 15 ISZERO 073C 61 PUSH2 0x0744 073F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0739 stack[0] = msg.value } // Block ends with conditional jump to 0x0744, if !msg.value label_0740: // Incoming jump from 0x073F, if not !msg.value // Inputs[1] { @0743 memory[0x00:0x00] } 0740 60 PUSH1 0x00 0742 80 DUP1 0743 FD *REVERT // Stack delta = +0 // Outputs[1] { @0743 revert(memory[0x00:0x00]); } // Block terminates label_0744: // Incoming jump from 0x073F, if !msg.value 0744 5B JUMPDEST 0745 50 POP 0746 61 PUSH2 0x0374 0749 61 PUSH2 0x1e41 074C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0746 stack[-1] = 0x0374 } // Block ends with call to 0x1e41, returns to 0x0374 label_074D: // Incoming jump from 0x00E2, if 0xaae40a2a == stack[-1] // Inputs[1] { @0754 msg.data.length } 074D 5B JUMPDEST 074E 61 PUSH2 0x05b3 0751 60 PUSH1 0x04 0753 80 DUP1 0754 36 CALLDATASIZE 0755 03 SUB 0756 60 PUSH1 0x40 0758 81 DUP2 0759 10 LT 075A 15 ISZERO 075B 61 PUSH2 0x0763 075E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @074E stack[0] = 0x05b3 // @0751 stack[1] = 0x04 // @0755 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0763, returns to 0x05B3, if !(msg.data.length - 0x04 < 0x40) label_075F: // Incoming jump from 0x075E, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0762 memory[0x00:0x00] } 075F 60 PUSH1 0x00 0761 80 DUP1 0762 FD *REVERT // Stack delta = +0 // Outputs[1] { @0762 revert(memory[0x00:0x00]); } // Block terminates label_0763: // Incoming call from 0x075E, returns to 0x05B3, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @076D stack[-2] // @076E msg.data[stack[-2]:stack[-2] + 0x20] // @0775 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0763 5B JUMPDEST 0764 50 POP 0765 60 PUSH1 0x01 0767 60 PUSH1 0x01 0769 60 PUSH1 0xa0 076B 1B SHL 076C 03 SUB 076D 81 DUP2 076E 35 CALLDATALOAD 076F 81 DUP2 0770 16 AND 0771 91 SWAP2 0772 60 PUSH1 0x20 0774 01 ADD 0775 35 CALLDATALOAD 0776 16 AND 0777 61 PUSH2 0x1e47 077A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0771 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0776 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x1e47 label_077B: // Incoming jump from 0x00ED, if 0xae9d70b0 == stack[-1] // Inputs[1] { @077C msg.value } 077B 5B JUMPDEST 077C 34 CALLVALUE 077D 80 DUP1 077E 15 ISZERO 077F 61 PUSH2 0x0787 0782 57 *JUMPI // Stack delta = +1 // Outputs[1] { @077C stack[0] = msg.value } // Block ends with conditional jump to 0x0787, if !msg.value label_0783: // Incoming jump from 0x0782, if not !msg.value // Inputs[1] { @0786 memory[0x00:0x00] } 0783 60 PUSH1 0x00 0785 80 DUP1 0786 FD *REVERT // Stack delta = +0 // Outputs[1] { @0786 revert(memory[0x00:0x00]); } // Block terminates label_0787: // Incoming jump from 0x0782, if !msg.value 0787 5B JUMPDEST 0788 50 POP 0789 61 PUSH2 0x0374 078C 61 PUSH2 0x1e84 078F 56 *JUMP // Stack delta = +0 // Outputs[1] { @0789 stack[-1] = 0x0374 } // Block ends with call to 0x1e84, returns to 0x0374 label_0790: // Incoming jump from 0x00F8, if 0xb2a02ff1 == stack[-1] // Inputs[1] { @0791 msg.value } 0790 5B JUMPDEST 0791 34 CALLVALUE 0792 80 DUP1 0793 15 ISZERO 0794 61 PUSH2 0x079c 0797 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0791 stack[0] = msg.value } // Block ends with conditional jump to 0x079c, if !msg.value label_0798: // Incoming jump from 0x0797, if not !msg.value // Inputs[1] { @079B memory[0x00:0x00] } 0798 60 PUSH1 0x00 079A 80 DUP1 079B FD *REVERT // Stack delta = +0 // Outputs[1] { @079B revert(memory[0x00:0x00]); } // Block terminates label_079C: // Incoming jump from 0x0797, if !msg.value // Inputs[1] { @07A4 msg.data.length } 079C 5B JUMPDEST 079D 50 POP 079E 61 PUSH2 0x0374 07A1 60 PUSH1 0x04 07A3 80 DUP1 07A4 36 CALLDATASIZE 07A5 03 SUB 07A6 60 PUSH1 0x60 07A8 81 DUP2 07A9 10 LT 07AA 15 ISZERO 07AB 61 PUSH2 0x07b3 07AE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @079E stack[-1] = 0x0374 // @07A1 stack[0] = 0x04 // @07A5 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x07b3, returns to 0x0374, if !(msg.data.length - 0x04 < 0x60) label_07AF: // Incoming jump from 0x07AE, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @07B2 memory[0x00:0x00] } 07AF 60 PUSH1 0x00 07B1 80 DUP1 07B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @07B2 revert(memory[0x00:0x00]); } // Block terminates label_07B3: // Incoming call from 0x07AE, returns to 0x0374, if !(msg.data.length - 0x04 < 0x60) // Inputs[4] // { // @07BD stack[-2] // @07BE msg.data[stack[-2]:stack[-2] + 0x20] // @07C6 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @07CE msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } 07B3 5B JUMPDEST 07B4 50 POP 07B5 60 PUSH1 0x01 07B7 60 PUSH1 0x01 07B9 60 PUSH1 0xa0 07BB 1B SHL 07BC 03 SUB 07BD 81 DUP2 07BE 35 CALLDATALOAD 07BF 81 DUP2 07C0 16 AND 07C1 91 SWAP2 07C2 60 PUSH1 0x20 07C4 81 DUP2 07C5 01 ADD 07C6 35 CALLDATALOAD 07C7 90 SWAP1 07C8 91 SWAP2 07C9 16 AND 07CA 90 SWAP1 07CB 60 PUSH1 0x40 07CD 01 ADD 07CE 35 CALLDATALOAD 07CF 61 PUSH2 0x1f23 07D2 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @07C1 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @07CA stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @07CE stack[0] = msg.data[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1f23 label_07D3: // Incoming jump from 0x0103, if 0xbd6d894d == stack[-1] // Inputs[1] { @07D4 msg.value } 07D3 5B JUMPDEST 07D4 34 CALLVALUE 07D5 80 DUP1 07D6 15 ISZERO 07D7 61 PUSH2 0x07df 07DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07D4 stack[0] = msg.value } // Block ends with conditional jump to 0x07df, if !msg.value label_07DB: // Incoming jump from 0x07DA, if not !msg.value // Inputs[1] { @07DE memory[0x00:0x00] } 07DB 60 PUSH1 0x00 07DD 80 DUP1 07DE FD *REVERT // Stack delta = +0 // Outputs[1] { @07DE revert(memory[0x00:0x00]); } // Block terminates label_07DF: // Incoming jump from 0x07DA, if !msg.value 07DF 5B JUMPDEST 07E0 50 POP 07E1 61 PUSH2 0x0374 07E4 61 PUSH2 0x1f9f 07E7 56 *JUMP // Stack delta = +0 // Outputs[1] { @07E1 stack[-1] = 0x0374 } // Block ends with call to 0x1f9f, returns to 0x0374 label_07E8: // Incoming jump from 0x010E, if 0xc37f68e2 == stack[-1] // Inputs[1] { @07E9 msg.value } 07E8 5B JUMPDEST 07E9 34 CALLVALUE 07EA 80 DUP1 07EB 15 ISZERO 07EC 61 PUSH2 0x07f4 07EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07E9 stack[0] = msg.value } // Block ends with conditional jump to 0x07f4, if !msg.value label_07F0: // Incoming jump from 0x07EF, if not !msg.value // Inputs[1] { @07F3 memory[0x00:0x00] } 07F0 60 PUSH1 0x00 07F2 80 DUP1 07F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @07F3 revert(memory[0x00:0x00]); } // Block terminates label_07F4: // Incoming jump from 0x07EF, if !msg.value // Inputs[1] { @07FC msg.data.length } 07F4 5B JUMPDEST 07F5 50 POP 07F6 61 PUSH2 0x081b 07F9 60 PUSH1 0x04 07FB 80 DUP1 07FC 36 CALLDATASIZE 07FD 03 SUB 07FE 60 PUSH1 0x20 0800 81 DUP2 0801 10 LT 0802 15 ISZERO 0803 61 PUSH2 0x080b 0806 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @07F6 stack[-1] = 0x081b // @07F9 stack[0] = 0x04 // @07FD stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x080b, returns to 0x081B, if !(msg.data.length - 0x04 < 0x20) label_0807: // Incoming jump from 0x0806, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @080A memory[0x00:0x00] } 0807 60 PUSH1 0x00 0809 80 DUP1 080A FD *REVERT // Stack delta = +0 // Outputs[1] { @080A revert(memory[0x00:0x00]); } // Block terminates label_080B: // Incoming call from 0x0806, returns to 0x081B, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @080D stack[-2] // @080D msg.data[stack[-2]:stack[-2] + 0x20] // } 080B 5B JUMPDEST 080C 50 POP 080D 35 CALLDATALOAD 080E 60 PUSH1 0x01 0810 60 PUSH1 0x01 0812 60 PUSH1 0xa0 0814 1B SHL 0815 03 SUB 0816 16 AND 0817 61 PUSH2 0x2058 081A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0816 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2058 label_081B: // Incoming return from call to 0x080B at 0x0806 // Inputs[7] // { // @081F memory[0x40:0x60] // @0820 stack[-4] // @0827 stack[-3] // @082E stack[-2] // @082F stack[-1] // @0837 memory[0x40:0x60] // @0840 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x80 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 081B 5B JUMPDEST 081C 60 PUSH1 0x40 081E 80 DUP1 081F 51 MLOAD 0820 94 SWAP5 0821 85 DUP6 0822 52 MSTORE 0823 60 PUSH1 0x20 0825 85 DUP6 0826 01 ADD 0827 93 SWAP4 0828 90 SWAP1 0829 93 SWAP4 082A 52 MSTORE 082B 83 DUP4 082C 83 DUP4 082D 01 ADD 082E 91 SWAP2 082F 90 SWAP1 0830 91 SWAP2 0831 52 MSTORE 0832 60 PUSH1 0x60 0834 83 DUP4 0835 01 ADD 0836 52 MSTORE 0837 51 MLOAD 0838 90 SWAP1 0839 81 DUP2 083A 90 SWAP1 083B 03 SUB 083C 60 PUSH1 0x80 083E 01 ADD 083F 90 SWAP1 0840 F3 *RETURN // Stack delta = -4 // Outputs[5] // { // @0822 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @082A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] // @0831 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-2] // @0836 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-1] // @0840 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x80 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0841: // Incoming jump from 0x0085, if 0xc5ebeaec == stack[-1] // Inputs[1] { @0842 msg.value } 0841 5B JUMPDEST 0842 34 CALLVALUE 0843 80 DUP1 0844 15 ISZERO 0845 61 PUSH2 0x084d 0848 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0842 stack[0] = msg.value } // Block ends with conditional jump to 0x084d, if !msg.value label_0849: // Incoming jump from 0x0848, if not !msg.value // Inputs[1] { @084C memory[0x00:0x00] } 0849 60 PUSH1 0x00 084B 80 DUP1 084C FD *REVERT // Stack delta = +0 // Outputs[1] { @084C revert(memory[0x00:0x00]); } // Block terminates label_084D: // Incoming jump from 0x0848, if !msg.value // Inputs[1] { @0855 msg.data.length } 084D 5B JUMPDEST 084E 50 POP 084F 61 PUSH2 0x0374 0852 60 PUSH1 0x04 0854 80 DUP1 0855 36 CALLDATASIZE 0856 03 SUB 0857 60 PUSH1 0x20 0859 81 DUP2 085A 10 LT 085B 15 ISZERO 085C 61 PUSH2 0x0864 085F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @084F stack[-1] = 0x0374 // @0852 stack[0] = 0x04 // @0856 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0864, if !(msg.data.length - 0x04 < 0x20) label_0860: // Incoming jump from 0x085F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0863 memory[0x00:0x00] } 0860 60 PUSH1 0x00 0862 80 DUP1 0863 FD *REVERT // Stack delta = +0 // Outputs[1] { @0863 revert(memory[0x00:0x00]); } // Block terminates label_0864: // Incoming jump from 0x085F, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0866 msg.data[stack[-2]:stack[-2] + 0x20] // @0866 stack[-2] // } 0864 5B JUMPDEST 0865 50 POP 0866 35 CALLDATALOAD 0867 61 PUSH2 0x20ed 086A 56 *JUMP // Stack delta = -1 // Outputs[1] { @0866 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x20ed label_086B: // Incoming jump from 0x0090, if 0xc7b7cc13 == stack[-1] // Inputs[1] { @086C msg.value } 086B 5B JUMPDEST 086C 34 CALLVALUE 086D 80 DUP1 086E 15 ISZERO 086F 61 PUSH2 0x0877 0872 57 *JUMPI // Stack delta = +1 // Outputs[1] { @086C stack[0] = msg.value } // Block ends with conditional jump to 0x0877, if !msg.value label_0873: // Incoming jump from 0x0872, if not !msg.value // Inputs[1] { @0876 memory[0x00:0x00] } 0873 60 PUSH1 0x00 0875 80 DUP1 0876 FD *REVERT // Stack delta = +0 // Outputs[1] { @0876 revert(memory[0x00:0x00]); } // Block terminates label_0877: // Incoming jump from 0x0872, if !msg.value // Inputs[1] { @087F msg.data.length } 0877 5B JUMPDEST 0878 50 POP 0879 61 PUSH2 0x05b3 087C 60 PUSH1 0x04 087E 80 DUP1 087F 36 CALLDATASIZE 0880 03 SUB 0881 60 PUSH1 0xe0 0883 81 DUP2 0884 10 LT 0885 15 ISZERO 0886 61 PUSH2 0x088e 0889 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0879 stack[-1] = 0x05b3 // @087C stack[0] = 0x04 // @0880 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x088e, if !(msg.data.length - 0x04 < 0xe0) label_088A: // Incoming jump from 0x0889, if not !(msg.data.length - 0x04 < 0xe0) // Inputs[1] { @088D memory[0x00:0x00] } 088A 60 PUSH1 0x00 088C 80 DUP1 088D FD *REVERT // Stack delta = +0 // Outputs[1] { @088D revert(memory[0x00:0x00]); } // Block terminates label_088E: // Incoming jump from 0x0889, if !(msg.data.length - 0x04 < 0xe0) // Inputs[6] // { // @0897 stack[-2] // @0898 msg.data[stack[-2]:stack[-2] + 0x20] // @08A0 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @08A4 stack[-1] // @08A9 msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @08B7 msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 088E 5B JUMPDEST 088F 60 PUSH1 0x01 0891 60 PUSH1 0x01 0893 60 PUSH1 0xa0 0895 1B SHL 0896 03 SUB 0897 82 DUP3 0898 35 CALLDATALOAD 0899 81 DUP2 089A 16 AND 089B 92 SWAP3 089C 60 PUSH1 0x20 089E 81 DUP2 089F 01 ADD 08A0 35 CALLDATALOAD 08A1 90 SWAP1 08A2 91 SWAP2 08A3 16 AND 08A4 91 SWAP2 08A5 60 PUSH1 0x40 08A7 82 DUP3 08A8 01 ADD 08A9 35 CALLDATALOAD 08AA 91 SWAP2 08AB 90 SWAP1 08AC 81 DUP2 08AD 01 ADD 08AE 90 SWAP1 08AF 60 PUSH1 0x80 08B1 81 DUP2 08B2 01 ADD 08B3 60 PUSH1 0x60 08B5 82 DUP3 08B6 01 ADD 08B7 35 CALLDATALOAD 08B8 64 PUSH5 0x0100000000 08BE 81 DUP2 08BF 11 GT 08C0 15 ISZERO 08C1 61 PUSH2 0x08c9 08C4 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @089B stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @08A4 stack[-1] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @08AA stack[0] = msg.data[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @08AE stack[1] = stack[-2] + stack[-1] // @08AE stack[2] = stack[-2] // @08B2 stack[3] = stack[-2] + 0x80 // @08B7 stack[4] = msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x08c9, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) label_08C5: // Incoming jump from 0x08C4, if not !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) // Inputs[1] { @08C8 memory[0x00:0x00] } 08C5 60 PUSH1 0x00 08C7 80 DUP1 08C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @08C8 revert(memory[0x00:0x00]); } // Block terminates label_08C9: // Incoming jump from 0x08C4, if !(msg.data[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] > 0x0100000000) // Inputs[3] // { // @08CA stack[-3] // @08CB stack[-1] // @08CC stack[-4] // } 08C9 5B JUMPDEST 08CA 82 DUP3 08CB 01 ADD 08CC 83 DUP4 08CD 60 PUSH1 0x20 08CF 82 DUP3 08D0 01 ADD 08D1 11 GT 08D2 15 ISZERO 08D3 61 PUSH2 0x08db 08D6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @08CB stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x08db, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_08D7: // Incoming jump from 0x08D6, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @08DA memory[0x00:0x00] } 08D7 60 PUSH1 0x00 08D9 80 DUP1 08DA FD *REVERT // Stack delta = +0 // Outputs[1] { @08DA revert(memory[0x00:0x00]); } // Block terminates label_08DB: // Incoming jump from 0x08D6, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @08DC stack[-1] // @08DD msg.data[stack[-1]:stack[-1] + 0x20] // @08E2 stack[-2] // @08E3 stack[-4] // } 08DB 5B JUMPDEST 08DC 80 DUP1 08DD 35 CALLDATALOAD 08DE 90 SWAP1 08DF 60 PUSH1 0x20 08E1 01 ADD 08E2 91 SWAP2 08E3 84 DUP5 08E4 60 PUSH1 0x01 08E6 83 DUP4 08E7 02 MUL 08E8 84 DUP5 08E9 01 ADD 08EA 11 GT 08EB 64 PUSH5 0x0100000000 08F1 83 DUP4 08F2 11 GT 08F3 17 OR 08F4 15 ISZERO 08F5 61 PUSH2 0x08fd 08F8 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @08DE stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @08E2 stack[0] = stack[-2] // @08E2 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x08fd, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_08F9: // Incoming jump from 0x08F8, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @08FC memory[0x00:0x00] } 08F9 60 PUSH1 0x00 08FB 80 DUP1 08FC FD *REVERT // Stack delta = +0 // Outputs[1] { @08FC revert(memory[0x00:0x00]); } // Block terminates label_08FD: // Incoming jump from 0x08F8, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[8] // { // @08FE stack[-1] // @08FE stack[-3] // @08FF stack[-2] // @0910 memory[0x40:0x60] // @0927 msg.data[stack[-3]:stack[-3] + stack[-2]] // @0932 stack[-5] // @0933 stack[-4] // @093B msg.data[stack[-1]:stack[-1] + 0x20] // } 08FD 5B JUMPDEST 08FE 91 SWAP2 08FF 90 SWAP1 0900 80 DUP1 0901 80 DUP1 0902 60 PUSH1 0x1f 0904 01 ADD 0905 60 PUSH1 0x20 0907 80 DUP1 0908 91 SWAP2 0909 04 DIV 090A 02 MUL 090B 60 PUSH1 0x20 090D 01 ADD 090E 60 PUSH1 0x40 0910 51 MLOAD 0911 90 SWAP1 0912 81 DUP2 0913 01 ADD 0914 60 PUSH1 0x40 0916 52 MSTORE 0917 80 DUP1 0918 93 SWAP4 0919 92 SWAP3 091A 91 SWAP2 091B 90 SWAP1 091C 81 DUP2 091D 81 DUP2 091E 52 MSTORE 091F 60 PUSH1 0x20 0921 01 ADD 0922 83 DUP4 0923 83 DUP4 0924 80 DUP1 0925 82 DUP3 0926 84 DUP5 0927 37 CALLDATACOPY 0928 60 PUSH1 0x00 092A 92 SWAP3 092B 01 ADD 092C 91 SWAP2 092D 90 SWAP1 092E 91 SWAP2 092F 52 MSTORE 0930 50 POP 0931 92 SWAP3 0932 95 SWAP6 0933 94 SWAP5 0934 93 SWAP4 0935 60 PUSH1 0x20 0937 81 DUP2 0938 01 ADD 0939 93 SWAP4 093A 50 POP 093B 35 CALLDATALOAD 093C 91 SWAP2 093D 50 POP 093E 50 POP 093F 64 PUSH5 0x0100000000 0945 81 DUP2 0946 11 GT 0947 15 ISZERO 0948 61 PUSH2 0x0950 094B 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0916 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @091E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0927 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @092F memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0932 stack[-5] = memory[0x40:0x60] // @0933 stack[-4] = stack[-5] // @0934 stack[-3] = stack[-4] // @0939 stack[-2] = stack[-1] + 0x20 // @093C stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x0950, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) label_094C: // Incoming jump from 0x094B, if not !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[1] { @094F memory[0x00:0x00] } 094C 60 PUSH1 0x00 094E 80 DUP1 094F FD *REVERT // Stack delta = +0 // Outputs[1] { @094F revert(memory[0x00:0x00]); } // Block terminates label_0950: // Incoming jump from 0x094B, if !(msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) // Inputs[3] // { // @0951 stack[-3] // @0952 stack[-1] // @0953 stack[-4] // } 0950 5B JUMPDEST 0951 82 DUP3 0952 01 ADD 0953 83 DUP4 0954 60 PUSH1 0x20 0956 82 DUP3 0957 01 ADD 0958 11 GT 0959 15 ISZERO 095A 61 PUSH2 0x0962 095D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0952 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0962, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_095E: // Incoming jump from 0x095D, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0961 memory[0x00:0x00] } 095E 60 PUSH1 0x00 0960 80 DUP1 0961 FD *REVERT // Stack delta = +0 // Outputs[1] { @0961 revert(memory[0x00:0x00]); } // Block terminates label_0962: // Incoming jump from 0x095D, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0963 stack[-1] // @0964 msg.data[stack[-1]:stack[-1] + 0x20] // @0969 stack[-2] // @096A stack[-4] // } 0962 5B JUMPDEST 0963 80 DUP1 0964 35 CALLDATALOAD 0965 90 SWAP1 0966 60 PUSH1 0x20 0968 01 ADD 0969 91 SWAP2 096A 84 DUP5 096B 60 PUSH1 0x01 096D 83 DUP4 096E 02 MUL 096F 84 DUP5 0970 01 ADD 0971 11 GT 0972 64 PUSH5 0x0100000000 0978 83 DUP4 0979 11 GT 097A 17 OR 097B 15 ISZERO 097C 61 PUSH2 0x0984 097F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0965 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0969 stack[0] = stack[-2] // @0969 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0984, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0980: // Incoming jump from 0x097F, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0983 memory[0x00:0x00] } 0980 60 PUSH1 0x00 0982 80 DUP1 0983 FD *REVERT // Stack delta = +0 // Outputs[1] { @0983 revert(memory[0x00:0x00]); } // Block terminates label_0984: // Incoming jump from 0x097F, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[9] // { // @0985 stack[-3] // @0985 stack[-1] // @0986 stack[-2] // @0997 memory[0x40:0x60] // @09AE msg.data[stack[-3]:stack[-3] + stack[-2]] // @09B9 stack[-5] // @09BD msg.data[stack[-1]:stack[-1] + 0x20] // @09BE stack[-4] // @09C5 msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } 0984 5B JUMPDEST 0985 91 SWAP2 0986 90 SWAP1 0987 80 DUP1 0988 80 DUP1 0989 60 PUSH1 0x1f 098B 01 ADD 098C 60 PUSH1 0x20 098E 80 DUP1 098F 91 SWAP2 0990 04 DIV 0991 02 MUL 0992 60 PUSH1 0x20 0994 01 ADD 0995 60 PUSH1 0x40 0997 51 MLOAD 0998 90 SWAP1 0999 81 DUP2 099A 01 ADD 099B 60 PUSH1 0x40 099D 52 MSTORE 099E 80 DUP1 099F 93 SWAP4 09A0 92 SWAP3 09A1 91 SWAP2 09A2 90 SWAP1 09A3 81 DUP2 09A4 81 DUP2 09A5 52 MSTORE 09A6 60 PUSH1 0x20 09A8 01 ADD 09A9 83 DUP4 09AA 83 DUP4 09AB 80 DUP1 09AC 82 DUP3 09AD 84 DUP5 09AE 37 CALLDATACOPY 09AF 60 PUSH1 0x00 09B1 92 SWAP3 09B2 01 ADD 09B3 91 SWAP2 09B4 90 SWAP1 09B5 91 SWAP2 09B6 52 MSTORE 09B7 50 POP 09B8 92 SWAP3 09B9 95 SWAP6 09BA 50 POP 09BB 50 POP 09BC 82 DUP3 09BD 35 CALLDATALOAD 09BE 93 SWAP4 09BF 50 POP 09C0 50 POP 09C1 50 POP 09C2 60 PUSH1 0x20 09C4 01 ADD 09C5 35 CALLDATALOAD 09C6 60 PUSH1 0xff 09C8 16 AND 09C9 61 PUSH2 0x20f8 09CC 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @099D memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @09A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @09AE memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @09B6 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @09B9 stack[-5] = memory[0x40:0x60] // @09BE stack[-4] = msg.data[stack[-1]:stack[-1] + 0x20] // @09C8 stack[-3] = 0xff & msg.data[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x20f8 label_09CD: // Incoming jump from 0x009B, if 0xd90a730e == stack[-1] // Inputs[1] { @09CE msg.value } 09CD 5B JUMPDEST 09CE 34 CALLVALUE 09CF 80 DUP1 09D0 15 ISZERO 09D1 61 PUSH2 0x09d9 09D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09CE stack[0] = msg.value } // Block ends with conditional jump to 0x09d9, if !msg.value label_09D5: // Incoming jump from 0x09D4, if not !msg.value // Inputs[1] { @09D8 memory[0x00:0x00] } 09D5 60 PUSH1 0x00 09D7 80 DUP1 09D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @09D8 revert(memory[0x00:0x00]); } // Block terminates label_09D9: // Incoming jump from 0x09D4, if !msg.value 09D9 5B JUMPDEST 09DA 50 POP 09DB 61 PUSH2 0x0374 09DE 61 PUSH2 0x21ca 09E1 56 *JUMP // Stack delta = +0 // Outputs[1] { @09DB stack[-1] = 0x0374 } // Block ends with call to 0x21ca, returns to 0x0374 label_09E2: // Incoming jump from 0x00A6, if 0xdd62ed3e == stack[-1] // Inputs[1] { @09E3 msg.value } 09E2 5B JUMPDEST 09E3 34 CALLVALUE 09E4 80 DUP1 09E5 15 ISZERO 09E6 61 PUSH2 0x09ee 09E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09E3 stack[0] = msg.value } // Block ends with conditional jump to 0x09ee, if !msg.value label_09EA: // Incoming jump from 0x09E9, if not !msg.value // Inputs[1] { @09ED memory[0x00:0x00] } 09EA 60 PUSH1 0x00 09EC 80 DUP1 09ED FD *REVERT // Stack delta = +0 // Outputs[1] { @09ED revert(memory[0x00:0x00]); } // Block terminates label_09EE: // Incoming jump from 0x09E9, if !msg.value // Inputs[1] { @09F6 msg.data.length } 09EE 5B JUMPDEST 09EF 50 POP 09F0 61 PUSH2 0x0374 09F3 60 PUSH1 0x04 09F5 80 DUP1 09F6 36 CALLDATASIZE 09F7 03 SUB 09F8 60 PUSH1 0x40 09FA 81 DUP2 09FB 10 LT 09FC 15 ISZERO 09FD 61 PUSH2 0x0a05 0A00 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @09F0 stack[-1] = 0x0374 // @09F3 stack[0] = 0x04 // @09F7 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a05, returns to 0x0374, if !(msg.data.length - 0x04 < 0x40) label_0A01: // Incoming jump from 0x0A00, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0A04 memory[0x00:0x00] } 0A01 60 PUSH1 0x00 0A03 80 DUP1 0A04 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A04 revert(memory[0x00:0x00]); } // Block terminates label_0A05: // Incoming call from 0x0A00, returns to 0x0374, if !(msg.data.length - 0x04 < 0x40) // Inputs[3] // { // @0A0F stack[-2] // @0A10 msg.data[stack[-2]:stack[-2] + 0x20] // @0A17 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0A05 5B JUMPDEST 0A06 50 POP 0A07 60 PUSH1 0x01 0A09 60 PUSH1 0x01 0A0B 60 PUSH1 0xa0 0A0D 1B SHL 0A0E 03 SUB 0A0F 81 DUP2 0A10 35 CALLDATALOAD 0A11 81 DUP2 0A12 16 AND 0A13 91 SWAP2 0A14 60 PUSH1 0x20 0A16 01 ADD 0A17 35 CALLDATALOAD 0A18 16 AND 0A19 61 PUSH2 0x21d0 0A1C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0A13 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] // @0A18 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] & (0x01 << 0xa0) - 0x01 // } // Block ends with unconditional jump to 0x21d0 label_0A1D: // Incoming jump from 0x00B1, if 0xe5974619 == stack[-1] // Inputs[1] { @0A24 msg.data.length } 0A1D 5B JUMPDEST 0A1E 61 PUSH2 0x05b3 0A21 60 PUSH1 0x04 0A23 80 DUP1 0A24 36 CALLDATASIZE 0A25 03 SUB 0A26 60 PUSH1 0x20 0A28 81 DUP2 0A29 10 LT 0A2A 15 ISZERO 0A2B 61 PUSH2 0x0a33 0A2E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A1E stack[0] = 0x05b3 // @0A21 stack[1] = 0x04 // @0A25 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional jump to 0x0a33, if !(msg.data.length - 0x04 < 0x20) label_0A2F: // Incoming jump from 0x0A2E, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0A32 memory[0x00:0x00] } 0A2F 60 PUSH1 0x00 0A31 80 DUP1 0A32 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A32 revert(memory[0x00:0x00]); } // Block terminates label_0A33: // Incoming jump from 0x0A2E, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0A35 msg.data[stack[-2]:stack[-2] + 0x20] // @0A35 stack[-2] // } 0A33 5B JUMPDEST 0A34 50 POP 0A35 35 CALLDATALOAD 0A36 60 PUSH1 0x01 0A38 60 PUSH1 0x01 0A3A 60 PUSH1 0xa0 0A3C 1B SHL 0A3D 03 SUB 0A3E 16 AND 0A3F 61 PUSH2 0x21fb 0A42 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A3E stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x21fb label_0A43: // Incoming jump from 0x00BC, if 0xf2b3abbd == stack[-1] // Inputs[1] { @0A44 msg.value } 0A43 5B JUMPDEST 0A44 34 CALLVALUE 0A45 80 DUP1 0A46 15 ISZERO 0A47 61 PUSH2 0x0a4f 0A4A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A44 stack[0] = msg.value } // Block ends with conditional jump to 0x0a4f, if !msg.value label_0A4B: // Incoming jump from 0x0A4A, if not !msg.value // Inputs[1] { @0A4E memory[0x00:0x00] } 0A4B 60 PUSH1 0x00 0A4D 80 DUP1 0A4E FD *REVERT // Stack delta = +0 // Outputs[1] { @0A4E revert(memory[0x00:0x00]); } // Block terminates label_0A4F: // Incoming jump from 0x0A4A, if !msg.value // Inputs[1] { @0A57 msg.data.length } 0A4F 5B JUMPDEST 0A50 50 POP 0A51 61 PUSH2 0x0374 0A54 60 PUSH1 0x04 0A56 80 DUP1 0A57 36 CALLDATASIZE 0A58 03 SUB 0A59 60 PUSH1 0x20 0A5B 81 DUP2 0A5C 10 LT 0A5D 15 ISZERO 0A5E 61 PUSH2 0x0a66 0A61 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0A51 stack[-1] = 0x0374 // @0A54 stack[0] = 0x04 // @0A58 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0a66, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_0A62: // Incoming jump from 0x0A61, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0A65 memory[0x00:0x00] } 0A62 60 PUSH1 0x00 0A64 80 DUP1 0A65 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A65 revert(memory[0x00:0x00]); } // Block terminates label_0A66: // Incoming call from 0x0A61, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0A68 msg.data[stack[-2]:stack[-2] + 0x20] // @0A68 stack[-2] // } 0A66 5B JUMPDEST 0A67 50 POP 0A68 35 CALLDATALOAD 0A69 60 PUSH1 0x01 0A6B 60 PUSH1 0x01 0A6D 60 PUSH1 0xa0 0A6F 1B SHL 0A70 03 SUB 0A71 16 AND 0A72 61 PUSH2 0x2236 0A75 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A71 stack[-2] = (0x01 << 0xa0) - 0x01 & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2236 label_0A76: // Incoming jump from 0x003E, if 0xf3fdb15a == stack[-1] // Inputs[1] { @0A77 msg.value } 0A76 5B JUMPDEST 0A77 34 CALLVALUE 0A78 80 DUP1 0A79 15 ISZERO 0A7A 61 PUSH2 0x0a82 0A7D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A77 stack[0] = msg.value } // Block ends with conditional jump to 0x0a82, if !msg.value label_0A7E: // Incoming jump from 0x0A7D, if not !msg.value // Inputs[1] { @0A81 memory[0x00:0x00] } 0A7E 60 PUSH1 0x00 0A80 80 DUP1 0A81 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A81 revert(memory[0x00:0x00]); } // Block terminates label_0A82: // Incoming jump from 0x0A7D, if !msg.value 0A82 5B JUMPDEST 0A83 50 POP 0A84 61 PUSH2 0x0a8b 0A87 61 PUSH2 0x228a 0A8A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A84 stack[-1] = 0x0a8b } // Block ends with call to 0x228a, returns to 0x0A8B label_0A8B: // Incoming return from call to 0x228A at 0x0A8A // Incoming return from call to 0x22AF at 0x0AD0 // Incoming return from call to 0x2299 at 0x0ABB // Inputs[4] // { // @0A8F memory[0x40:0x60] // @0A99 stack[-1] // @0A9D memory[0x40:0x60] // @0AA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0A8B 5B JUMPDEST 0A8C 60 PUSH1 0x40 0A8E 80 DUP1 0A8F 51 MLOAD 0A90 60 PUSH1 0x01 0A92 60 PUSH1 0x01 0A94 60 PUSH1 0xa0 0A96 1B SHL 0A97 03 SUB 0A98 90 SWAP1 0A99 92 SWAP3 0A9A 16 AND 0A9B 82 DUP3 0A9C 52 MSTORE 0A9D 51 MLOAD 0A9E 90 SWAP1 0A9F 81 DUP2 0AA0 90 SWAP1 0AA1 03 SUB 0AA2 60 PUSH1 0x20 0AA4 01 ADD 0AA5 90 SWAP1 0AA6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0AA6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])]; // } // Block terminates label_0AA7: // Incoming jump from 0x0049, if 0xf77c4791 == stack[-1] // Inputs[1] { @0AA8 msg.value } 0AA7 5B JUMPDEST 0AA8 34 CALLVALUE 0AA9 80 DUP1 0AAA 15 ISZERO 0AAB 61 PUSH2 0x0ab3 0AAE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AA8 stack[0] = msg.value } // Block ends with conditional jump to 0x0ab3, if !msg.value label_0AAF: // Incoming jump from 0x0AAE, if not !msg.value // Inputs[1] { @0AB2 memory[0x00:0x00] } 0AAF 60 PUSH1 0x00 0AB1 80 DUP1 0AB2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AB2 revert(memory[0x00:0x00]); } // Block terminates label_0AB3: // Incoming jump from 0x0AAE, if !msg.value 0AB3 5B JUMPDEST 0AB4 50 POP 0AB5 61 PUSH2 0x0a8b 0AB8 61 PUSH2 0x2299 0ABB 56 *JUMP // Stack delta = +0 // Outputs[1] { @0AB5 stack[-1] = 0x0a8b } // Block ends with call to 0x2299, returns to 0x0A8B label_0ABC: // Incoming jump from 0x0054, if 0xf851a440 == stack[-1] // Inputs[1] { @0ABD msg.value } 0ABC 5B JUMPDEST 0ABD 34 CALLVALUE 0ABE 80 DUP1 0ABF 15 ISZERO 0AC0 61 PUSH2 0x0ac8 0AC3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0ABD stack[0] = msg.value } // Block ends with conditional jump to 0x0ac8, if !msg.value label_0AC4: // Incoming jump from 0x0AC3, if not !msg.value // Inputs[1] { @0AC7 memory[0x00:0x00] } 0AC4 60 PUSH1 0x00 0AC6 80 DUP1 0AC7 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AC7 revert(memory[0x00:0x00]); } // Block terminates label_0AC8: // Incoming jump from 0x0AC3, if !msg.value 0AC8 5B JUMPDEST 0AC9 50 POP 0ACA 61 PUSH2 0x0a8b 0ACD 61 PUSH2 0x22af 0AD0 56 *JUMP // Stack delta = +0 // Outputs[1] { @0ACA stack[-1] = 0x0a8b } // Block ends with call to 0x22af, returns to 0x0A8B label_0AD1: // Incoming jump from 0x005F, if 0xf8f9da28 == stack[-1] // Inputs[1] { @0AD2 msg.value } 0AD1 5B JUMPDEST 0AD2 34 CALLVALUE 0AD3 80 DUP1 0AD4 15 ISZERO 0AD5 61 PUSH2 0x0add 0AD8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AD2 stack[0] = msg.value } // Block ends with conditional jump to 0x0add, if !msg.value label_0AD9: // Incoming jump from 0x0AD8, if not !msg.value // Inputs[1] { @0ADC memory[0x00:0x00] } 0AD9 60 PUSH1 0x00 0ADB 80 DUP1 0ADC FD *REVERT // Stack delta = +0 // Outputs[1] { @0ADC revert(memory[0x00:0x00]); } // Block terminates label_0ADD: // Incoming jump from 0x0AD8, if !msg.value 0ADD 5B JUMPDEST 0ADE 50 POP 0ADF 61 PUSH2 0x0374 0AE2 61 PUSH2 0x22c3 0AE5 56 *JUMP // Stack delta = +0 // Outputs[1] { @0ADF stack[-1] = 0x0374 } // Block ends with call to 0x22c3, returns to 0x0374 label_0AE6: // Incoming jump from 0x006A, if 0xfca7820b == stack[-1] // Inputs[1] { @0AE7 msg.value } 0AE6 5B JUMPDEST 0AE7 34 CALLVALUE 0AE8 80 DUP1 0AE9 15 ISZERO 0AEA 61 PUSH2 0x0af2 0AED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AE7 stack[0] = msg.value } // Block ends with conditional jump to 0x0af2, if !msg.value label_0AEE: // Incoming jump from 0x0AED, if not !msg.value // Inputs[1] { @0AF1 memory[0x00:0x00] } 0AEE 60 PUSH1 0x00 0AF0 80 DUP1 0AF1 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AF1 revert(memory[0x00:0x00]); } // Block terminates label_0AF2: // Incoming jump from 0x0AED, if !msg.value // Inputs[1] { @0AFA msg.data.length } 0AF2 5B JUMPDEST 0AF3 50 POP 0AF4 61 PUSH2 0x0374 0AF7 60 PUSH1 0x04 0AF9 80 DUP1 0AFA 36 CALLDATASIZE 0AFB 03 SUB 0AFC 60 PUSH1 0x20 0AFE 81 DUP2 0AFF 10 LT 0B00 15 ISZERO 0B01 61 PUSH2 0x0b09 0B04 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0AF4 stack[-1] = 0x0374 // @0AF7 stack[0] = 0x04 // @0AFB stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0b09, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) label_0B05: // Incoming jump from 0x0B04, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0B08 memory[0x00:0x00] } 0B05 60 PUSH1 0x00 0B07 80 DUP1 0B08 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B08 revert(memory[0x00:0x00]); } // Block terminates label_0B09: // Incoming call from 0x0B04, returns to 0x0374, if !(msg.data.length - 0x04 < 0x20) // Inputs[2] // { // @0B0B stack[-2] // @0B0B msg.data[stack[-2]:stack[-2] + 0x20] // } 0B09 5B JUMPDEST 0B0A 50 POP 0B0B 35 CALLDATALOAD 0B0C 61 PUSH2 0x2327 0B0F 56 *JUMP // Stack delta = -1 // Outputs[1] { @0B0B stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2327 label_0B10: // Incoming jump from 0x0075, if 0xfcb64147 == stack[-1] 0B10 5B JUMPDEST 0B11 61 PUSH2 0x0374 0B14 61 PUSH2 0x23e7 0B17 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B11 stack[0] = 0x0374 } // Block ends with unconditional jump to 0x23e7 label_0B18: // Incoming jump from 0x0291 // Incoming jump from 0x11A2 // Inputs[1] { @0B1C storage[0x00] } 0B18 5B JUMPDEST 0B19 60 PUSH1 0x00 0B1B 80 DUP1 0B1C 54 SLOAD 0B1D 62 PUSH3 0x010000 0B21 90 SWAP1 0B22 04 DIV 0B23 60 PUSH1 0xff 0B25 16 AND 0B26 61 PUSH2 0x0b62 0B29 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B19 stack[0] = 0x00 } // Block ends with conditional jump to 0x0b62, if 0xff & storage[0x00] / 0x010000 label_0B2A: // Incoming jump from 0x0B29, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @0B2D memory[0x40:0x60] // @0B58 memory[0x40:0x60] // @0B61 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0B2A 60 PUSH1 0x40 0B2C 80 DUP1 0B2D 51 MLOAD 0B2E 60 PUSH1 0x01 0B30 60 PUSH1 0xe5 0B32 1B SHL 0B33 62 PUSH3 0x461bcd 0B37 02 MUL 0B38 81 DUP2 0B39 52 MSTORE 0B3A 60 PUSH1 0x20 0B3C 60 PUSH1 0x04 0B3E 82 DUP3 0B3F 01 ADD 0B40 52 MSTORE 0B41 60 PUSH1 0x03 0B43 60 PUSH1 0x24 0B45 82 DUP3 0B46 01 ADD 0B47 52 MSTORE 0B48 60 PUSH1 0x01 0B4A 60 PUSH1 0xe8 0B4C 1B SHL 0B4D 62 PUSH3 0x453637 0B51 02 MUL 0B52 60 PUSH1 0x44 0B54 82 DUP3 0B55 01 ADD 0B56 52 MSTORE 0B57 90 SWAP1 0B58 51 MLOAD 0B59 90 SWAP1 0B5A 81 DUP2 0B5B 90 SWAP1 0B5C 03 SUB 0B5D 60 PUSH1 0x64 0B5F 01 ADD 0B60 90 SWAP1 0B61 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B39 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0B40 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B47 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @0B56 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @0B61 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0B62: // Incoming jump from 0x0B29, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @0B66 storage[0x00] } 0B62 5B JUMPDEST 0B63 60 PUSH1 0x00 0B65 80 DUP1 0B66 54 SLOAD 0B67 62 PUSH3 0xff0000 0B6B 19 NOT 0B6C 16 AND 0B6D 81 DUP2 0B6E 55 SSTORE 0B6F 61 PUSH2 0x0b76 0B72 61 PUSH2 0x1a38 0B75 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B63 stack[0] = 0x00 // @0B6E storage[0x00] = ~0xff0000 & storage[0x00] // @0B6F stack[1] = 0x0b76 // } // Block ends with call to 0x1a38, returns to 0x0B76 label_0B76: // Incoming return from call to 0x1A38 at 0x0B75 // Incoming return from call to 0x1A38 at 0x0B75 // Inputs[2] // { // @0B77 stack[-1] // @0B77 stack[-2] // } 0B76 5B JUMPDEST 0B77 14 EQ 0B78 61 PUSH2 0x0bb3 0B7B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0bb3, if stack[-1] == stack[-2] label_0B7C: // Incoming jump from 0x0B7B, if not stack[-1] == stack[-2] // Inputs[3] // { // @0B7F memory[0x40:0x60] // @0BA9 memory[0x40:0x60] // @0BB2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0B7C 60 PUSH1 0x40 0B7E 80 DUP1 0B7F 51 MLOAD 0B80 60 PUSH1 0x01 0B82 60 PUSH1 0xe5 0B84 1B SHL 0B85 62 PUSH3 0x461bcd 0B89 02 MUL 0B8A 81 DUP2 0B8B 52 MSTORE 0B8C 60 PUSH1 0x20 0B8E 60 PUSH1 0x04 0B90 82 DUP3 0B91 01 ADD 0B92 52 MSTORE 0B93 60 PUSH1 0x02 0B95 60 PUSH1 0x24 0B97 82 DUP3 0B98 01 ADD 0B99 52 MSTORE 0B9A 60 PUSH1 0x01 0B9C 60 PUSH1 0xf0 0B9E 1B SHL 0B9F 61 PUSH2 0x4535 0BA2 02 MUL 0BA3 60 PUSH1 0x44 0BA5 82 DUP3 0BA6 01 ADD 0BA7 52 MSTORE 0BA8 90 SWAP1 0BA9 51 MLOAD 0BAA 90 SWAP1 0BAB 81 DUP2 0BAC 90 SWAP1 0BAD 03 SUB 0BAE 60 PUSH1 0x64 0BB0 01 ADD 0BB1 90 SWAP1 0BB2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B8B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0B92 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B99 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @0BA7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @0BB2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0BB3: // Incoming jump from 0x0B7B, if stack[-1] == stack[-2] // Inputs[6] // { // @0BB7 storage[0x00] // @0BBB memory[0x40:0x60] // @0BC9 address(this) // @0BD7 stack[-3] // @0BE0 memory[0x40:0x60] // @0C07 address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } 0BB3 5B JUMPDEST 0BB4 60 PUSH1 0x00 0BB6 80 DUP1 0BB7 54 SLOAD 0BB8 60 PUSH1 0x40 0BBA 80 DUP1 0BBB 51 MLOAD 0BBC 60 PUSH1 0x01 0BBE 60 PUSH1 0xe1 0BC0 1B SHL 0BC1 63 PUSH4 0x78cb4c05 0BC6 02 MUL 0BC7 81 DUP2 0BC8 52 MSTORE 0BC9 30 ADDRESS 0BCA 60 PUSH1 0x04 0BCC 82 DUP3 0BCD 01 ADD 0BCE 52 MSTORE 0BCF 60 PUSH1 0x01 0BD1 60 PUSH1 0x01 0BD3 60 PUSH1 0xa0 0BD5 1B SHL 0BD6 03 SUB 0BD7 87 DUP8 0BD8 81 DUP2 0BD9 16 AND 0BDA 60 PUSH1 0x24 0BDC 83 DUP4 0BDD 01 ADD 0BDE 52 MSTORE 0BDF 91 SWAP2 0BE0 51 MLOAD 0BE1 63 PUSH4 0x01000000 0BE6 90 SWAP1 0BE7 93 SWAP4 0BE8 04 DIV 0BE9 90 SWAP1 0BEA 91 SWAP2 0BEB 16 AND 0BEC 91 SWAP2 0BED 63 PUSH4 0xf196980a 0BF2 91 SWAP2 0BF3 60 PUSH1 0x44 0BF5 80 DUP1 0BF6 82 DUP3 0BF7 01 ADD 0BF8 92 SWAP3 0BF9 60 PUSH1 0x20 0BFB 92 SWAP3 0BFC 90 SWAP1 0BFD 91 SWAP2 0BFE 90 SWAP1 0BFF 82 DUP3 0C00 90 SWAP1 0C01 03 SUB 0C02 01 ADD 0C03 81 DUP2 0C04 87 DUP8 0C05 87 DUP8 0C06 80 DUP1 0C07 3B EXTCODESIZE 0C08 15 ISZERO 0C09 80 DUP1 0C0A 15 ISZERO 0C0B 61 PUSH2 0x0c13 0C0E 57 *JUMPI // Stack delta = +11 // Outputs[14] // { // @0BB4 stack[0] = 0x00 // @0BC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x78cb4c05 * (0x01 << 0xe1) // @0BCE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0BDE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0BEC stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @0BF2 stack[2] = 0xf196980a // @0BF8 stack[3] = memory[0x40:0x60] + 0x44 // @0BFB stack[4] = 0x20 // @0BFD stack[5] = memory[0x40:0x60] // @0C02 stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @0C03 stack[7] = memory[0x40:0x60] // @0C04 stack[8] = 0x00 // @0C05 stack[9] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @0C08 stack[10] = !address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } // Block ends with conditional jump to 0x0c13, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length label_0C0F: // Incoming jump from 0x0C0E, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[1] { @0C12 memory[0x00:0x00] } 0C0F 60 PUSH1 0x00 0C11 80 DUP1 0C12 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C12 revert(memory[0x00:0x00]); } // Block terminates label_0C13: // Incoming jump from 0x0C0E, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[9] // { // @0C15 msg.gas // @0C16 stack[-4] // @0C16 stack[-5] // @0C16 stack[-7] // @0C16 stack[-6] // @0C16 memory[stack[-4]:stack[-4] + stack[-5]] // @0C16 stack[-3] // @0C16 stack[-2] // @0C16 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0C13 5B JUMPDEST 0C14 50 POP 0C15 5A GAS 0C16 F1 CALL 0C17 15 ISZERO 0C18 80 DUP1 0C19 15 ISZERO 0C1A 61 PUSH2 0x0c27 0C1D 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0C16 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0C17 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0c27, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0C1E: // Incoming jump from 0x0C1D, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0C1E returndata.length // @0C22 returndata[0x00:0x00 + returndata.length] // @0C23 returndata.length // @0C26 memory[0x00:0x00 + returndata.length] // } 0C1E 3D RETURNDATASIZE 0C1F 60 PUSH1 0x00 0C21 80 DUP1 0C22 3E RETURNDATACOPY 0C23 3D RETURNDATASIZE 0C24 60 PUSH1 0x00 0C26 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C22 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0C26 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0C27: // Incoming jump from 0x0C1D, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0C2E memory[0x40:0x60] // @0C2F returndata.length // } 0C27 5B JUMPDEST 0C28 50 POP 0C29 50 POP 0C2A 50 POP 0C2B 50 POP 0C2C 60 PUSH1 0x40 0C2E 51 MLOAD 0C2F 3D RETURNDATASIZE 0C30 60 PUSH1 0x20 0C32 81 DUP2 0C33 10 LT 0C34 15 ISZERO 0C35 61 PUSH2 0x0c3d 0C38 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0C2E stack[-4] = memory[0x40:0x60] // @0C2F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0c3d, if !(returndata.length < 0x20) label_0C39: // Incoming jump from 0x0C38, if not !(returndata.length < 0x20) // Inputs[1] { @0C3C memory[0x00:0x00] } 0C39 60 PUSH1 0x00 0C3B 80 DUP1 0C3C FD *REVERT // Stack delta = +0 // Outputs[1] { @0C3C revert(memory[0x00:0x00]); } // Block terminates label_0C3D: // Incoming jump from 0x0C38, if !(returndata.length < 0x20) // Inputs[3] // { // @0C3F stack[-2] // @0C3F memory[stack[-2]:stack[-2] + 0x20] // @0C40 stack[-3] // } 0C3D 5B JUMPDEST 0C3E 50 POP 0C3F 51 MLOAD 0C40 90 SWAP1 0C41 50 POP 0C42 80 DUP1 0C43 15 ISZERO 0C44 61 PUSH2 0x0c80 0C47 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0C40 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0c80, if !memory[stack[-2]:stack[-2] + 0x20] label_0C48: // Incoming jump from 0x0C47, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @0C4B memory[0x40:0x60] // @0C76 memory[0x40:0x60] // @0C7F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0C48 60 PUSH1 0x40 0C4A 80 DUP1 0C4B 51 MLOAD 0C4C 60 PUSH1 0x01 0C4E 60 PUSH1 0xe5 0C50 1B SHL 0C51 62 PUSH3 0x461bcd 0C55 02 MUL 0C56 81 DUP2 0C57 52 MSTORE 0C58 60 PUSH1 0x20 0C5A 60 PUSH1 0x04 0C5C 82 DUP3 0C5D 01 ADD 0C5E 52 MSTORE 0C5F 60 PUSH1 0x03 0C61 60 PUSH1 0x24 0C63 82 DUP3 0C64 01 ADD 0C65 52 MSTORE 0C66 60 PUSH1 0x01 0C68 60 PUSH1 0xec 0C6A 1B SHL 0C6B 62 PUSH3 0x045313 0C6F 02 MUL 0C70 60 PUSH1 0x44 0C72 82 DUP3 0C73 01 ADD 0C74 52 MSTORE 0C75 90 SWAP1 0C76 51 MLOAD 0C77 90 SWAP1 0C78 81 DUP2 0C79 90 SWAP1 0C7A 03 SUB 0C7B 60 PUSH1 0x64 0C7D 01 ADD 0C7E 90 SWAP1 0C7F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0C57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0C5E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C65 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @0C74 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x045313 * (0x01 << 0xec) // @0C7F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0C80: // Incoming jump from 0x0C47, if !memory[stack[-2]:stack[-2] + 0x20] 0C80 5B JUMPDEST 0C81 61 PUSH2 0x0c88 0C84 61 PUSH2 0x23f2 0C87 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C81 stack[0] = 0x0c88 } // Block ends with call to 0x23f2, returns to 0x0C88 label_0C88: // Incoming return from call to 0x23F2 at 0x0C87 // Inputs[2] // { // @0C8B storage[0x08] // @0C8C stack[-1] // } 0C88 5B JUMPDEST 0C89 60 PUSH1 0x08 0C8B 54 SLOAD 0C8C 14 EQ 0C8D 61 PUSH2 0x0cc9 0C90 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cc9, if storage[0x08] == stack[-1] label_0C91: // Incoming jump from 0x0C90, if not storage[0x08] == stack[-1] // Inputs[3] // { // @0C94 memory[0x40:0x60] // @0CBF memory[0x40:0x60] // @0CC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0C91 60 PUSH1 0x40 0C93 80 DUP1 0C94 51 MLOAD 0C95 60 PUSH1 0x01 0C97 60 PUSH1 0xe5 0C99 1B SHL 0C9A 62 PUSH3 0x461bcd 0C9E 02 MUL 0C9F 81 DUP2 0CA0 52 MSTORE 0CA1 60 PUSH1 0x20 0CA3 60 PUSH1 0x04 0CA5 82 DUP3 0CA6 01 ADD 0CA7 52 MSTORE 0CA8 60 PUSH1 0x03 0CAA 60 PUSH1 0x24 0CAC 82 DUP3 0CAD 01 ADD 0CAE 52 MSTORE 0CAF 60 PUSH1 0x01 0CB1 60 PUSH1 0xeb 0CB3 1B SHL 0CB4 62 PUSH3 0x08a627 0CB8 02 MUL 0CB9 60 PUSH1 0x44 0CBB 82 DUP3 0CBC 01 ADD 0CBD 52 MSTORE 0CBE 90 SWAP1 0CBF 51 MLOAD 0CC0 90 SWAP1 0CC1 81 DUP2 0CC2 90 SWAP1 0CC3 03 SUB 0CC4 60 PUSH1 0x64 0CC6 01 ADD 0CC7 90 SWAP1 0CC8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0CA0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0CA7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CAE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @0CBD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x08a627 * (0x01 << 0xeb) // @0CC8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0CC9: // Incoming jump from 0x0C90, if storage[0x08] == stack[-1] 0CC9 5B JUMPDEST 0CCA 61 PUSH2 0x0cd1 0CCD 61 PUSH2 0x5311 0CD0 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CCA stack[0] = 0x0cd1 } // Block ends with call to 0x5311, returns to 0x0CD1 label_0CD1: // Incoming return from call to 0x5311 at 0x0CD0 0CD1 5B JUMPDEST 0CD2 61 PUSH2 0x0cd9 0CD5 61 PUSH2 0x23f6 0CD8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CD2 stack[0] = 0x0cd9 } // Block ends with call to 0x23f6, returns to 0x0CD9 label_0CD9: // Incoming return from call to 0x23F6 at 0x0CD8 // Inputs[3] // { // @0CDC stack[-3] // @0CDE stack[-1] // @0CE5 stack[-2] // } 0CD9 5B JUMPDEST 0CDA 60 PUSH1 0x40 0CDC 83 DUP4 0CDD 01 ADD 0CDE 81 DUP2 0CDF 90 SWAP1 0CE0 52 MSTORE 0CE1 60 PUSH1 0x20 0CE3 83 DUP4 0CE4 01 ADD 0CE5 82 DUP3 0CE6 60 PUSH1 0x03 0CE8 81 DUP2 0CE9 11 GT 0CEA 15 ISZERO 0CEB 61 PUSH2 0x0cf0 0CEE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0CE0 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] = stack[-1] // @0CE4 stack[0] = stack[-3] + 0x20 // @0CE5 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0cf0, if !(stack[-2] > 0x03) label_0CEF: // Incoming jump from 0x0CEE, if not !(stack[-2] > 0x03) 0CEF FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CEF assert(); } // Block terminates label_0CF0: // Incoming jump from 0x0CEE, if !(stack[-2] > 0x03) // Inputs[1] { @0CF3 stack[-1] } 0CF0 5B JUMPDEST 0CF1 60 PUSH1 0x03 0CF3 81 DUP2 0CF4 11 GT 0CF5 15 ISZERO 0CF6 61 PUSH2 0x0cfb 0CF9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cfb, if !(stack[-1] > 0x03) label_0CFA: // Incoming jump from 0x0CF9, if not !(stack[-1] > 0x03) 0CFA FE *ASSERT // Stack delta = +0 // Outputs[1] { @0CFA assert(); } // Block terminates label_0CFB: // Incoming jump from 0x0CF9, if !(stack[-1] > 0x03) // Inputs[5] // { // @0CFC stack[-1] // @0CFC stack[-2] // @0D01 stack[-4] // @0D03 stack[-5] // @0D07 memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } 0CFB 5B JUMPDEST 0CFC 90 SWAP1 0CFD 52 MSTORE 0CFE 50 POP 0CFF 60 PUSH1 0x00 0D01 90 SWAP1 0D02 50 POP 0D03 81 DUP2 0D04 60 PUSH1 0x20 0D06 01 ADD 0D07 51 MLOAD 0D08 60 PUSH1 0x03 0D0A 81 DUP2 0D0B 11 GT 0D0C 15 ISZERO 0D0D 61 PUSH2 0x0d12 0D10 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @0CFD memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @0D01 stack[-4] = 0x00 // @0D07 stack[-3] = memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } // Block ends with conditional jump to 0x0d12, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) label_0D11: // Incoming jump from 0x0D10, if not !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) 0D11 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0D11 assert(); } // Block terminates label_0D12: // Incoming jump from 0x0D10, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @0D13 stack[-2] // @0D13 stack[-1] // } 0D12 5B JUMPDEST 0D13 14 EQ 0D14 61 PUSH2 0x0d50 0D17 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0d50, if stack[-1] == stack[-2] label_0D18: // Incoming jump from 0x0D17, if not stack[-1] == stack[-2] // Inputs[3] // { // @0D1B memory[0x40:0x60] // @0D46 memory[0x40:0x60] // @0D4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0D18 60 PUSH1 0x40 0D1A 80 DUP1 0D1B 51 MLOAD 0D1C 60 PUSH1 0x01 0D1E 60 PUSH1 0xe5 0D20 1B SHL 0D21 62 PUSH3 0x461bcd 0D25 02 MUL 0D26 81 DUP2 0D27 52 MSTORE 0D28 60 PUSH1 0x20 0D2A 60 PUSH1 0x04 0D2C 82 DUP3 0D2D 01 ADD 0D2E 52 MSTORE 0D2F 60 PUSH1 0x03 0D31 60 PUSH1 0x24 0D33 82 DUP3 0D34 01 ADD 0D35 52 MSTORE 0D36 60 PUSH1 0x01 0D38 60 PUSH1 0xe9 0D3A 1B SHL 0D3B 62 PUSH3 0x229899 0D3F 02 MUL 0D40 60 PUSH1 0x44 0D42 82 DUP3 0D43 01 ADD 0D44 52 MSTORE 0D45 90 SWAP1 0D46 51 MLOAD 0D47 90 SWAP1 0D48 81 DUP2 0D49 90 SWAP1 0D4A 03 SUB 0D4B 60 PUSH1 0x64 0D4D 01 ADD 0D4E 90 SWAP1 0D4F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0D27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @0D2E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D35 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @0D44 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229899 * (0x01 << 0xe9) // @0D4F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0D50: // Incoming jump from 0x0D17, if stack[-1] == stack[-2] // Inputs[2] // { // @0D54 stack[-5] // @0D55 stack[-4] // } 0D50 5B JUMPDEST 0D51 61 PUSH2 0x0d5a 0D54 85 DUP6 0D55 85 DUP6 0D56 61 PUSH2 0x24a1 0D59 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D51 stack[0] = 0x0d5a // @0D54 stack[1] = stack[-5] // @0D55 stack[2] = stack[-4] // } // Block ends with call to 0x24a1, returns to 0x0D5A label_0D5A: // Incoming return from call to 0x24A1 at 0x0D59 // Inputs[4] // { // @0D5D stack[-2] // @0D5F stack[-1] // @0D65 memory[0x40:0x60] // @0D6F memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // } 0D5A 5B JUMPDEST 0D5B 60 PUSH1 0xc0 0D5D 82 DUP3 0D5E 01 ADD 0D5F 81 DUP2 0D60 90 SWAP1 0D61 52 MSTORE 0D62 60 PUSH1 0x40 0D64 80 DUP1 0D65 51 MLOAD 0D66 60 PUSH1 0x20 0D68 81 DUP2 0D69 01 ADD 0D6A 82 DUP3 0D6B 52 MSTORE 0D6C 90 SWAP1 0D6D 83 DUP4 0D6E 01 ADD 0D6F 51 MLOAD 0D70 81 DUP2 0D71 52 MSTORE 0D72 61 PUSH2 0x0d7b 0D75 91 SWAP2 0D76 90 SWAP1 0D77 61 PUSH2 0x2532 0D7A 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @0D61 memory[stack[-2] + 0xc0:stack[-2] + 0xc0 + 0x20] = stack[-1] // @0D6B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0D71 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @0D75 stack[-1] = 0x0d7b // @0D76 stack[1] = memory[0x40:0x60] // @0D76 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2532 0D7B 5B JUMPDEST 0D7C 60 PUSH1 0x60 0D7E 83 DUP4 0D7F 01 ADD 0D80 81 DUP2 0D81 90 SWAP1 0D82 52 MSTORE 0D83 60 PUSH1 0x20 0D85 83 DUP4 0D86 01 ADD 0D87 82 DUP3 0D88 60 PUSH1 0x03 0D8A 81 DUP2 0D8B 11 GT 0D8C 15 ISZERO 0D8D 61 PUSH2 0x0d92 0D90 57 *JUMPI 0D91 FE *ASSERT 0D92 5B JUMPDEST 0D93 60 PUSH1 0x03 0D95 81 DUP2 0D96 11 GT 0D97 15 ISZERO 0D98 61 PUSH2 0x0d9d 0D9B 57 *JUMPI 0D9C FE *ASSERT 0D9D 5B JUMPDEST 0D9E 90 SWAP1 0D9F 52 MSTORE 0DA0 50 POP 0DA1 60 PUSH1 0x00 0DA3 90 SWAP1 0DA4 50 POP 0DA5 81 DUP2 0DA6 60 PUSH1 0x20 0DA8 01 ADD 0DA9 51 MLOAD 0DAA 60 PUSH1 0x03 0DAC 81 DUP2 0DAD 11 GT 0DAE 15 ISZERO 0DAF 61 PUSH2 0x0db4 0DB2 57 *JUMPI 0DB3 FE *ASSERT 0DB4 5B JUMPDEST 0DB5 14 EQ 0DB6 61 PUSH2 0x0df2 0DB9 57 *JUMPI 0DBA 60 PUSH1 0x40 0DBC 80 DUP1 0DBD 51 MLOAD 0DBE 60 PUSH1 0x01 0DC0 60 PUSH1 0xe5 0DC2 1B SHL 0DC3 62 PUSH3 0x461bcd 0DC7 02 MUL 0DC8 81 DUP2 0DC9 52 MSTORE 0DCA 60 PUSH1 0x20 0DCC 60 PUSH1 0x04 0DCE 82 DUP3 0DCF 01 ADD 0DD0 52 MSTORE 0DD1 60 PUSH1 0x03 0DD3 60 PUSH1 0x24 0DD5 82 DUP3 0DD6 01 ADD 0DD7 52 MSTORE 0DD8 60 PUSH1 0x01 0DDA 60 PUSH1 0xe8 0DDC 1B SHL 0DDD 62 PUSH3 0x453133 0DE1 02 MUL 0DE2 60 PUSH1 0x44 0DE4 82 DUP3 0DE5 01 ADD 0DE6 52 MSTORE 0DE7 90 SWAP1 0DE8 51 MLOAD 0DE9 90 SWAP1 0DEA 81 DUP2 0DEB 90 SWAP1 0DEC 03 SUB 0DED 60 PUSH1 0x64 0DEF 01 ADD 0DF0 90 SWAP1 0DF1 FD *REVERT 0DF2 5B JUMPDEST 0DF3 60 PUSH1 0x01 0DF5 60 PUSH1 0x01 0DF7 60 PUSH1 0xa0 0DF9 1B SHL 0DFA 03 SUB 0DFB 85 DUP6 0DFC 16 AND 0DFD 60 PUSH1 0x00 0DFF 90 SWAP1 0E00 81 DUP2 0E01 52 MSTORE 0E02 60 PUSH1 0x0f 0E04 60 PUSH1 0x20 0E06 52 MSTORE 0E07 60 PUSH1 0x40 0E09 90 SWAP1 0E0A 20 SHA3 0E0B 54 SLOAD 0E0C 60 PUSH1 0xc0 0E0E 82 DUP3 0E0F 01 ADD 0E10 51 MLOAD 0E11 61 PUSH2 0x0e1a 0E14 91 SWAP2 0E15 90 SWAP1 0E16 61 PUSH2 0x2586 0E19 56 *JUMP 0E1A 5B JUMPDEST 0E1B 60 PUSH1 0xe0 0E1D 83 DUP4 0E1E 01 ADD 0E1F 81 DUP2 0E20 90 SWAP1 0E21 52 MSTORE 0E22 60 PUSH1 0x20 0E24 83 DUP4 0E25 01 ADD 0E26 82 DUP3 0E27 60 PUSH1 0x03 0E29 81 DUP2 0E2A 11 GT 0E2B 15 ISZERO 0E2C 61 PUSH2 0x0e31 0E2F 57 *JUMPI 0E30 FE *ASSERT 0E31 5B JUMPDEST 0E32 60 PUSH1 0x03 0E34 81 DUP2 0E35 11 GT 0E36 15 ISZERO 0E37 61 PUSH2 0x0e3c 0E3A 57 *JUMPI 0E3B FE *ASSERT 0E3C 5B JUMPDEST 0E3D 90 SWAP1 0E3E 52 MSTORE 0E3F 50 POP 0E40 60 PUSH1 0x00 0E42 90 SWAP1 0E43 50 POP 0E44 81 DUP2 0E45 60 PUSH1 0x20 0E47 01 ADD 0E48 51 MLOAD 0E49 60 PUSH1 0x03 0E4B 81 DUP2 0E4C 11 GT 0E4D 15 ISZERO 0E4E 61 PUSH2 0x0e53 0E51 57 *JUMPI 0E52 FE *ASSERT 0E53 5B JUMPDEST 0E54 14 EQ 0E55 61 PUSH2 0x0e91 0E58 57 *JUMPI 0E59 60 PUSH1 0x40 0E5B 80 DUP1 0E5C 51 MLOAD 0E5D 60 PUSH1 0x01 0E5F 60 PUSH1 0xe5 0E61 1B SHL 0E62 62 PUSH3 0x461bcd 0E66 02 MUL 0E67 81 DUP2 0E68 52 MSTORE 0E69 60 PUSH1 0x20 0E6B 60 PUSH1 0x04 0E6D 82 DUP3 0E6E 01 ADD 0E6F 52 MSTORE 0E70 60 PUSH1 0x03 0E72 60 PUSH1 0x24 0E74 82 DUP3 0E75 01 ADD 0E76 52 MSTORE 0E77 60 PUSH1 0x01 0E79 60 PUSH1 0xe9 0E7B 1B SHL 0E7C 62 PUSH3 0x22989b 0E80 02 MUL 0E81 60 PUSH1 0x44 0E83 82 DUP3 0E84 01 ADD 0E85 52 MSTORE 0E86 90 SWAP1 0E87 51 MLOAD 0E88 90 SWAP1 0E89 81 DUP2 0E8A 90 SWAP1 0E8B 03 SUB 0E8C 60 PUSH1 0x64 0E8E 01 ADD 0E8F 90 SWAP1 0E90 FD *REVERT 0E91 5B JUMPDEST 0E92 60 PUSH1 0xe0 0E94 81 DUP2 0E95 01 ADD 0E96 51 MLOAD 0E97 60 PUSH1 0x01 0E99 60 PUSH1 0x01 0E9B 60 PUSH1 0xa0 0E9D 1B SHL 0E9E 03 SUB 0E9F 86 DUP7 0EA0 16 AND 0EA1 60 PUSH1 0x00 0EA3 90 SWAP1 0EA4 81 DUP2 0EA5 52 MSTORE 0EA6 60 PUSH1 0x0f 0EA8 60 PUSH1 0x20 0EAA 52 MSTORE 0EAB 60 PUSH1 0x40 0EAD 90 SWAP1 0EAE 20 SHA3 0EAF 55 SSTORE 0EB0 60 PUSH1 0x07 0EB2 54 SLOAD 0EB3 60 PUSH1 0x60 0EB5 82 DUP3 0EB6 01 ADD 0EB7 51 MLOAD 0EB8 61 PUSH2 0x0ec1 0EBB 91 SWAP2 0EBC 90 SWAP1 0EBD 61 PUSH2 0x2586 0EC0 56 *JUMP 0EC1 5B JUMPDEST 0EC2 60 PUSH1 0x80 0EC4 83 DUP4 0EC5 01 ADD 0EC6 81 DUP2 0EC7 90 SWAP1 0EC8 52 MSTORE 0EC9 60 PUSH1 0x20 0ECB 83 DUP4 0ECC 01 ADD 0ECD 82 DUP3 0ECE 60 PUSH1 0x03 0ED0 81 DUP2 0ED1 11 GT 0ED2 15 ISZERO 0ED3 61 PUSH2 0x0ed8 0ED6 57 *JUMPI 0ED7 FE *ASSERT 0ED8 5B JUMPDEST 0ED9 60 PUSH1 0x03 0EDB 81 DUP2 0EDC 11 GT 0EDD 15 ISZERO 0EDE 61 PUSH2 0x0ee3 0EE1 57 *JUMPI 0EE2 FE *ASSERT 0EE3 5B JUMPDEST 0EE4 90 SWAP1 0EE5 52 MSTORE 0EE6 50 POP 0EE7 60 PUSH1 0x00 0EE9 90 SWAP1 0EEA 50 POP 0EEB 81 DUP2 0EEC 60 PUSH1 0x20 0EEE 01 ADD 0EEF 51 MLOAD 0EF0 60 PUSH1 0x03 0EF2 81 DUP2 0EF3 11 GT 0EF4 15 ISZERO 0EF5 61 PUSH2 0x0efa 0EF8 57 *JUMPI 0EF9 FE *ASSERT 0EFA 5B JUMPDEST 0EFB 14 EQ 0EFC 61 PUSH2 0x0f38 0EFF 57 *JUMPI 0F00 60 PUSH1 0x40 0F02 80 DUP1 0F03 51 MLOAD 0F04 60 PUSH1 0x01 0F06 60 PUSH1 0xe5 0F08 1B SHL 0F09 62 PUSH3 0x461bcd 0F0D 02 MUL 0F0E 81 DUP2 0F0F 52 MSTORE 0F10 60 PUSH1 0x20 0F12 60 PUSH1 0x04 0F14 82 DUP3 0F15 01 ADD 0F16 52 MSTORE 0F17 60 PUSH1 0x03 0F19 60 PUSH1 0x24 0F1B 82 DUP3 0F1C 01 ADD 0F1D 52 MSTORE 0F1E 60 PUSH1 0x01 0F20 60 PUSH1 0xea 0F22 1B SHL 0F23 62 PUSH3 0x114c4d 0F27 02 MUL 0F28 60 PUSH1 0x44 0F2A 82 DUP3 0F2B 01 ADD 0F2C 52 MSTORE 0F2D 90 SWAP1 0F2E 51 MLOAD 0F2F 90 SWAP1 0F30 81 DUP2 0F31 90 SWAP1 0F32 03 SUB 0F33 60 PUSH1 0x64 0F35 01 ADD 0F36 90 SWAP1 0F37 FD *REVERT 0F38 5B JUMPDEST 0F39 60 PUSH1 0x01 0F3B 60 PUSH1 0x01 0F3D 60 PUSH1 0xa0 0F3F 1B SHL 0F40 03 SUB 0F41 85 DUP6 0F42 16 AND 0F43 60 PUSH1 0x00 0F45 90 SWAP1 0F46 81 DUP2 0F47 52 MSTORE 0F48 60 PUSH1 0x0d 0F4A 60 PUSH1 0x20 0F4C 52 MSTORE 0F4D 60 PUSH1 0x40 0F4F 90 SWAP1 0F50 20 SHA3 0F51 54 SLOAD 0F52 60 PUSH1 0x60 0F54 82 DUP3 0F55 01 ADD 0F56 51 MLOAD 0F57 61 PUSH2 0x0f60 0F5A 91 SWAP2 0F5B 90 SWAP1 0F5C 61 PUSH2 0x2586 0F5F 56 *JUMP 0F60 5B JUMPDEST 0F61 60 PUSH1 0xa0 0F63 83 DUP4 0F64 01 ADD 0F65 81 DUP2 0F66 90 SWAP1 0F67 52 MSTORE 0F68 60 PUSH1 0x20 0F6A 83 DUP4 0F6B 01 ADD 0F6C 82 DUP3 0F6D 60 PUSH1 0x03 0F6F 81 DUP2 0F70 11 GT 0F71 15 ISZERO 0F72 61 PUSH2 0x0f77 0F75 57 *JUMPI 0F76 FE *ASSERT 0F77 5B JUMPDEST 0F78 60 PUSH1 0x03 0F7A 81 DUP2 0F7B 11 GT 0F7C 15 ISZERO 0F7D 61 PUSH2 0x0f82 0F80 57 *JUMPI 0F81 FE *ASSERT 0F82 5B JUMPDEST 0F83 90 SWAP1 0F84 52 MSTORE 0F85 50 POP 0F86 60 PUSH1 0x00 0F88 90 SWAP1 0F89 50 POP 0F8A 81 DUP2 0F8B 60 PUSH1 0x20 0F8D 01 ADD 0F8E 51 MLOAD 0F8F 60 PUSH1 0x03 0F91 81 DUP2 0F92 11 GT 0F93 15 ISZERO 0F94 61 PUSH2 0x0f99 0F97 57 *JUMPI 0F98 FE *ASSERT 0F99 5B JUMPDEST 0F9A 14 EQ 0F9B 61 PUSH2 0x0fd7 0F9E 57 *JUMPI 0F9F 60 PUSH1 0x40 0FA1 80 DUP1 0FA2 51 MLOAD 0FA3 60 PUSH1 0x01 0FA5 60 PUSH1 0xe5 0FA7 1B SHL 0FA8 62 PUSH3 0x461bcd 0FAC 02 MUL 0FAD 81 DUP2 0FAE 52 MSTORE 0FAF 60 PUSH1 0x20 0FB1 60 PUSH1 0x04 0FB3 82 DUP3 0FB4 01 ADD 0FB5 52 MSTORE 0FB6 60 PUSH1 0x03 0FB8 60 PUSH1 0x24 0FBA 82 DUP3 0FBB 01 ADD 0FBC 52 MSTORE 0FBD 60 PUSH1 0x01 0FBF 60 PUSH1 0xe8 0FC1 1B SHL 0FC2 62 PUSH3 0x453135 0FC6 02 MUL 0FC7 60 PUSH1 0x44 0FC9 82 DUP3 0FCA 01 ADD 0FCB 52 MSTORE 0FCC 90 SWAP1 0FCD 51 MLOAD 0FCE 90 SWAP1 0FCF 81 DUP2 0FD0 90 SWAP1 0FD1 03 SUB 0FD2 60 PUSH1 0x64 0FD4 01 ADD 0FD5 90 SWAP1 0FD6 FD *REVERT 0FD7 5B JUMPDEST 0FD8 60 PUSH1 0x80 0FDA 81 DUP2 0FDB 01 ADD 0FDC 51 MLOAD 0FDD 60 PUSH1 0x07 0FDF 55 SSTORE 0FE0 60 PUSH1 0xa0 0FE2 81 DUP2 0FE3 01 ADD 0FE4 51 MLOAD 0FE5 60 PUSH1 0x01 0FE7 60 PUSH1 0x01 0FE9 60 PUSH1 0xa0 0FEB 1B SHL 0FEC 03 SUB 0FED 86 DUP7 0FEE 16 AND 0FEF 60 PUSH1 0x00 0FF1 81 DUP2 0FF2 81 DUP2 0FF3 52 MSTORE 0FF4 60 PUSH1 0x0d 0FF6 60 PUSH1 0x20 0FF8 90 SWAP1 0FF9 81 DUP2 0FFA 52 MSTORE 0FFB 60 PUSH1 0x40 0FFD 91 SWAP2 0FFE 82 DUP3 0FFF 90 SWAP1 1000 20 SHA3 1001 93 SWAP4 1002 90 SWAP1 1003 93 SWAP4 1004 55 SSTORE 1005 60 PUSH1 0xc0 1007 84 DUP5 1008 01 ADD 1009 51 MLOAD 100A 60 PUSH1 0x60 100C 80 DUP1 100D 86 DUP7 100E 01 ADD 100F 51 MLOAD 1010 83 DUP4 1011 51 MLOAD 1012 94 SWAP5 1013 85 DUP6 1014 52 MSTORE 1015 94 SWAP5 1016 84 DUP5 1017 01 ADD 1018 91 SWAP2 1019 90 SWAP1 101A 91 SWAP2 101B 52 MSTORE 101C 82 DUP3 101D 82 DUP3 101E 01 ADD 101F 93 SWAP4 1020 90 SWAP1 1021 93 SWAP4 1022 52 MSTORE 1023 51 MLOAD 1024 7F PUSH32 0x4c209b5fc8ad50758f13e2e1088ba56a560dff690a1c6fef26394f4c03821c4f 1045 92 SWAP3 1046 91 SWAP2 1047 81 DUP2 1048 90 SWAP1 1049 03 SUB 104A 90 SWAP1 104B 91 SWAP2 104C 01 ADD 104D 90 SWAP1 104E A1 LOG1 104F 60 PUSH1 0x60 1051 81 DUP2 1052 01 ADD 1053 51 MLOAD 1054 60 PUSH1 0x40 1056 80 DUP1 1057 51 MLOAD 1058 91 SWAP2 1059 82 DUP3 105A 52 MSTORE 105B 51 MLOAD 105C 60 PUSH1 0x01 105E 60 PUSH1 0x01 1060 60 PUSH1 0xa0 1062 1B SHL 1063 03 SUB 1064 87 DUP8 1065 16 AND 1066 91 SWAP2 1067 30 ADDRESS 1068 91 SWAP2 1069 60 PUSH1 0x00 106B 80 DUP1 106C 51 MLOAD 106D 60 PUSH1 0x20 106F 61 PUSH2 0x54d1 1072 83 DUP4 1073 39 CODECOPY 1074 81 DUP2 1075 51 MLOAD 1076 91 SWAP2 1077 52 MSTORE 1078 91 SWAP2 1079 81 DUP2 107A 90 SWAP1 107B 03 SUB 107C 60 PUSH1 0x20 107E 01 ADD 107F 90 SWAP1 1080 A3 LOG3 1081 60 PUSH1 0xc0 1083 01 ADD 1084 51 MLOAD 1085 91 SWAP2 1086 50 POP 1087 50 POP 1088 60 PUSH1 0x00 108A 80 DUP1 108B 54 SLOAD 108C 62 PUSH3 0xff0000 1090 19 NOT 1091 16 AND 1092 62 PUSH3 0x010000 1096 17 OR 1097 90 SWAP1 1098 55 SSTORE 1099 92 SWAP3 109A 91 SWAP2 109B 50 POP 109C 50 POP 109D 56 *JUMP label_109E: // Incoming call from 0x02A9, returns to 0x02AA // Inputs[2] // { // @10A2 storage[0x03] // @10A6 memory[0x40:0x60] // } 109E 5B JUMPDEST 109F 60 PUSH1 0x03 10A1 80 DUP1 10A2 54 SLOAD 10A3 60 PUSH1 0x40 10A5 80 DUP1 10A6 51 MLOAD 10A7 60 PUSH1 0x20 10A9 60 PUSH1 0x02 10AB 60 PUSH1 0x01 10AD 85 DUP6 10AE 16 AND 10AF 15 ISZERO 10B0 61 PUSH2 0x0100 10B3 02 MUL 10B4 60 PUSH1 0x00 10B6 19 NOT 10B7 01 ADD 10B8 90 SWAP1 10B9 94 SWAP5 10BA 16 AND 10BB 93 SWAP4 10BC 90 SWAP1 10BD 93 SWAP4 10BE 04 DIV 10BF 60 PUSH1 0x1f 10C1 81 DUP2 10C2 01 ADD 10C3 84 DUP5 10C4 90 SWAP1 10C5 04 DIV 10C6 84 DUP5 10C7 02 MUL 10C8 82 DUP3 10C9 01 ADD 10CA 84 DUP5 10CB 01 ADD 10CC 90 SWAP1 10CD 92 SWAP3 10CE 52 MSTORE 10CF 81 DUP2 10D0 81 DUP2 10D1 52 MSTORE 10D2 92 SWAP3 10D3 91 SWAP2 10D4 83 DUP4 10D5 01 ADD 10D6 82 DUP3 10D7 82 DUP3 10D8 80 DUP1 10D9 15 ISZERO 10DA 61 PUSH2 0x1124 10DD 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @10CD stack[2] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // @10CE memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 + 0x1f) / 0x20) // @10D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // @10D2 stack[0] = memory[0x40:0x60] // @10D3 stack[1] = 0x03 // @10D5 stack[3] = memory[0x40:0x60] + 0x20 // @10D6 stack[4] = 0x03 // @10D7 stack[5] = (storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x1124, if !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) label_10DE: // Incoming jump from 0x10DD, if not !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) // Inputs[1] { @10DE stack[-1] } 10DE 80 DUP1 10DF 60 PUSH1 0x1f 10E1 10 LT 10E2 61 PUSH2 0x10f9 10E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10f9, if 0x1f < stack[-1] label_10E6: // Incoming jump from 0x10E5, if not 0x1f < stack[-1] // Inputs[4] // { // @10EA stack[-2] // @10EB storage[stack[-2]] // @10EE stack[-3] // @10F0 stack[-1] // } 10E6 61 PUSH2 0x0100 10E9 80 DUP1 10EA 83 DUP4 10EB 54 SLOAD 10EC 04 DIV 10ED 02 MUL 10EE 83 DUP4 10EF 52 MSTORE 10F0 91 SWAP2 10F1 60 PUSH1 0x20 10F3 01 ADD 10F4 91 SWAP2 10F5 61 PUSH2 0x1124 10F8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @10EF memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @10F4 stack[-1] = stack[-1] // @10F4 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1124 label_10F9: // Incoming jump from 0x19C5, if 0x1f < stack[-1] // Incoming jump from 0x10E5, if 0x1f < stack[-1] // Inputs[5] // { // @10FA stack[-3] // @10FB stack[-1] // @10FD stack[-2] // @1105 memory[0x00:0x20] // @1109 storage[keccak256(memory[0x00:0x20])] // } 10F9 5B JUMPDEST 10FA 82 DUP3 10FB 01 ADD 10FC 91 SWAP2 10FD 90 SWAP1 10FE 60 PUSH1 0x00 1100 52 MSTORE 1101 60 PUSH1 0x20 1103 60 PUSH1 0x00 1105 20 SHA3 1106 90 SWAP1 1107 5B JUMPDEST 1108 81 DUP2 1109 54 SLOAD 110A 81 DUP2 110B 52 MSTORE 110C 90 SWAP1 110D 60 PUSH1 0x01 110F 01 ADD 1110 90 SWAP1 1111 60 PUSH1 0x20 1113 01 ADD 1114 80 DUP1 1115 83 DUP4 1116 11 GT 1117 61 PUSH2 0x1107 111A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @10FC stack[-3] = stack[-3] + stack[-1] // @1100 memory[0x00:0x20] = stack[-2] // @110B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1110 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1113 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1107, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_111B: // Incoming jump from 0x111A, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x111A, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @111B stack[-3] // @111C stack[-1] // } 111B 82 DUP3 111C 90 SWAP1 111D 03 SUB 111E 60 PUSH1 0x1f 1120 16 AND 1121 82 DUP3 1122 01 ADD 1123 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1123 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1123 stack[-1] = stack[-3] // } // Block continues label_1124: // Incoming jump from 0x10DD, if !((storage[0x03] & ~0x00 + 0x0100 * !(storage[0x03] & 0x01)) / 0x02) // Incoming jump from 0x10F8 // Incoming jump from 0x19D8 // Incoming jump from 0x19BD, if !((storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02) // Incoming jump from 0x1123 // Inputs[1] { @112A stack[-7] } 1124 5B JUMPDEST 1125 50 POP 1126 50 POP 1127 50 POP 1128 50 POP 1129 50 POP 112A 81 DUP2 112B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_112C: // Incoming jump from 0x0357 // Inputs[9] // { // @112D msg.sender // @113E memory[0x00:0x40] // @1147 stack[-2] // @1151 memory[0x00:0x40] // @1152 stack[-1] // @1156 memory[0x40:0x60] // @115B memory[0x40:0x60] // @118D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @1191 stack[-3] // } 112C 5B JUMPDEST 112D 33 CALLER 112E 60 PUSH1 0x00 1130 81 DUP2 1131 81 DUP2 1132 52 MSTORE 1133 60 PUSH1 0x0e 1135 60 PUSH1 0x20 1137 90 SWAP1 1138 81 DUP2 1139 52 MSTORE 113A 60 PUSH1 0x40 113C 80 DUP1 113D 83 DUP4 113E 20 SHA3 113F 60 PUSH1 0x01 1141 60 PUSH1 0x01 1143 60 PUSH1 0xa0 1145 1B SHL 1146 03 SUB 1147 87 DUP8 1148 16 AND 1149 80 DUP1 114A 85 DUP6 114B 52 MSTORE 114C 90 SWAP1 114D 83 DUP4 114E 52 MSTORE 114F 81 DUP2 1150 84 DUP5 1151 20 SHA3 1152 86 DUP7 1153 90 SWAP1 1154 55 SSTORE 1155 81 DUP2 1156 51 MLOAD 1157 86 DUP7 1158 81 DUP2 1159 52 MSTORE 115A 91 SWAP2 115B 51 MLOAD 115C 93 SWAP4 115D 94 SWAP5 115E 93 SWAP4 115F 90 SWAP1 1160 92 SWAP3 1161 84 DUP5 1162 92 SWAP3 1163 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1184 92 SWAP3 1185 90 SWAP1 1186 81 DUP2 1187 90 SWAP1 1188 03 SUB 1189 90 SWAP1 118A 91 SWAP2 118B 01 ADD 118C 90 SWAP1 118D A3 LOG3 118E 50 POP 118F 60 PUSH1 0x01 1191 93 SWAP4 1192 92 SWAP3 1193 50 POP 1194 50 POP 1195 50 POP 1196 56 *JUMP // Stack delta = -2 // Outputs[8] // { // @1132 memory[0x00:0x20] = msg.sender // @1139 memory[0x20:0x40] = 0x0e // @114B memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @114E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1154 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1159 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @118D log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // @1191 stack[-3] = 0x01 // } // Block ends with unconditional jump to stack[-3] label_1197: // Incoming jump from 0x0373 // Inputs[2] // { // @119D msg.sender // @119E msg.value // } 1197 5B JUMPDEST 1198 60 PUSH1 0x00 119A 61 PUSH2 0x11a3 119D 33 CALLER 119E 34 CALLVALUE 119F 61 PUSH2 0x0b18 11A2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1198 stack[0] = 0x00 // @119A stack[1] = 0x11a3 // @119D stack[2] = msg.sender // @119E stack[3] = msg.value // } // Block ends with unconditional jump to 0x0b18 label_11A3: // Incoming return from call to 0x306E at 0x1571 // Incoming return from call to 0x4105 at 0x23F1 // Inputs[2] // { // @11A4 stack[-1] // @11A4 stack[-2] // } 11A3 5B JUMPDEST 11A4 90 SWAP1 11A5 50 POP // Stack delta = -1 // Outputs[1] { @11A4 stack[-2] = stack[-1] } // Block continues label_11A6: // Incoming jump from 0x11A5 // Incoming jump from 0x1A5B // Incoming return from call to 0x544D at 0x5496 // Inputs[2] // { // @11A7 stack[-1] // @11A7 stack[-2] // } 11A6 5B JUMPDEST 11A7 90 SWAP1 11A8 56 *JUMP // Stack delta = -1 // Outputs[1] { @11A7 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_11A9: // Incoming call from 0x039A, returns to 0x0374 // Inputs[2] // { // @11AC storage[0x0b] // @11AD stack[-1] // } 11A9 5B JUMPDEST 11AA 60 PUSH1 0x0b 11AC 54 SLOAD 11AD 81 DUP2 11AE 56 *JUMP // Stack delta = +1 // Outputs[1] { @11AC stack[0] = storage[0x0b] } // Block ends with unconditional jump to stack[-1] label_11AF: // Incoming jump from 0x03CD // Inputs[1] { @11B3 storage[0x00] } 11AF 5B JUMPDEST 11B0 60 PUSH1 0x00 11B2 80 DUP1 11B3 54 SLOAD 11B4 62 PUSH3 0x010000 11B8 90 SWAP1 11B9 04 DIV 11BA 60 PUSH1 0xff 11BC 16 AND 11BD 61 PUSH2 0x11f9 11C0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @11B0 stack[0] = 0x00 } // Block ends with conditional jump to 0x11f9, if 0xff & storage[0x00] / 0x010000 label_11C1: // Incoming jump from 0x11C0, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @11C4 memory[0x40:0x60] // @11EF memory[0x40:0x60] // @11F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 11C1 60 PUSH1 0x40 11C3 80 DUP1 11C4 51 MLOAD 11C5 60 PUSH1 0x01 11C7 60 PUSH1 0xe5 11C9 1B SHL 11CA 62 PUSH3 0x461bcd 11CE 02 MUL 11CF 81 DUP2 11D0 52 MSTORE 11D1 60 PUSH1 0x20 11D3 60 PUSH1 0x04 11D5 82 DUP3 11D6 01 ADD 11D7 52 MSTORE 11D8 60 PUSH1 0x03 11DA 60 PUSH1 0x24 11DC 82 DUP3 11DD 01 ADD 11DE 52 MSTORE 11DF 60 PUSH1 0x01 11E1 60 PUSH1 0xe8 11E3 1B SHL 11E4 62 PUSH3 0x453637 11E8 02 MUL 11E9 60 PUSH1 0x44 11EB 82 DUP3 11EC 01 ADD 11ED 52 MSTORE 11EE 90 SWAP1 11EF 51 MLOAD 11F0 90 SWAP1 11F1 81 DUP2 11F2 90 SWAP1 11F3 03 SUB 11F4 60 PUSH1 0x64 11F6 01 ADD 11F7 90 SWAP1 11F8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @11D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @11D7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11DE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @11ED memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @11F8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_11F9: // Incoming jump from 0x11C0, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @11FD storage[0x00] } 11F9 5B JUMPDEST 11FA 60 PUSH1 0x00 11FC 80 DUP1 11FD 54 SLOAD 11FE 62 PUSH3 0xff0000 1202 19 NOT 1203 16 AND 1204 81 DUP2 1205 55 SSTORE 1206 61 PUSH2 0x120d 1209 61 PUSH2 0x1a38 120C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @11FA stack[0] = 0x00 // @1205 storage[0x00] = ~0xff0000 & storage[0x00] // @1206 stack[1] = 0x120d // } // Block ends with call to 0x1a38, returns to 0x120D label_120D: // Incoming return from call to 0x1A38 at 0x120C // Incoming return from call to 0x1A38 at 0x120C // Inputs[2] // { // @120E stack[-2] // @120E stack[-1] // } 120D 5B JUMPDEST 120E 14 EQ 120F 61 PUSH2 0x124a 1212 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x124a, if stack[-1] == stack[-2] label_1213: // Incoming jump from 0x1212, if not stack[-1] == stack[-2] // Inputs[3] // { // @1216 memory[0x40:0x60] // @1240 memory[0x40:0x60] // @1249 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1213 60 PUSH1 0x40 1215 80 DUP1 1216 51 MLOAD 1217 60 PUSH1 0x01 1219 60 PUSH1 0xe5 121B 1B SHL 121C 62 PUSH3 0x461bcd 1220 02 MUL 1221 81 DUP2 1222 52 MSTORE 1223 60 PUSH1 0x20 1225 60 PUSH1 0x04 1227 82 DUP3 1228 01 ADD 1229 52 MSTORE 122A 60 PUSH1 0x02 122C 60 PUSH1 0x24 122E 82 DUP3 122F 01 ADD 1230 52 MSTORE 1231 60 PUSH1 0x01 1233 60 PUSH1 0xf0 1235 1B SHL 1236 61 PUSH2 0x4535 1239 02 MUL 123A 60 PUSH1 0x44 123C 82 DUP3 123D 01 ADD 123E 52 MSTORE 123F 90 SWAP1 1240 51 MLOAD 1241 90 SWAP1 1242 81 DUP2 1243 90 SWAP1 1244 03 SUB 1245 60 PUSH1 0x64 1247 01 ADD 1248 90 SWAP1 1249 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1222 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1229 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1230 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @123E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @1249 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_124A: // Incoming jump from 0x1212, if stack[-1] == stack[-2] // Inputs[1] { @124E stack[-2] } 124A 5B JUMPDEST 124B 61 PUSH2 0x1253 124E 82 DUP3 124F 61 PUSH2 0x19d9 1252 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @124B stack[0] = 0x1253 // @124E stack[1] = stack[-2] // } // Block ends with call to 0x19d9, returns to 0x1253 label_1253: // Incoming return from call to 0x19D9 at 0x1252 // Incoming return from call to 0x4E3D at 0x3B3A // Inputs[5] // { // @1254 stack[-2] // @1254 stack[-1] // @1259 storage[0x00] // @1267 stack[-4] // @1268 stack[-3] // } 1253 5B JUMPDEST 1254 90 SWAP1 1255 50 POP 1256 60 PUSH1 0x00 1258 80 DUP1 1259 54 SLOAD 125A 62 PUSH3 0xff0000 125E 19 NOT 125F 16 AND 1260 62 PUSH3 0x010000 1264 17 OR 1265 90 SWAP1 1266 55 SSTORE 1267 91 SWAP2 1268 90 SWAP1 1269 50 POP 126A 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1266 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @1267 stack[-4] = stack[-1] // } // Block ends with unconditional jump to stack[-4] label_126B: // Incoming call from 0x03E2, returns to 0x0374 // Inputs[2] // { // @126E storage[0x07] // @126F stack[-1] // } 126B 5B JUMPDEST 126C 60 PUSH1 0x07 126E 54 SLOAD 126F 81 DUP2 1270 56 *JUMP // Stack delta = +1 // Outputs[1] { @126E stack[0] = storage[0x07] } // Block ends with unconditional jump to stack[-1] label_1271: // Incoming call from 0x2041, returns to 0x2042 // Incoming call from 0x03F7, returns to 0x0374 1271 5B JUMPDEST 1272 60 PUSH1 0x00 1274 80 DUP1 1275 60 PUSH1 0x00 1277 61 PUSH2 0x127e 127A 61 PUSH2 0x23f6 127D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1272 stack[0] = 0x00 // @1274 stack[1] = 0x00 // @1275 stack[2] = 0x00 // @1277 stack[3] = 0x127e // } // Block ends with call to 0x23f6, returns to 0x127E label_127E: // Incoming return from call to 0x23F6 at 0x127D // Inputs[4] // { // @127F stack[-1] // @127F stack[-2] // @1280 stack[-4] // @1282 stack[-3] // } 127E 5B JUMPDEST 127F 90 SWAP1 1280 92 SWAP3 1281 50 POP 1282 90 SWAP1 1283 50 POP 1284 60 PUSH1 0x00 1286 82 DUP3 1287 60 PUSH1 0x03 1289 81 DUP2 128A 11 GT 128B 15 ISZERO 128C 61 PUSH2 0x1291 128F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1280 stack[-4] = stack[-2] // @1282 stack[-3] = stack[-1] // @1284 stack[-2] = 0x00 // @1286 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1291, if !(stack[-2] > 0x03) label_1290: // Incoming jump from 0x128F, if not !(stack[-2] > 0x03) 1290 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1290 assert(); } // Block terminates label_1291: // Incoming jump from 0x128F, if !(stack[-2] > 0x03) // Inputs[2] // { // @1292 stack[-1] // @1292 stack[-2] // } 1291 5B JUMPDEST 1292 14 EQ 1293 61 PUSH2 0x12cf 1296 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x12cf, if stack[-1] == stack[-2] label_1297: // Incoming jump from 0x1296, if not stack[-1] == stack[-2] // Inputs[3] // { // @129A memory[0x40:0x60] // @12C5 memory[0x40:0x60] // @12CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1297 60 PUSH1 0x40 1299 80 DUP1 129A 51 MLOAD 129B 60 PUSH1 0x01 129D 60 PUSH1 0xe5 129F 1B SHL 12A0 62 PUSH3 0x461bcd 12A4 02 MUL 12A5 81 DUP2 12A6 52 MSTORE 12A7 60 PUSH1 0x20 12A9 60 PUSH1 0x04 12AB 82 DUP3 12AC 01 ADD 12AD 52 MSTORE 12AE 60 PUSH1 0x03 12B0 60 PUSH1 0x24 12B2 82 DUP3 12B3 01 ADD 12B4 52 MSTORE 12B5 60 PUSH1 0x01 12B7 60 PUSH1 0xeb 12B9 1B SHL 12BA 62 PUSH3 0x08a6c7 12BE 02 MUL 12BF 60 PUSH1 0x44 12C1 82 DUP3 12C2 01 ADD 12C3 52 MSTORE 12C4 90 SWAP1 12C5 51 MLOAD 12C6 90 SWAP1 12C7 81 DUP2 12C8 90 SWAP1 12C9 03 SUB 12CA 60 PUSH1 0x64 12CC 01 ADD 12CD 90 SWAP1 12CE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @12A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @12AD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12B4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @12C3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x08a6c7 * (0x01 << 0xeb) // @12CE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_12CF: // Incoming return from call to 0x28BD at 0x14B7 // Incoming jump from 0x1296, if stack[-1] == stack[-2] // Incoming jump from 0x3095, if stack[-1] == stack[-2] // Inputs[3] // { // @12D0 stack[-1] // @12D0 stack[-3] // @12D3 stack[-4] // } 12CF 5B JUMPDEST 12D0 91 SWAP2 12D1 50 POP 12D2 50 POP 12D3 90 SWAP1 12D4 56 *JUMP // Stack delta = -3 // Outputs[1] { @12D3 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_12D5: // Incoming jump from 0x043A // Inputs[1] { @12D9 storage[0x00] } 12D5 5B JUMPDEST 12D6 60 PUSH1 0x00 12D8 80 DUP1 12D9 54 SLOAD 12DA 62 PUSH3 0x010000 12DE 90 SWAP1 12DF 04 DIV 12E0 60 PUSH1 0xff 12E2 16 AND 12E3 61 PUSH2 0x131f 12E6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12D6 stack[0] = 0x00 } // Block ends with conditional jump to 0x131f, if 0xff & storage[0x00] / 0x010000 label_12E7: // Incoming jump from 0x12E6, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @12EA memory[0x40:0x60] // @1315 memory[0x40:0x60] // @131E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 12E7 60 PUSH1 0x40 12E9 80 DUP1 12EA 51 MLOAD 12EB 60 PUSH1 0x01 12ED 60 PUSH1 0xe5 12EF 1B SHL 12F0 62 PUSH3 0x461bcd 12F4 02 MUL 12F5 81 DUP2 12F6 52 MSTORE 12F7 60 PUSH1 0x20 12F9 60 PUSH1 0x04 12FB 82 DUP3 12FC 01 ADD 12FD 52 MSTORE 12FE 60 PUSH1 0x03 1300 60 PUSH1 0x24 1302 82 DUP3 1303 01 ADD 1304 52 MSTORE 1305 60 PUSH1 0x01 1307 60 PUSH1 0xe8 1309 1B SHL 130A 62 PUSH3 0x453637 130E 02 MUL 130F 60 PUSH1 0x44 1311 82 DUP3 1312 01 ADD 1313 52 MSTORE 1314 90 SWAP1 1315 51 MLOAD 1316 90 SWAP1 1317 81 DUP2 1318 90 SWAP1 1319 03 SUB 131A 60 PUSH1 0x64 131C 01 ADD 131D 90 SWAP1 131E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @12F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @12FD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1304 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1313 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @131E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_131F: // Incoming jump from 0x12E6, if 0xff & storage[0x00] / 0x010000 // Inputs[5] // { // @1323 storage[0x00] // @132F msg.sender // @1330 stack[-4] // @1331 stack[-3] // @1332 stack[-2] // } 131F 5B JUMPDEST 1320 60 PUSH1 0x00 1322 80 DUP1 1323 54 SLOAD 1324 62 PUSH3 0xff0000 1328 19 NOT 1329 16 AND 132A 81 DUP2 132B 55 SSTORE 132C 61 PUSH2 0x1337 132F 33 CALLER 1330 86 DUP7 1331 86 DUP7 1332 86 DUP7 1333 61 PUSH2 0x25ac 1336 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1320 stack[0] = 0x00 // @132B storage[0x00] = ~0xff0000 & storage[0x00] // @132C stack[1] = 0x1337 // @132F stack[2] = msg.sender // @1330 stack[3] = stack[-4] // @1331 stack[4] = stack[-3] // @1332 stack[5] = stack[-2] // } // Block ends with call to 0x25ac, returns to 0x1337 label_1337: // Incoming return from call to 0x25AC at 0x1336 // Incoming return from call to 0x25AC at 0x1336 // Inputs[6] // { // @1338 stack[-2] // @1338 stack[-1] // @1339 stack[-3] // @133E storage[0x00] // @134C stack[-7] // @134D stack[-6] // } 1337 5B JUMPDEST 1338 14 EQ 1339 90 SWAP1 133A 50 POP 133B 60 PUSH1 0x00 133D 80 DUP1 133E 54 SLOAD 133F 62 PUSH3 0xff0000 1343 19 NOT 1344 16 AND 1345 62 PUSH3 0x010000 1349 17 OR 134A 90 SWAP1 134B 55 SSTORE 134C 93 SWAP4 134D 92 SWAP3 134E 50 POP 134F 50 POP 1350 50 POP 1351 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @134B storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @134C stack[-7] = stack[-1] == stack[-2] // } // Block ends with unconditional jump to stack[-7] label_1352: // Incoming jump from 0x044F 1352 5B JUMPDEST 1353 60 PUSH1 0x00 1355 80 DUP1 1356 61 PUSH2 0x135d 1359 61 PUSH2 0x1a38 135C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1353 stack[0] = 0x00 // @1355 stack[1] = 0x00 // @1356 stack[2] = 0x135d // } // Block ends with call to 0x1a38, returns to 0x135D label_135D: // Incoming return from call to 0x1A38 at 0x135C // Incoming return from call to 0x1A38 at 0x135C // Inputs[2] // { // @135E stack[-2] // @135E stack[-1] // } 135D 5B JUMPDEST 135E 14 EQ 135F 61 PUSH2 0x139a 1362 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x139a, if stack[-1] == stack[-2] label_1363: // Incoming jump from 0x1362, if not stack[-1] == stack[-2] // Inputs[3] // { // @1366 memory[0x40:0x60] // @1390 memory[0x40:0x60] // @1399 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1363 60 PUSH1 0x40 1365 80 DUP1 1366 51 MLOAD 1367 60 PUSH1 0x01 1369 60 PUSH1 0xe5 136B 1B SHL 136C 62 PUSH3 0x461bcd 1370 02 MUL 1371 81 DUP2 1372 52 MSTORE 1373 60 PUSH1 0x20 1375 60 PUSH1 0x04 1377 82 DUP3 1378 01 ADD 1379 52 MSTORE 137A 60 PUSH1 0x02 137C 60 PUSH1 0x24 137E 82 DUP3 137F 01 ADD 1380 52 MSTORE 1381 60 PUSH1 0x01 1383 60 PUSH1 0xf0 1385 1B SHL 1386 61 PUSH2 0x4535 1389 02 MUL 138A 60 PUSH1 0x44 138C 82 DUP3 138D 01 ADD 138E 52 MSTORE 138F 90 SWAP1 1390 51 MLOAD 1391 90 SWAP1 1392 81 DUP2 1393 90 SWAP1 1394 03 SUB 1395 60 PUSH1 0x64 1397 01 ADD 1398 90 SWAP1 1399 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1372 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1379 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1380 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @138E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @1399 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_139A: // Incoming jump from 0x1362, if stack[-1] == stack[-2] 139A 5B JUMPDEST 139B 61 PUSH2 0x13a2 139E 61 PUSH2 0x23f2 13A1 56 *JUMP // Stack delta = +1 // Outputs[1] { @139B stack[0] = 0x13a2 } // Block ends with call to 0x23f2, returns to 0x13A2 label_13A2: // Incoming return from call to 0x23F2 at 0x13A1 // Inputs[2] // { // @13A5 storage[0x08] // @13A6 stack[-1] // } 13A2 5B JUMPDEST 13A3 60 PUSH1 0x08 13A5 54 SLOAD 13A6 14 EQ 13A7 61 PUSH2 0x13e3 13AA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x13e3, if storage[0x08] == stack[-1] label_13AB: // Incoming jump from 0x13AA, if not storage[0x08] == stack[-1] // Inputs[3] // { // @13AE memory[0x40:0x60] // @13D9 memory[0x40:0x60] // @13E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 13AB 60 PUSH1 0x40 13AD 80 DUP1 13AE 51 MLOAD 13AF 60 PUSH1 0x01 13B1 60 PUSH1 0xe5 13B3 1B SHL 13B4 62 PUSH3 0x461bcd 13B8 02 MUL 13B9 81 DUP2 13BA 52 MSTORE 13BB 60 PUSH1 0x20 13BD 60 PUSH1 0x04 13BF 82 DUP3 13C0 01 ADD 13C1 52 MSTORE 13C2 60 PUSH1 0x03 13C4 60 PUSH1 0x24 13C6 82 DUP3 13C7 01 ADD 13C8 52 MSTORE 13C9 60 PUSH1 0x01 13CB 60 PUSH1 0xe8 13CD 1B SHL 13CE 62 PUSH3 0x453333 13D2 02 MUL 13D3 60 PUSH1 0x44 13D5 82 DUP3 13D6 01 ADD 13D7 52 MSTORE 13D8 90 SWAP1 13D9 51 MLOAD 13DA 90 SWAP1 13DB 81 DUP2 13DC 90 SWAP1 13DD 03 SUB 13DE 60 PUSH1 0x64 13E0 01 ADD 13E1 90 SWAP1 13E2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @13BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @13C1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13C8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @13D7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453333 * (0x01 << 0xe8) // @13E2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_13E3: // Incoming jump from 0x13AA, if storage[0x08] == stack[-1] // Inputs[6] // { // @13E7 storage[0x00] // @13EB memory[0x40:0x60] // @13F9 address(this) // @13FF msg.sender // @1406 memory[0x40:0x60] // @1433 address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } 13E3 5B JUMPDEST 13E4 60 PUSH1 0x00 13E6 80 DUP1 13E7 54 SLOAD 13E8 60 PUSH1 0x40 13EA 80 DUP1 13EB 51 MLOAD 13EC 60 PUSH1 0x01 13EE 60 PUSH1 0xe0 13F0 1B SHL 13F1 63 PUSH4 0xf53cc4b3 13F6 02 MUL 13F7 81 DUP2 13F8 52 MSTORE 13F9 30 ADDRESS 13FA 60 PUSH1 0x04 13FC 82 DUP3 13FD 01 ADD 13FE 52 MSTORE 13FF 33 CALLER 1400 60 PUSH1 0x24 1402 82 DUP3 1403 01 ADD 1404 52 MSTORE 1405 90 SWAP1 1406 51 MLOAD 1407 63 PUSH4 0x01000000 140C 90 SWAP1 140D 92 SWAP3 140E 04 DIV 140F 60 PUSH1 0x01 1411 60 PUSH1 0x01 1413 60 PUSH1 0xa0 1415 1B SHL 1416 03 SUB 1417 16 AND 1418 91 SWAP2 1419 63 PUSH4 0xf53cc4b3 141E 91 SWAP2 141F 60 PUSH1 0x44 1421 80 DUP1 1422 82 DUP3 1423 01 ADD 1424 92 SWAP3 1425 60 PUSH1 0x20 1427 92 SWAP3 1428 90 SWAP1 1429 91 SWAP2 142A 90 SWAP1 142B 82 DUP3 142C 90 SWAP1 142D 03 SUB 142E 01 ADD 142F 81 DUP2 1430 87 DUP8 1431 87 DUP8 1432 80 DUP1 1433 3B EXTCODESIZE 1434 15 ISZERO 1435 80 DUP1 1436 15 ISZERO 1437 61 PUSH2 0x143f 143A 57 *JUMPI // Stack delta = +11 // Outputs[14] // { // @13E4 stack[0] = 0x00 // @13F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf53cc4b3 * (0x01 << 0xe0) // @13FE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1404 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = msg.sender // @1418 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @141E stack[2] = 0xf53cc4b3 // @1424 stack[3] = memory[0x40:0x60] + 0x44 // @1427 stack[4] = 0x20 // @1429 stack[5] = memory[0x40:0x60] // @142E stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @142F stack[7] = memory[0x40:0x60] // @1430 stack[8] = 0x00 // @1431 stack[9] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @1434 stack[10] = !address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } // Block ends with conditional jump to 0x143f, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length label_143B: // Incoming jump from 0x143A, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[1] { @143E memory[0x00:0x00] } 143B 60 PUSH1 0x00 143D 80 DUP1 143E FD *REVERT // Stack delta = +0 // Outputs[1] { @143E revert(memory[0x00:0x00]); } // Block terminates label_143F: // Incoming jump from 0x143A, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[9] // { // @1441 msg.gas // @1442 stack[-6] // @1442 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1442 stack[-5] // @1442 stack[-3] // @1442 stack[-2] // @1442 memory[stack[-4]:stack[-4] + stack[-5]] // @1442 stack[-4] // @1442 stack[-7] // } 143F 5B JUMPDEST 1440 50 POP 1441 5A GAS 1442 F1 CALL 1443 15 ISZERO 1444 80 DUP1 1445 15 ISZERO 1446 61 PUSH2 0x1453 1449 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @1442 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1443 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1453, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_144A: // Incoming jump from 0x1449, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @144A returndata.length // @144E returndata[0x00:0x00 + returndata.length] // @144F returndata.length // @1452 memory[0x00:0x00 + returndata.length] // } 144A 3D RETURNDATASIZE 144B 60 PUSH1 0x00 144D 80 DUP1 144E 3E RETURNDATACOPY 144F 3D RETURNDATASIZE 1450 60 PUSH1 0x00 1452 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @144E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1452 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1453: // Incoming jump from 0x1449, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @145A memory[0x40:0x60] // @145B returndata.length // } 1453 5B JUMPDEST 1454 50 POP 1455 50 POP 1456 50 POP 1457 50 POP 1458 60 PUSH1 0x40 145A 51 MLOAD 145B 3D RETURNDATASIZE 145C 60 PUSH1 0x20 145E 81 DUP2 145F 10 LT 1460 15 ISZERO 1461 61 PUSH2 0x1469 1464 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @145A stack[-4] = memory[0x40:0x60] // @145B stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1469, if !(returndata.length < 0x20) label_1465: // Incoming jump from 0x1464, if not !(returndata.length < 0x20) // Inputs[1] { @1468 memory[0x00:0x00] } 1465 60 PUSH1 0x00 1467 80 DUP1 1468 FD *REVERT // Stack delta = +0 // Outputs[1] { @1468 revert(memory[0x00:0x00]); } // Block terminates label_1469: // Incoming jump from 0x1464, if !(returndata.length < 0x20) // Inputs[3] // { // @146B memory[stack[-2]:stack[-2] + 0x20] // @146B stack[-2] // @146C stack[-3] // } 1469 5B JUMPDEST 146A 50 POP 146B 51 MLOAD 146C 90 SWAP1 146D 50 POP 146E 80 DUP1 146F 15 ISZERO 1470 61 PUSH2 0x14ac 1473 57 *JUMPI // Stack delta = -2 // Outputs[1] { @146C stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x14ac, if !memory[stack[-2]:stack[-2] + 0x20] label_1474: // Incoming jump from 0x1473, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1477 memory[0x40:0x60] // @14A2 memory[0x40:0x60] // @14AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1474 60 PUSH1 0x40 1476 80 DUP1 1477 51 MLOAD 1478 60 PUSH1 0x01 147A 60 PUSH1 0xe5 147C 1B SHL 147D 62 PUSH3 0x461bcd 1481 02 MUL 1482 81 DUP2 1483 52 MSTORE 1484 60 PUSH1 0x20 1486 60 PUSH1 0x04 1488 82 DUP3 1489 01 ADD 148A 52 MSTORE 148B 60 PUSH1 0x03 148D 60 PUSH1 0x24 148F 82 DUP3 1490 01 ADD 1491 52 MSTORE 1492 60 PUSH1 0x01 1494 60 PUSH1 0xe8 1496 1B SHL 1497 62 PUSH3 0x453733 149B 02 MUL 149C 60 PUSH1 0x44 149E 82 DUP3 149F 01 ADD 14A0 52 MSTORE 14A1 90 SWAP1 14A2 51 MLOAD 14A3 90 SWAP1 14A4 81 DUP2 14A5 90 SWAP1 14A6 03 SUB 14A7 60 PUSH1 0x64 14A9 01 ADD 14AA 90 SWAP1 14AB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1483 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @148A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1491 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @14A0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453733 * (0x01 << 0xe8) // @14AB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_14AC: // Incoming jump from 0x1473, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @14B0 msg.sender } 14AC 5B JUMPDEST 14AD 61 PUSH2 0x12cf 14B0 33 CALLER 14B1 60 PUSH1 0x00 14B3 19 NOT 14B4 61 PUSH2 0x28bd 14B7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14AD stack[0] = 0x12cf // @14B0 stack[1] = msg.sender // @14B3 stack[2] = ~0x00 // } // Block ends with call to 0x28bd, returns to 0x12CF label_14B8: // Incoming call from 0x0464, returns to 0x0465 // Inputs[2] // { // @14BB storage[0x05] // @14BF stack[-1] // } 14B8 5B JUMPDEST 14B9 60 PUSH1 0x05 14BB 54 SLOAD 14BC 60 PUSH1 0xff 14BE 16 AND 14BF 81 DUP2 14C0 56 *JUMP // Stack delta = +1 // Outputs[1] { @14BE stack[0] = 0xff & storage[0x05] } // Block ends with unconditional jump to stack[-1] label_14C1: // Incoming call from 0x048F, returns to 0x0358 // Inputs[1] { @14C4 stack[-1] } 14C1 5B JUMPDEST 14C2 60 PUSH1 0x01 14C4 81 DUP2 14C5 56 *JUMP // Stack delta = +1 // Outputs[1] { @14C2 stack[0] = 0x01 } // Block ends with unconditional jump to stack[-1] label_14C6: // Incoming jump from 0x04C2 14C6 5B JUMPDEST 14C7 60 PUSH1 0x00 14C9 61 PUSH2 0x14d0 14CC 61 PUSH2 0x5357 14CF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14C7 stack[0] = 0x00 // @14C9 stack[1] = 0x14d0 // } // Block ends with call to 0x5357, returns to 0x14D0 label_14D0: // Incoming return from call to 0x5357 at 0x14CF // Inputs[1] { @14D3 memory[0x40:0x60] } 14D0 5B JUMPDEST 14D1 60 PUSH1 0x40 14D3 51 MLOAD 14D4 80 DUP1 14D5 60 PUSH1 0x20 14D7 01 ADD 14D8 60 PUSH1 0x40 14DA 52 MSTORE 14DB 80 DUP1 14DC 61 PUSH2 0x14e3 14DF 61 PUSH2 0x1f9f 14E2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @14D3 stack[0] = memory[0x40:0x60] // @14DA memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @14DB stack[1] = memory[0x40:0x60] // @14DC stack[2] = 0x14e3 // } // Block ends with call to 0x1f9f, returns to 0x14E3 label_14E3: // Incoming return from call to 0x1F9F at 0x14E2 // Inputs[7] // { // @14E4 stack[-1] // @14E4 stack[-2] // @14EE stack[-6] // @14FD memory[0x00:0x40] // @14FE storage[keccak256(memory[0x00:0x40])] // @14FF stack[-3] // @1500 stack[-4] // } 14E3 5B JUMPDEST 14E4 90 SWAP1 14E5 52 MSTORE 14E6 60 PUSH1 0x01 14E8 60 PUSH1 0x01 14EA 60 PUSH1 0xa0 14EC 1B SHL 14ED 03 SUB 14EE 84 DUP5 14EF 16 AND 14F0 60 PUSH1 0x00 14F2 90 SWAP1 14F3 81 DUP2 14F4 52 MSTORE 14F5 60 PUSH1 0x0d 14F7 60 PUSH1 0x20 14F9 52 MSTORE 14FA 60 PUSH1 0x40 14FC 81 DUP2 14FD 20 SHA3 14FE 54 SLOAD 14FF 91 SWAP2 1500 92 SWAP3 1501 50 POP 1502 90 SWAP1 1503 81 DUP2 1504 90 SWAP1 1505 61 PUSH2 0x150f 1508 90 SWAP1 1509 84 DUP5 150A 90 SWAP1 150B 61 PUSH2 0x3057 150E 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @14E5 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @14F4 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @14F9 memory[0x20:0x40] = 0x0d // @1500 stack[-4] = stack[-3] // @1502 stack[-3] = 0x00 // @1504 stack[-2] = 0x00 // @1508 stack[-1] = 0x150f // @150A stack[0] = stack[-3] // @150A stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3057, returns to 0x150F label_150F: // Incoming return from call to 0x3057 at 0x150E // Inputs[4] // { // @1510 stack[-1] // @1510 stack[-2] // @1511 stack[-4] // @1513 stack[-3] // } 150F 5B JUMPDEST 1510 90 SWAP1 1511 92 SWAP3 1512 50 POP 1513 90 SWAP1 1514 50 POP 1515 60 PUSH1 0x00 1517 82 DUP3 1518 60 PUSH1 0x03 151A 81 DUP2 151B 11 GT 151C 15 ISZERO 151D 61 PUSH2 0x1522 1520 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1511 stack[-4] = stack[-2] // @1513 stack[-3] = stack[-1] // @1515 stack[-2] = 0x00 // @1517 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1522, if !(stack[-2] > 0x03) label_1521: // Incoming jump from 0x1520, if not !(stack[-2] > 0x03) 1521 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1521 assert(); } // Block terminates label_1522: // Incoming jump from 0x1520, if !(stack[-2] > 0x03) // Inputs[2] // { // @1523 stack[-2] // @1523 stack[-1] // } 1522 5B JUMPDEST 1523 14 EQ 1524 61 PUSH2 0x1560 1527 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1560, if stack[-1] == stack[-2] label_1528: // Incoming jump from 0x1527, if not stack[-1] == stack[-2] // Inputs[3] // { // @152B memory[0x40:0x60] // @1556 memory[0x40:0x60] // @155F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1528 60 PUSH1 0x40 152A 80 DUP1 152B 51 MLOAD 152C 60 PUSH1 0x01 152E 60 PUSH1 0xe5 1530 1B SHL 1531 62 PUSH3 0x461bcd 1535 02 MUL 1536 81 DUP2 1537 52 MSTORE 1538 60 PUSH1 0x20 153A 60 PUSH1 0x04 153C 82 DUP3 153D 01 ADD 153E 52 MSTORE 153F 60 PUSH1 0x03 1541 60 PUSH1 0x24 1543 82 DUP3 1544 01 ADD 1545 52 MSTORE 1546 60 PUSH1 0x01 1548 60 PUSH1 0xe8 154A 1B SHL 154B 62 PUSH3 0x453639 154F 02 MUL 1550 60 PUSH1 0x44 1552 82 DUP3 1553 01 ADD 1554 52 MSTORE 1555 90 SWAP1 1556 51 MLOAD 1557 90 SWAP1 1558 81 DUP2 1559 90 SWAP1 155A 03 SUB 155B 60 PUSH1 0x64 155D 01 ADD 155E 90 SWAP1 155F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1537 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @153E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1545 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1554 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453639 * (0x01 << 0xe8) // @155F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1560: // Incoming jump from 0x1527, if stack[-1] == stack[-2] // Incoming jump from 0x4386, if !(stack[-7] > 0x10) // Incoming jump from 0x2664 // Inputs[3] // { // @1561 stack[-1] // @1561 stack[-6] // @1562 stack[-5] // } 1560 5B JUMPDEST 1561 94 SWAP5 1562 93 SWAP4 1563 50 POP 1564 50 POP 1565 50 POP 1566 50 POP 1567 56 *JUMP // Stack delta = -5 // Outputs[1] { @1561 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1568: // Incoming jump from 0x04D7 1568 5B JUMPDEST 1569 60 PUSH1 0x00 156B 61 PUSH2 0x11a3 156E 61 PUSH2 0x306e 1571 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1569 stack[0] = 0x00 // @156B stack[1] = 0x11a3 // } // Block ends with call to 0x306e, returns to 0x11A3 label_1572: // Incoming call from 0x04EC, returns to 0x0374 // Inputs[2] // { // @1575 storage[0x06] // @1576 stack[-1] // } 1572 5B JUMPDEST 1573 60 PUSH1 0x06 1575 54 SLOAD 1576 81 DUP2 1577 56 *JUMP // Stack delta = +1 // Outputs[1] { @1575 stack[0] = storage[0x06] } // Block ends with unconditional jump to stack[-1] label_1578: // Incoming jump from 0x051F // Inputs[4] // { // @1580 stack[-1] // @1586 memory[0x00:0x40] // @1587 storage[keccak256(memory[0x00:0x40])] // @1588 stack[-2] // } 1578 5B JUMPDEST 1579 60 PUSH1 0x0f 157B 60 PUSH1 0x20 157D 52 MSTORE 157E 60 PUSH1 0x00 1580 90 SWAP1 1581 81 DUP2 1582 52 MSTORE 1583 60 PUSH1 0x40 1585 90 SWAP1 1586 20 SHA3 1587 54 SLOAD 1588 81 DUP2 1589 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @157D memory[0x20:0x40] = 0x0f // @1582 memory[0x00:0x20] = stack[-1] // @1587 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_158A: // Incoming jump from 0x0527 158A 5B JUMPDEST 158B 60 PUSH1 0x00 158D 80 DUP1 158E 80 DUP1 158F 61 PUSH2 0x1596 1592 61 PUSH2 0x1a38 1595 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @158B stack[0] = 0x00 // @158D stack[1] = 0x00 // @158E stack[2] = 0x00 // @158F stack[3] = 0x1596 // } // Block ends with call to 0x1a38, returns to 0x1596 label_1596: // Incoming return from call to 0x1A38 at 0x1595 // Incoming return from call to 0x1A38 at 0x1595 // Inputs[2] // { // @1597 stack[-2] // @1597 stack[-1] // } 1596 5B JUMPDEST 1597 14 EQ 1598 61 PUSH2 0x15d3 159B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x15d3, if stack[-1] == stack[-2] label_159C: // Incoming jump from 0x159B, if not stack[-1] == stack[-2] // Inputs[3] // { // @159F memory[0x40:0x60] // @15C9 memory[0x40:0x60] // @15D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 159C 60 PUSH1 0x40 159E 80 DUP1 159F 51 MLOAD 15A0 60 PUSH1 0x01 15A2 60 PUSH1 0xe5 15A4 1B SHL 15A5 62 PUSH3 0x461bcd 15A9 02 MUL 15AA 81 DUP2 15AB 52 MSTORE 15AC 60 PUSH1 0x20 15AE 60 PUSH1 0x04 15B0 82 DUP3 15B1 01 ADD 15B2 52 MSTORE 15B3 60 PUSH1 0x02 15B5 60 PUSH1 0x24 15B7 82 DUP3 15B8 01 ADD 15B9 52 MSTORE 15BA 60 PUSH1 0x01 15BC 60 PUSH1 0xf0 15BE 1B SHL 15BF 61 PUSH2 0x4535 15C2 02 MUL 15C3 60 PUSH1 0x44 15C5 82 DUP3 15C6 01 ADD 15C7 52 MSTORE 15C8 90 SWAP1 15C9 51 MLOAD 15CA 90 SWAP1 15CB 81 DUP2 15CC 90 SWAP1 15CD 03 SUB 15CE 60 PUSH1 0x64 15D0 01 ADD 15D1 90 SWAP1 15D2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @15AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @15B2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15B9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @15C7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @15D2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_15D3: // Incoming jump from 0x159B, if stack[-1] == stack[-2] 15D3 5B JUMPDEST 15D4 61 PUSH2 0x15db 15D7 61 PUSH2 0x23f2 15DA 56 *JUMP // Stack delta = +1 // Outputs[1] { @15D4 stack[0] = 0x15db } // Block ends with call to 0x23f2, returns to 0x15DB label_15DB: // Incoming return from call to 0x23F2 at 0x15DA // Inputs[2] // { // @15DE storage[0x08] // @15DF stack[-1] // } 15DB 5B JUMPDEST 15DC 60 PUSH1 0x08 15DE 54 SLOAD 15DF 14 EQ 15E0 61 PUSH2 0x161b 15E3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x161b, if storage[0x08] == stack[-1] label_15E4: // Incoming jump from 0x15E3, if not storage[0x08] == stack[-1] // Inputs[3] // { // @15E7 memory[0x40:0x60] // @1611 memory[0x40:0x60] // @161A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 15E4 60 PUSH1 0x40 15E6 80 DUP1 15E7 51 MLOAD 15E8 60 PUSH1 0x01 15EA 60 PUSH1 0xe5 15EC 1B SHL 15ED 62 PUSH3 0x461bcd 15F1 02 MUL 15F2 81 DUP2 15F3 52 MSTORE 15F4 60 PUSH1 0x20 15F6 60 PUSH1 0x04 15F8 82 DUP3 15F9 01 ADD 15FA 52 MSTORE 15FB 60 PUSH1 0x02 15FD 60 PUSH1 0x24 15FF 82 DUP3 1600 01 ADD 1601 52 MSTORE 1602 60 PUSH1 0x01 1604 60 PUSH1 0xf0 1606 1B SHL 1607 61 PUSH2 0x4537 160A 02 MUL 160B 60 PUSH1 0x44 160D 82 DUP3 160E 01 ADD 160F 52 MSTORE 1610 90 SWAP1 1611 51 MLOAD 1612 90 SWAP1 1613 81 DUP2 1614 90 SWAP1 1615 03 SUB 1616 60 PUSH1 0x64 1618 01 ADD 1619 90 SWAP1 161A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @15F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @15FA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1601 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @160F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4537 * (0x01 << 0xf0) // @161A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_161B: // Incoming jump from 0x15E3, if storage[0x08] == stack[-1] // Inputs[1] { @161F msg.value } 161B 5B JUMPDEST 161C 61 PUSH2 0x1624 161F 34 CALLVALUE 1620 61 PUSH2 0x309a 1623 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @161C stack[0] = 0x1624 // @161F stack[1] = msg.value // } // Block ends with call to 0x309a, returns to 0x1624 label_1624: // Incoming return from call to 0x309A at 0x1623 // Inputs[4] // { // @1625 stack[-1] // @1625 stack[-3] // @1627 stack[-2] // @1627 stack[-4] // } 1624 5B JUMPDEST 1625 91 SWAP2 1626 50 POP 1627 91 SWAP2 1628 50 POP // Stack delta = -2 // Outputs[2] // { // @1625 stack[-3] = stack[-1] // @1627 stack[-4] = stack[-2] // } // Block continues label_1629: // Incoming jump from 0x248F // Incoming jump from 0x2410 // Incoming jump from 0x245E // Incoming jump from 0x1628 // Incoming jump from 0x24A0 // Inputs[3] // { // @162A stack[-1] // @162A stack[-2] // @162B stack[-3] // } 1629 5B JUMPDEST 162A 90 SWAP1 162B 91 SWAP2 162C 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @162A stack[-2] = stack[-1] // @162B stack[-3] = stack[-2] // } // Block ends with unconditional jump to stack[-3] label_162D: // Incoming jump from 0x056A 162D 5B JUMPDEST 162E 60 PUSH1 0x00 1630 80 DUP1 1631 61 PUSH2 0x1638 1634 61 PUSH2 0x1a38 1637 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @162E stack[0] = 0x00 // @1630 stack[1] = 0x00 // @1631 stack[2] = 0x1638 // } // Block ends with call to 0x1a38, returns to 0x1638 label_1638: // Incoming return from call to 0x1A38 at 0x1637 // Incoming return from call to 0x1A38 at 0x1637 // Inputs[2] // { // @1639 stack[-2] // @1639 stack[-1] // } 1638 5B JUMPDEST 1639 90 SWAP1 163A 50 POP 163B 80 DUP1 163C 15 ISZERO 163D 61 PUSH2 0x1678 1640 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1639 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1678, if !stack[-1] label_1641: // Incoming jump from 0x1640, if not !stack[-1] // Inputs[3] // { // @1644 memory[0x40:0x60] // @166E memory[0x40:0x60] // @1677 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1641 60 PUSH1 0x40 1643 80 DUP1 1644 51 MLOAD 1645 60 PUSH1 0x01 1647 60 PUSH1 0xe5 1649 1B SHL 164A 62 PUSH3 0x461bcd 164E 02 MUL 164F 81 DUP2 1650 52 MSTORE 1651 60 PUSH1 0x20 1653 60 PUSH1 0x04 1655 82 DUP3 1656 01 ADD 1657 52 MSTORE 1658 60 PUSH1 0x02 165A 60 PUSH1 0x24 165C 82 DUP3 165D 01 ADD 165E 52 MSTORE 165F 60 PUSH1 0x01 1661 60 PUSH1 0xf0 1663 1B SHL 1664 61 PUSH2 0x4535 1667 02 MUL 1668 60 PUSH1 0x44 166A 82 DUP3 166B 01 ADD 166C 52 MSTORE 166D 90 SWAP1 166E 51 MLOAD 166F 90 SWAP1 1670 81 DUP2 1671 90 SWAP1 1672 03 SUB 1673 60 PUSH1 0x64 1675 01 ADD 1676 90 SWAP1 1677 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1650 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1657 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @165E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @166C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @1677 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1678: // Incoming jump from 0x1640, if !stack[-1] // Inputs[1] { @167C stack[-3] } 1678 5B JUMPDEST 1679 61 PUSH2 0x1681 167C 83 DUP4 167D 61 PUSH2 0x3119 1680 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1679 stack[0] = 0x1681 // @167C stack[1] = stack[-3] // } // Block ends with call to 0x3119, returns to 0x1681 label_1681: // Incoming return from call to 0x3E60 at 0x2289 // Incoming jump from 0x19FF, if stack[-1] == stack[-2] // Incoming return from call to 0x3119 at 0x1680 // Incoming jump from 0x43EC, if !(stack[-6] > 0x10) // Incoming jump from 0x4104 // Incoming jump from 0x3FD7 // Inputs[3] // { // @1682 stack[-5] // @1682 stack[-1] // @1683 stack[-4] // } 1681 5B JUMPDEST 1682 93 SWAP4 1683 92 SWAP3 1684 50 POP 1685 50 POP 1686 50 POP 1687 56 *JUMP // Stack delta = -4 // Outputs[1] { @1682 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1688: // Incoming call from 0x057F, returns to 0x0374 // Inputs[2] // { // @168B storage[0x08] // @168C stack[-1] // } 1688 5B JUMPDEST 1689 60 PUSH1 0x08 168B 54 SLOAD 168C 81 DUP2 168D 56 *JUMP // Stack delta = +1 // Outputs[1] { @168B stack[0] = storage[0x08] } // Block ends with unconditional jump to stack[-1] label_168E: // Incoming jump from 0x05B2 // Inputs[2] // { // @1691 storage[0x05] // @16A0 msg.sender // } 168E 5B JUMPDEST 168F 60 PUSH1 0x05 1691 54 SLOAD 1692 61 PUSH2 0x0100 1695 90 SWAP1 1696 04 DIV 1697 60 PUSH1 0x01 1699 60 PUSH1 0x01 169B 60 PUSH1 0xa0 169D 1B SHL 169E 03 SUB 169F 16 AND 16A0 33 CALLER 16A1 14 EQ 16A2 61 PUSH2 0x16dd 16A5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16dd, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 label_16A6: // Incoming jump from 0x16A5, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[3] // { // @16A9 memory[0x40:0x60] // @16D3 memory[0x40:0x60] // @16DC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 16A6 60 PUSH1 0x40 16A8 80 DUP1 16A9 51 MLOAD 16AA 60 PUSH1 0x01 16AC 60 PUSH1 0xe5 16AE 1B SHL 16AF 62 PUSH3 0x461bcd 16B3 02 MUL 16B4 81 DUP2 16B5 52 MSTORE 16B6 60 PUSH1 0x20 16B8 60 PUSH1 0x04 16BA 82 DUP3 16BB 01 ADD 16BC 52 MSTORE 16BD 60 PUSH1 0x02 16BF 60 PUSH1 0x24 16C1 82 DUP3 16C2 01 ADD 16C3 52 MSTORE 16C4 60 PUSH1 0x01 16C6 60 PUSH1 0xf0 16C8 1B SHL 16C9 61 PUSH2 0x4531 16CC 02 MUL 16CD 60 PUSH1 0x44 16CF 82 DUP3 16D0 01 ADD 16D1 52 MSTORE 16D2 90 SWAP1 16D3 51 MLOAD 16D4 90 SWAP1 16D5 81 DUP2 16D6 90 SWAP1 16D7 03 SUB 16D8 60 PUSH1 0x64 16DA 01 ADD 16DB 90 SWAP1 16DC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @16B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @16BC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @16C3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @16D1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4531 * (0x01 << 0xf0) // @16DC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_16DD: // Incoming jump from 0x16A5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[6] // { // @16E1 storage[0x05] // @16EB stack[-1] // @170B memory[0x40:0x60] // @1714 memory[0x40:0x60] // @173E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @1740 stack[-2] // } 16DD 5B JUMPDEST 16DE 60 PUSH1 0x05 16E0 80 DUP1 16E1 54 SLOAD 16E2 60 PUSH1 0x01 16E4 60 PUSH1 0x01 16E6 60 PUSH1 0xa0 16E8 1B SHL 16E9 03 SUB 16EA 80 DUP1 16EB 84 DUP5 16EC 16 AND 16ED 61 PUSH2 0x0100 16F0 90 SWAP1 16F1 81 DUP2 16F2 02 MUL 16F3 61 PUSH2 0x0100 16F6 60 PUSH1 0x01 16F8 60 PUSH1 0xa8 16FA 1B SHL 16FB 03 SUB 16FC 19 NOT 16FD 90 SWAP1 16FE 93 SWAP4 16FF 16 AND 1700 92 SWAP3 1701 90 SWAP1 1702 92 SWAP3 1703 17 OR 1704 92 SWAP3 1705 83 DUP4 1706 90 SWAP1 1707 55 SSTORE 1708 60 PUSH1 0x40 170A 80 DUP1 170B 51 MLOAD 170C 92 SWAP3 170D 90 SWAP1 170E 93 SWAP4 170F 04 DIV 1710 16 AND 1711 81 DUP2 1712 52 MSTORE 1713 90 SWAP1 1714 51 MLOAD 1715 7F PUSH32 0x71614071b88dee5e0b2ae578a9dd7b2ebbe9ae832ba419dc0242cd065a290b6c 1736 91 SWAP2 1737 81 DUP2 1738 90 SWAP1 1739 03 SUB 173A 60 PUSH1 0x20 173C 01 ADD 173D 90 SWAP1 173E A1 LOG1 173F 50 POP 1740 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @1707 storage[0x05] = (storage[0x05] & ~((0x01 << 0xa8) - 0x0100)) | 0x0100 * (stack[-1] & (0x01 << 0xa0) - 0x01) // @1712 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ((storage[0x05] & ~((0x01 << 0xa8) - 0x0100)) | 0x0100 * (stack[-1] & (0x01 << 0xa0) - 0x01)) / 0x0100 & (0x01 << 0xa0) - 0x01 // @173E log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x71614071b88dee5e0b2ae578a9dd7b2ebbe9ae832ba419dc0242cd065a290b6c]); // } // Block ends with unconditional jump to stack[-2] label_1741: // Incoming jump from 0x05E7 // Inputs[4] // { // @174A stack[-1] // @1758 memory[0x00:0x40] // @1759 storage[keccak256(memory[0x00:0x40])] // @175A stack[-2] // } 1741 5B JUMPDEST 1742 60 PUSH1 0x01 1744 60 PUSH1 0x01 1746 60 PUSH1 0xa0 1748 1B SHL 1749 03 SUB 174A 16 AND 174B 60 PUSH1 0x00 174D 90 SWAP1 174E 81 DUP2 174F 52 MSTORE 1750 60 PUSH1 0x0d 1752 60 PUSH1 0x20 1754 52 MSTORE 1755 60 PUSH1 0x40 1757 90 SWAP1 1758 20 SHA3 1759 54 SLOAD 175A 90 SWAP1 175B 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @174F memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1754 memory[0x20:0x40] = 0x0d // @175A stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_175C: // Incoming call from 0x05FC, returns to 0x0374 // Inputs[1] { @1760 storage[0x00] } 175C 5B JUMPDEST 175D 60 PUSH1 0x00 175F 80 DUP1 1760 54 SLOAD 1761 62 PUSH3 0x010000 1765 90 SWAP1 1766 04 DIV 1767 60 PUSH1 0xff 1769 16 AND 176A 61 PUSH2 0x17a6 176D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @175D stack[0] = 0x00 } // Block ends with conditional jump to 0x17a6, if 0xff & storage[0x00] / 0x010000 label_176E: // Incoming jump from 0x176D, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @1771 memory[0x40:0x60] // @179C memory[0x40:0x60] // @17A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 176E 60 PUSH1 0x40 1770 80 DUP1 1771 51 MLOAD 1772 60 PUSH1 0x01 1774 60 PUSH1 0xe5 1776 1B SHL 1777 62 PUSH3 0x461bcd 177B 02 MUL 177C 81 DUP2 177D 52 MSTORE 177E 60 PUSH1 0x20 1780 60 PUSH1 0x04 1782 82 DUP3 1783 01 ADD 1784 52 MSTORE 1785 60 PUSH1 0x03 1787 60 PUSH1 0x24 1789 82 DUP3 178A 01 ADD 178B 52 MSTORE 178C 60 PUSH1 0x01 178E 60 PUSH1 0xe8 1790 1B SHL 1791 62 PUSH3 0x453637 1795 02 MUL 1796 60 PUSH1 0x44 1798 82 DUP3 1799 01 ADD 179A 52 MSTORE 179B 90 SWAP1 179C 51 MLOAD 179D 90 SWAP1 179E 81 DUP2 179F 90 SWAP1 17A0 03 SUB 17A1 60 PUSH1 0x64 17A3 01 ADD 17A4 90 SWAP1 17A5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @177D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1784 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @178B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @179A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @17A5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_17A6: // Incoming jump from 0x176D, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @17AA storage[0x00] } 17A6 5B JUMPDEST 17A7 60 PUSH1 0x00 17A9 80 DUP1 17AA 54 SLOAD 17AB 62 PUSH3 0xff0000 17AF 19 NOT 17B0 16 AND 17B1 81 DUP2 17B2 55 SSTORE 17B3 61 PUSH2 0x17ba 17B6 61 PUSH2 0x1a38 17B9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17A7 stack[0] = 0x00 // @17B2 storage[0x00] = ~0xff0000 & storage[0x00] // @17B3 stack[1] = 0x17ba // } // Block ends with call to 0x1a38, returns to 0x17BA label_17BA: // Incoming return from call to 0x1A38 at 0x17B9 // Incoming return from call to 0x1A38 at 0x17B9 // Inputs[2] // { // @17BB stack[-1] // @17BB stack[-2] // } 17BA 5B JUMPDEST 17BB 14 EQ 17BC 61 PUSH2 0x17f7 17BF 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x17f7, if stack[-1] == stack[-2] label_17C0: // Incoming jump from 0x17BF, if not stack[-1] == stack[-2] // Inputs[3] // { // @17C3 memory[0x40:0x60] // @17ED memory[0x40:0x60] // @17F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 17C0 60 PUSH1 0x40 17C2 80 DUP1 17C3 51 MLOAD 17C4 60 PUSH1 0x01 17C6 60 PUSH1 0xe5 17C8 1B SHL 17C9 62 PUSH3 0x461bcd 17CD 02 MUL 17CE 81 DUP2 17CF 52 MSTORE 17D0 60 PUSH1 0x20 17D2 60 PUSH1 0x04 17D4 82 DUP3 17D5 01 ADD 17D6 52 MSTORE 17D7 60 PUSH1 0x02 17D9 60 PUSH1 0x24 17DB 82 DUP3 17DC 01 ADD 17DD 52 MSTORE 17DE 60 PUSH1 0x01 17E0 60 PUSH1 0xf0 17E2 1B SHL 17E3 61 PUSH2 0x4535 17E6 02 MUL 17E7 60 PUSH1 0x44 17E9 82 DUP3 17EA 01 ADD 17EB 52 MSTORE 17EC 90 SWAP1 17ED 51 MLOAD 17EE 90 SWAP1 17EF 81 DUP2 17F0 90 SWAP1 17F1 03 SUB 17F2 60 PUSH1 0x64 17F4 01 ADD 17F5 90 SWAP1 17F6 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @17CF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @17D6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @17DD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @17EB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @17F6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_17F7: // Incoming jump from 0x17BF, if stack[-1] == stack[-2] // Inputs[3] // { // @17FB storage[0x06] // @17FF storage[0x00] // @180D stack[-2] // } 17F7 5B JUMPDEST 17F8 50 POP 17F9 60 PUSH1 0x06 17FB 54 SLOAD 17FC 60 PUSH1 0x00 17FE 80 DUP1 17FF 54 SLOAD 1800 62 PUSH3 0xff0000 1804 19 NOT 1805 16 AND 1806 62 PUSH3 0x010000 180A 17 OR 180B 90 SWAP1 180C 55 SSTORE 180D 90 SWAP1 180E 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @180C storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @180D stack[-2] = storage[0x06] // } // Block ends with unconditional jump to stack[-2] label_180F: // Incoming jump from 0x0626 180F 5B JUMPDEST 1810 60 PUSH1 0x00 1812 80 DUP1 1813 61 PUSH2 0x181a 1816 61 PUSH2 0x1a38 1819 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1810 stack[0] = 0x00 // @1812 stack[1] = 0x00 // @1813 stack[2] = 0x181a // } // Block ends with call to 0x1a38, returns to 0x181A label_181A: // Incoming return from call to 0x1A38 at 0x1819 // Incoming return from call to 0x1A38 at 0x1819 // Inputs[2] // { // @181B stack[-2] // @181B stack[-1] // } 181A 5B JUMPDEST 181B 14 EQ 181C 61 PUSH2 0x1857 181F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1857, if stack[-1] == stack[-2] label_1820: // Incoming jump from 0x181F, if not stack[-1] == stack[-2] // Inputs[3] // { // @1823 memory[0x40:0x60] // @184D memory[0x40:0x60] // @1856 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1820 60 PUSH1 0x40 1822 80 DUP1 1823 51 MLOAD 1824 60 PUSH1 0x01 1826 60 PUSH1 0xe5 1828 1B SHL 1829 62 PUSH3 0x461bcd 182D 02 MUL 182E 81 DUP2 182F 52 MSTORE 1830 60 PUSH1 0x20 1832 60 PUSH1 0x04 1834 82 DUP3 1835 01 ADD 1836 52 MSTORE 1837 60 PUSH1 0x02 1839 60 PUSH1 0x24 183B 82 DUP3 183C 01 ADD 183D 52 MSTORE 183E 60 PUSH1 0x01 1840 60 PUSH1 0xf0 1842 1B SHL 1843 61 PUSH2 0x4535 1846 02 MUL 1847 60 PUSH1 0x44 1849 82 DUP3 184A 01 ADD 184B 52 MSTORE 184C 90 SWAP1 184D 51 MLOAD 184E 90 SWAP1 184F 81 DUP2 1850 90 SWAP1 1851 03 SUB 1852 60 PUSH1 0x64 1854 01 ADD 1855 90 SWAP1 1856 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @182F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1836 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @183D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @184B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @1856 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1857: // Incoming jump from 0x181F, if stack[-1] == stack[-2] 1857 5B JUMPDEST 1858 61 PUSH2 0x185f 185B 61 PUSH2 0x23f2 185E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1858 stack[0] = 0x185f } // Block ends with call to 0x23f2, returns to 0x185F label_185F: // Incoming return from call to 0x23F2 at 0x185E // Inputs[2] // { // @1862 storage[0x08] // @1863 stack[-1] // } 185F 5B JUMPDEST 1860 60 PUSH1 0x08 1862 54 SLOAD 1863 14 EQ 1864 61 PUSH2 0x18a0 1867 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x18a0, if storage[0x08] == stack[-1] label_1868: // Incoming jump from 0x1867, if not storage[0x08] == stack[-1] // Inputs[3] // { // @186B memory[0x40:0x60] // @1896 memory[0x40:0x60] // @189F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1868 60 PUSH1 0x40 186A 80 DUP1 186B 51 MLOAD 186C 60 PUSH1 0x01 186E 60 PUSH1 0xe5 1870 1B SHL 1871 62 PUSH3 0x461bcd 1875 02 MUL 1876 81 DUP2 1877 52 MSTORE 1878 60 PUSH1 0x20 187A 60 PUSH1 0x04 187C 82 DUP3 187D 01 ADD 187E 52 MSTORE 187F 60 PUSH1 0x03 1881 60 PUSH1 0x24 1883 82 DUP3 1884 01 ADD 1885 52 MSTORE 1886 60 PUSH1 0x01 1888 60 PUSH1 0xe8 188A 1B SHL 188B 62 PUSH3 0x453333 188F 02 MUL 1890 60 PUSH1 0x44 1892 82 DUP3 1893 01 ADD 1894 52 MSTORE 1895 90 SWAP1 1896 51 MLOAD 1897 90 SWAP1 1898 81 DUP2 1899 90 SWAP1 189A 03 SUB 189B 60 PUSH1 0x64 189D 01 ADD 189E 90 SWAP1 189F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1877 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @187E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1885 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1894 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453333 * (0x01 << 0xe8) // @189F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_18A0: // Incoming jump from 0x1867, if storage[0x08] == stack[-1] // Inputs[2] // { // @18A4 msg.sender // @18A5 stack[-2] // } 18A0 5B JUMPDEST 18A1 61 PUSH2 0x18aa 18A4 33 CALLER 18A5 83 DUP4 18A6 61 PUSH2 0x28bd 18A9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18A1 stack[0] = 0x18aa // @18A4 stack[1] = msg.sender // @18A5 stack[2] = stack[-2] // } // Block ends with call to 0x28bd, returns to 0x18AA label_18AA: // Incoming return from call to 0x28BD at 0x18A9 // Incoming jump from 0x196B // Inputs[3] // { // @18AB stack[-4] // @18AB stack[-1] // @18AC stack[-3] // } 18AA 5B JUMPDEST 18AB 92 SWAP3 18AC 91 SWAP2 18AD 50 POP 18AE 50 POP 18AF 56 *JUMP // Stack delta = -3 // Outputs[1] { @18AB stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_18B0: // Incoming call from 0x063B, returns to 0x0374 // Inputs[2] // { // @18B3 storage[0x0a] // @18B4 stack[-1] // } 18B0 5B JUMPDEST 18B1 60 PUSH1 0x0a 18B3 54 SLOAD 18B4 81 DUP2 18B5 56 *JUMP // Stack delta = +1 // Outputs[1] { @18B3 stack[0] = storage[0x0a] } // Block ends with unconditional jump to stack[-1] label_18B6: // Incoming jump from 0x066E // Inputs[2] // { // @18B9 storage[0x05] // @18CB msg.sender // } 18B6 5B JUMPDEST 18B7 60 PUSH1 0x05 18B9 54 SLOAD 18BA 60 PUSH1 0x00 18BC 90 SWAP1 18BD 61 PUSH2 0x0100 18C0 90 SWAP1 18C1 04 DIV 18C2 60 PUSH1 0x01 18C4 60 PUSH1 0x01 18C6 60 PUSH1 0xa0 18C8 1B SHL 18C9 03 SUB 18CA 16 AND 18CB 33 CALLER 18CC 14 EQ 18CD 61 PUSH2 0x1908 18D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18BC stack[0] = 0x00 } // Block ends with conditional jump to 0x1908, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 label_18D1: // Incoming jump from 0x18D0, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[3] // { // @18D4 memory[0x40:0x60] // @18FE memory[0x40:0x60] // @1907 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 18D1 60 PUSH1 0x40 18D3 80 DUP1 18D4 51 MLOAD 18D5 60 PUSH1 0x01 18D7 60 PUSH1 0xe5 18D9 1B SHL 18DA 62 PUSH3 0x461bcd 18DE 02 MUL 18DF 81 DUP2 18E0 52 MSTORE 18E1 60 PUSH1 0x20 18E3 60 PUSH1 0x04 18E5 82 DUP3 18E6 01 ADD 18E7 52 MSTORE 18E8 60 PUSH1 0x02 18EA 60 PUSH1 0x24 18EC 82 DUP3 18ED 01 ADD 18EE 52 MSTORE 18EF 60 PUSH1 0x01 18F1 60 PUSH1 0xf0 18F3 1B SHL 18F4 61 PUSH2 0x4531 18F7 02 MUL 18F8 60 PUSH1 0x44 18FA 82 DUP3 18FB 01 ADD 18FC 52 MSTORE 18FD 90 SWAP1 18FE 51 MLOAD 18FF 90 SWAP1 1900 81 DUP2 1901 90 SWAP1 1902 03 SUB 1903 60 PUSH1 0x64 1905 01 ADD 1906 90 SWAP1 1907 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @18E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @18E7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @18EE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @18FC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4531 * (0x01 << 0xf0) // @1907 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1908: // Incoming jump from 0x18D0, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[5] // { // @190C storage[0x00] // @1915 stack[-2] // @1937 memory[0x40:0x60] // @193B memory[0x40:0x60] // @1965 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1908 5B JUMPDEST 1909 60 PUSH1 0x00 190B 80 DUP1 190C 54 SLOAD 190D 60 PUSH1 0x01 190F 60 PUSH1 0x01 1911 60 PUSH1 0xa0 1913 1B SHL 1914 03 SUB 1915 84 DUP5 1916 16 AND 1917 63 PUSH4 0x01000000 191C 81 DUP2 191D 02 MUL 191E 63 PUSH4 0x01000000 1923 60 PUSH1 0x01 1925 60 PUSH1 0xb8 1927 1B SHL 1928 03 SUB 1929 19 NOT 192A 90 SWAP1 192B 92 SWAP3 192C 16 AND 192D 91 SWAP2 192E 90 SWAP1 192F 91 SWAP2 1930 17 OR 1931 90 SWAP1 1932 91 SWAP2 1933 55 SSTORE 1934 60 PUSH1 0x40 1936 80 DUP1 1937 51 MLOAD 1938 91 SWAP2 1939 82 DUP3 193A 52 MSTORE 193B 51 MLOAD 193C 7F PUSH32 0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6 195D 91 SWAP2 195E 81 DUP2 195F 90 SWAP1 1960 03 SUB 1961 60 PUSH1 0x20 1963 01 ADD 1964 90 SWAP1 1965 A1 LOG1 1966 60 PUSH1 0x00 1968 61 PUSH2 0x18aa 196B 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1933 storage[0x00] = (storage[0x00] & ~((0x01 << 0xb8) - 0x01000000)) | (stack[-2] & (0x01 << 0xa0) - 0x01) * 0x01000000 // @193A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1965 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xe253457d9ad994ca9682fc3bbc38c890dca73a2d5ecee3809e548bac8b00d7c6]); // @1966 stack[0] = 0x00 // } // Block ends with unconditional jump to 0x18aa label_196C: // Incoming jump from 0x06A1 // Inputs[4] // { // @1974 stack[-1] // @197A memory[0x00:0x40] // @197B storage[keccak256(memory[0x00:0x40])] // @197C stack[-2] // } 196C 5B JUMPDEST 196D 60 PUSH1 0x10 196F 60 PUSH1 0x20 1971 52 MSTORE 1972 60 PUSH1 0x00 1974 90 SWAP1 1975 81 DUP2 1976 52 MSTORE 1977 60 PUSH1 0x40 1979 90 SWAP1 197A 20 SHA3 197B 54 SLOAD 197C 81 DUP2 197D 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1971 memory[0x20:0x40] = 0x10 // @1976 memory[0x00:0x20] = stack[-1] // @197B stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_197E: // Incoming call from 0x06B6, returns to 0x02AA // Inputs[2] // { // @1982 storage[0x04] // @1986 memory[0x40:0x60] // } 197E 5B JUMPDEST 197F 60 PUSH1 0x04 1981 80 DUP1 1982 54 SLOAD 1983 60 PUSH1 0x40 1985 80 DUP1 1986 51 MLOAD 1987 60 PUSH1 0x20 1989 60 PUSH1 0x02 198B 60 PUSH1 0x01 198D 85 DUP6 198E 16 AND 198F 15 ISZERO 1990 61 PUSH2 0x0100 1993 02 MUL 1994 60 PUSH1 0x00 1996 19 NOT 1997 01 ADD 1998 90 SWAP1 1999 94 SWAP5 199A 16 AND 199B 93 SWAP4 199C 90 SWAP1 199D 93 SWAP4 199E 04 DIV 199F 60 PUSH1 0x1f 19A1 81 DUP2 19A2 01 ADD 19A3 84 DUP5 19A4 90 SWAP1 19A5 04 DIV 19A6 84 DUP5 19A7 02 MUL 19A8 82 DUP3 19A9 01 ADD 19AA 84 DUP5 19AB 01 ADD 19AC 90 SWAP1 19AD 92 SWAP3 19AE 52 MSTORE 19AF 81 DUP2 19B0 81 DUP2 19B1 52 MSTORE 19B2 92 SWAP3 19B3 91 SWAP2 19B4 83 DUP4 19B5 01 ADD 19B6 82 DUP3 19B7 82 DUP3 19B8 80 DUP1 19B9 15 ISZERO 19BA 61 PUSH2 0x1124 19BD 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @19AD stack[2] = (storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02 // @19AE memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + 0x20 * (((storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02 + 0x1f) / 0x20) // @19B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02 // @19B2 stack[0] = memory[0x40:0x60] // @19B3 stack[1] = 0x04 // @19B5 stack[3] = memory[0x40:0x60] + 0x20 // @19B6 stack[4] = 0x04 // @19B7 stack[5] = (storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02 // } // Block ends with conditional jump to 0x1124, if !((storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02) label_19BE: // Incoming jump from 0x19BD, if not !((storage[0x04] & ~0x00 + 0x0100 * !(storage[0x04] & 0x01)) / 0x02) // Inputs[1] { @19BE stack[-1] } 19BE 80 DUP1 19BF 60 PUSH1 0x1f 19C1 10 LT 19C2 61 PUSH2 0x10f9 19C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10f9, if 0x1f < stack[-1] label_19C6: // Incoming jump from 0x19C5, if not 0x1f < stack[-1] // Inputs[4] // { // @19CA stack[-2] // @19CB storage[stack[-2]] // @19CE stack[-3] // @19D0 stack[-1] // } 19C6 61 PUSH2 0x0100 19C9 80 DUP1 19CA 83 DUP4 19CB 54 SLOAD 19CC 04 DIV 19CD 02 MUL 19CE 83 DUP4 19CF 52 MSTORE 19D0 91 SWAP2 19D1 60 PUSH1 0x20 19D3 01 ADD 19D4 91 SWAP2 19D5 61 PUSH2 0x1124 19D8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @19CF memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @19D4 stack[-1] = stack[-1] // @19D4 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1124 label_19D9: // Incoming jump from 0x06E9 // Incoming call from 0x1252, returns to 0x1253 // Inputs[1] { @19E2 stack[-1] } 19D9 5B JUMPDEST 19DA 60 PUSH1 0x00 19DC 80 DUP1 19DD 60 PUSH1 0x00 19DF 61 PUSH2 0x19e7 19E2 84 DUP5 19E3 61 PUSH2 0x330c 19E6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @19DA stack[0] = 0x00 // @19DC stack[1] = 0x00 // @19DD stack[2] = 0x00 // @19DF stack[3] = 0x19e7 // @19E2 stack[4] = stack[-1] // } // Block ends with call to 0x330c, returns to 0x19E7 label_19E7: // Incoming return from call to 0x330C at 0x19E6 // Inputs[4] // { // @19E8 stack[-2] // @19E8 stack[-1] // @19E9 stack[-4] // @19EB stack[-3] // } 19E7 5B JUMPDEST 19E8 90 SWAP1 19E9 92 SWAP3 19EA 50 POP 19EB 90 SWAP1 19EC 50 POP 19ED 60 PUSH1 0x00 19EF 82 DUP3 19F0 60 PUSH1 0x03 19F2 81 DUP2 19F3 11 GT 19F4 15 ISZERO 19F5 61 PUSH2 0x19fa 19F8 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @19E9 stack[-4] = stack[-2] // @19EB stack[-3] = stack[-1] // @19ED stack[-2] = 0x00 // @19EF stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x19fa, if !(stack[-2] > 0x03) label_19F9: // Incoming jump from 0x19F8, if not !(stack[-2] > 0x03) 19F9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @19F9 assert(); } // Block terminates label_19FA: // Incoming jump from 0x19F8, if !(stack[-2] > 0x03) // Inputs[2] // { // @19FB stack[-1] // @19FB stack[-2] // } 19FA 5B JUMPDEST 19FB 14 EQ 19FC 61 PUSH2 0x1681 19FF 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1681, if stack[-1] == stack[-2] label_1A00: // Incoming jump from 0x19FF, if not stack[-1] == stack[-2] // Inputs[3] // { // @1A03 memory[0x40:0x60] // @1A2E memory[0x40:0x60] // @1A37 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1A00 60 PUSH1 0x40 1A02 80 DUP1 1A03 51 MLOAD 1A04 60 PUSH1 0x01 1A06 60 PUSH1 0xe5 1A08 1B SHL 1A09 62 PUSH3 0x461bcd 1A0D 02 MUL 1A0E 81 DUP2 1A0F 52 MSTORE 1A10 60 PUSH1 0x20 1A12 60 PUSH1 0x04 1A14 82 DUP3 1A15 01 ADD 1A16 52 MSTORE 1A17 60 PUSH1 0x03 1A19 60 PUSH1 0x24 1A1B 82 DUP3 1A1C 01 ADD 1A1D 52 MSTORE 1A1E 60 PUSH1 0x01 1A20 60 PUSH1 0xea 1A22 1B SHL 1A23 62 PUSH3 0x114dcd 1A27 02 MUL 1A28 60 PUSH1 0x44 1A2A 82 DUP3 1A2B 01 ADD 1A2C 52 MSTORE 1A2D 90 SWAP1 1A2E 51 MLOAD 1A2F 90 SWAP1 1A30 81 DUP2 1A31 90 SWAP1 1A32 03 SUB 1A33 60 PUSH1 0x64 1A35 01 ADD 1A36 90 SWAP1 1A37 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1A0F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1A16 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A1D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1A2C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x114dcd * (0x01 << 0xea) // @1A37 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1A38: // Incoming call from 0x1595, returns to 0x1596 // Incoming call from 0x4162, returns to 0x4163 // Incoming call from 0x0B75, returns to 0x0B76 // Incoming call from 0x3AF3, returns to 0x3AF4 // Incoming call from 0x2240, returns to 0x2241 // Incoming call from 0x3E09, returns to 0x3E0A // Incoming call from 0x1FFC, returns to 0x1FFD // Incoming call from 0x17B9, returns to 0x17BA // Incoming call from 0x135C, returns to 0x135D // Incoming call from 0x120C, returns to 0x120D // Incoming call from 0x1637, returns to 0x1638 // Incoming call from 0x2384, returns to 0x2385 // Incoming call from 0x06FE, returns to 0x0374 // Incoming call from 0x3506, returns to 0x3507 // Incoming call from 0x1819, returns to 0x181A 1A38 5B JUMPDEST 1A39 60 PUSH1 0x00 1A3B 80 DUP1 1A3C 61 PUSH2 0x1a43 1A3F 61 PUSH2 0x23f2 1A42 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A39 stack[0] = 0x00 // @1A3B stack[1] = 0x00 // @1A3C stack[2] = 0x1a43 // } // Block ends with call to 0x23f2, returns to 0x1A43 label_1A43: // Incoming return from call to 0x23F2 at 0x1A42 // Inputs[3] // { // @1A46 storage[0x08] // @1A47 stack[-1] // @1A48 stack[-2] // } 1A43 5B JUMPDEST 1A44 60 PUSH1 0x08 1A46 54 SLOAD 1A47 90 SWAP1 1A48 91 SWAP2 1A49 50 POP 1A4A 80 DUP1 1A4B 82 DUP3 1A4C 14 EQ 1A4D 15 ISZERO 1A4E 61 PUSH2 0x1a5c 1A51 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1A47 stack[-1] = storage[0x08] // @1A48 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x1a5c, if !(stack[-1] == storage[0x08]) label_1A52: // Incoming jump from 0x1A51, if not !(stack[-1] == storage[0x08]) // Inputs[1] { @1A54 stack[-3] } 1A52 60 PUSH1 0x00 1A54 92 SWAP3 1A55 50 POP 1A56 50 POP 1A57 50 POP 1A58 61 PUSH2 0x11a6 1A5B 56 *JUMP // Stack delta = -2 // Outputs[1] { @1A54 stack[-3] = 0x00 } // Block ends with unconditional jump to 0x11a6 label_1A5C: // Incoming jump from 0x1A51, if !(stack[-1] == storage[0x08]) 1A5C 5B JUMPDEST 1A5D 60 PUSH1 0x00 1A5F 61 PUSH2 0x1a66 1A62 61 PUSH2 0x306e 1A65 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A5D stack[0] = 0x00 // @1A5F stack[1] = 0x1a66 // } // Block ends with call to 0x306e, returns to 0x1A66 label_1A66: // Incoming return from call to 0x306E at 0x1A65 // Inputs[9] // { // @1A69 storage[0x06] // @1A6C storage[0x0a] // @1A6F storage[0x09] // @1A72 storage[0x01] // @1A76 memory[0x40:0x60] // @1A88 stack[-1] // @1A9A memory[0x40:0x60] // @1A9C stack[-2] // @1ACB address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length // } 1A66 5B JUMPDEST 1A67 60 PUSH1 0x06 1A69 54 SLOAD 1A6A 60 PUSH1 0x0a 1A6C 54 SLOAD 1A6D 60 PUSH1 0x09 1A6F 54 SLOAD 1A70 60 PUSH1 0x01 1A72 54 SLOAD 1A73 60 PUSH1 0x40 1A75 80 DUP1 1A76 51 MLOAD 1A77 60 PUSH1 0x01 1A79 60 PUSH1 0xe0 1A7B 1B SHL 1A7C 63 PUSH4 0x15f24053 1A81 02 MUL 1A82 81 DUP2 1A83 52 MSTORE 1A84 60 PUSH1 0x04 1A86 81 DUP2 1A87 01 ADD 1A88 87 DUP8 1A89 90 SWAP1 1A8A 52 MSTORE 1A8B 60 PUSH1 0x24 1A8D 81 DUP2 1A8E 01 ADD 1A8F 86 DUP7 1A90 90 SWAP1 1A91 52 MSTORE 1A92 60 PUSH1 0x44 1A94 81 DUP2 1A95 01 ADD 1A96 85 DUP6 1A97 90 SWAP1 1A98 52 MSTORE 1A99 90 SWAP1 1A9A 51 MLOAD 1A9B 95 SWAP6 1A9C 96 SWAP7 1A9D 50 POP 1A9E 93 SWAP4 1A9F 94 SWAP5 1AA0 92 SWAP3 1AA1 93 SWAP4 1AA2 91 SWAP2 1AA3 92 SWAP3 1AA4 60 PUSH1 0x00 1AA6 92 SWAP3 1AA7 60 PUSH1 0x01 1AA9 60 PUSH1 0x01 1AAB 60 PUSH1 0xa0 1AAD 1B SHL 1AAE 03 SUB 1AAF 90 SWAP1 1AB0 92 SWAP3 1AB1 16 AND 1AB2 91 SWAP2 1AB3 63 PUSH4 0x15f24053 1AB8 91 SWAP2 1AB9 60 PUSH1 0x64 1ABB 80 DUP1 1ABC 83 DUP4 1ABD 01 ADD 1ABE 92 SWAP3 1ABF 60 PUSH1 0x20 1AC1 92 SWAP3 1AC2 91 SWAP2 1AC3 90 SWAP1 1AC4 82 DUP3 1AC5 90 SWAP1 1AC6 03 SUB 1AC7 01 ADD 1AC8 81 DUP2 1AC9 86 DUP7 1ACA 80 DUP1 1ACB 3B EXTCODESIZE 1ACC 15 ISZERO 1ACD 80 DUP1 1ACE 15 ISZERO 1ACF 61 PUSH2 0x1ad7 1AD2 57 *JUMPI // Stack delta = +12 // Outputs[18] // { // @1A83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x15f24053 * (0x01 << 0xe0) // @1A8A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] // @1A91 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = storage[0x06] // @1A98 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = storage[0x0a] // @1A9C stack[-2] = stack[-1] // @1A9F stack[-1] = storage[0x06] // @1AA1 stack[0] = storage[0x0a] // @1AA3 stack[1] = storage[0x09] // @1AA6 stack[2] = 0x00 // @1AB2 stack[3] = storage[0x01] & (0x01 << 0xa0) - 0x01 // @1AB8 stack[4] = 0x15f24053 // @1ABE stack[5] = memory[0x40:0x60] + 0x64 // @1AC1 stack[6] = 0x20 // @1AC2 stack[7] = memory[0x40:0x60] // @1AC7 stack[8] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @1AC8 stack[9] = memory[0x40:0x60] // @1AC9 stack[10] = storage[0x01] & (0x01 << 0xa0) - 0x01 // @1ACC stack[11] = !address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x1ad7, if !!address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length label_1AD3: // Incoming jump from 0x1AD2, if not !!address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1AD6 memory[0x00:0x00] } 1AD3 60 PUSH1 0x00 1AD5 80 DUP1 1AD6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AD6 revert(memory[0x00:0x00]); } // Block terminates label_1AD7: // Incoming jump from 0x1AD2, if !!address(storage[0x01] & (0x01 << 0xa0) - 0x01).code.length // Inputs[8] // { // @1AD9 msg.gas // @1ADA stack[-4] // @1ADA memory[stack[-3]:stack[-3] + stack[-4]] // @1ADA stack[-2] // @1ADA stack[-6] // @1ADA address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1ADA stack[-3] // @1ADA stack[-5] // } 1AD7 5B JUMPDEST 1AD8 50 POP 1AD9 5A GAS 1ADA FA STATICCALL 1ADB 15 ISZERO 1ADC 80 DUP1 1ADD 15 ISZERO 1ADE 61 PUSH2 0x1aeb 1AE1 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1ADA memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1ADB stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1aeb, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1AE2: // Incoming jump from 0x1AE1, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1AE2 returndata.length // @1AE6 returndata[0x00:0x00 + returndata.length] // @1AE7 returndata.length // @1AEA memory[0x00:0x00 + returndata.length] // } 1AE2 3D RETURNDATASIZE 1AE3 60 PUSH1 0x00 1AE5 80 DUP1 1AE6 3E RETURNDATACOPY 1AE7 3D RETURNDATASIZE 1AE8 60 PUSH1 0x00 1AEA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AE6 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1AEA revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1AEB: // Incoming jump from 0x1AE1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1AF2 memory[0x40:0x60] // @1AF3 returndata.length // } 1AEB 5B JUMPDEST 1AEC 50 POP 1AED 50 POP 1AEE 50 POP 1AEF 50 POP 1AF0 60 PUSH1 0x40 1AF2 51 MLOAD 1AF3 3D RETURNDATASIZE 1AF4 60 PUSH1 0x20 1AF6 81 DUP2 1AF7 10 LT 1AF8 15 ISZERO 1AF9 61 PUSH2 0x1b01 1AFC 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1AF2 stack[-4] = memory[0x40:0x60] // @1AF3 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1b01, if !(returndata.length < 0x20) label_1AFD: // Incoming jump from 0x1AFC, if not !(returndata.length < 0x20) // Inputs[1] { @1B00 memory[0x00:0x00] } 1AFD 60 PUSH1 0x00 1AFF 80 DUP1 1B00 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B00 revert(memory[0x00:0x00]); } // Block terminates label_1B01: // Incoming jump from 0x1AFC, if !(returndata.length < 0x20) // Inputs[3] // { // @1B03 stack[-2] // @1B03 memory[stack[-2]:stack[-2] + 0x20] // @1B04 stack[-3] // } 1B01 5B JUMPDEST 1B02 50 POP 1B03 51 MLOAD 1B04 90 SWAP1 1B05 50 POP 1B06 65 PUSH6 0x048c27395000 1B0D 81 DUP2 1B0E 11 GT 1B0F 15 ISZERO 1B10 61 PUSH2 0x1b4c 1B13 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1B04 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1b4c, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x048c27395000) label_1B14: // Incoming jump from 0x1B13, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x048c27395000) // Inputs[3] // { // @1B17 memory[0x40:0x60] // @1B42 memory[0x40:0x60] // @1B4B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1B14 60 PUSH1 0x40 1B16 80 DUP1 1B17 51 MLOAD 1B18 60 PUSH1 0x01 1B1A 60 PUSH1 0xe5 1B1C 1B SHL 1B1D 62 PUSH3 0x461bcd 1B21 02 MUL 1B22 81 DUP2 1B23 52 MSTORE 1B24 60 PUSH1 0x20 1B26 60 PUSH1 0x04 1B28 82 DUP3 1B29 01 ADD 1B2A 52 MSTORE 1B2B 60 PUSH1 0x03 1B2D 60 PUSH1 0x24 1B2F 82 DUP3 1B30 01 ADD 1B31 52 MSTORE 1B32 60 PUSH1 0x01 1B34 60 PUSH1 0xec 1B36 1B SHL 1B37 62 PUSH3 0x045363 1B3B 02 MUL 1B3C 60 PUSH1 0x44 1B3E 82 DUP3 1B3F 01 ADD 1B40 52 MSTORE 1B41 90 SWAP1 1B42 51 MLOAD 1B43 90 SWAP1 1B44 81 DUP2 1B45 90 SWAP1 1B46 03 SUB 1B47 60 PUSH1 0x64 1B49 01 ADD 1B4A 90 SWAP1 1B4B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B23 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1B2A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B31 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1B40 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x045363 * (0x01 << 0xec) // @1B4B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1B4C: // Incoming jump from 0x1B13, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x048c27395000) // Inputs[2] // { // @1B53 stack[-7] // @1B54 stack[-6] // } 1B4C 5B JUMPDEST 1B4D 60 PUSH1 0x00 1B4F 80 DUP1 1B50 61 PUSH2 0x1b59 1B53 89 DUP10 1B54 89 DUP10 1B55 61 PUSH2 0x33c0 1B58 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1B4D stack[0] = 0x00 // @1B4F stack[1] = 0x00 // @1B50 stack[2] = 0x1b59 // @1B53 stack[3] = stack[-7] // @1B54 stack[4] = stack[-6] // } // Block ends with call to 0x33c0, returns to 0x1B59 label_1B59: // Incoming return from call to 0x33C0 at 0x1B58 // Inputs[4] // { // @1B5A stack[-2] // @1B5A stack[-1] // @1B5B stack[-4] // @1B5D stack[-3] // } 1B59 5B JUMPDEST 1B5A 90 SWAP1 1B5B 92 SWAP3 1B5C 50 POP 1B5D 90 SWAP1 1B5E 50 POP 1B5F 60 PUSH1 0x00 1B61 82 DUP3 1B62 60 PUSH1 0x03 1B64 81 DUP2 1B65 11 GT 1B66 15 ISZERO 1B67 61 PUSH2 0x1b6c 1B6A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1B5B stack[-4] = stack[-2] // @1B5D stack[-3] = stack[-1] // @1B5F stack[-2] = 0x00 // @1B61 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1b6c, if !(stack[-2] > 0x03) label_1B6B: // Incoming jump from 0x1B6A, if not !(stack[-2] > 0x03) 1B6B FE *ASSERT // Stack delta = +0 // Outputs[1] { @1B6B assert(); } // Block terminates label_1B6C: // Incoming jump from 0x1B6A, if !(stack[-2] > 0x03) // Inputs[2] // { // @1B6D stack[-2] // @1B6D stack[-1] // } 1B6C 5B JUMPDEST 1B6D 14 EQ 1B6E 61 PUSH2 0x1baa 1B71 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1baa, if stack[-1] == stack[-2] label_1B72: // Incoming jump from 0x1B71, if not stack[-1] == stack[-2] // Inputs[3] // { // @1B75 memory[0x40:0x60] // @1BA0 memory[0x40:0x60] // @1BA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1B72 60 PUSH1 0x40 1B74 80 DUP1 1B75 51 MLOAD 1B76 60 PUSH1 0x01 1B78 60 PUSH1 0xe5 1B7A 1B SHL 1B7B 62 PUSH3 0x461bcd 1B7F 02 MUL 1B80 81 DUP2 1B81 52 MSTORE 1B82 60 PUSH1 0x20 1B84 60 PUSH1 0x04 1B86 82 DUP3 1B87 01 ADD 1B88 52 MSTORE 1B89 60 PUSH1 0x03 1B8B 60 PUSH1 0x24 1B8D 82 DUP3 1B8E 01 ADD 1B8F 52 MSTORE 1B90 60 PUSH1 0x01 1B92 60 PUSH1 0xe8 1B94 1B SHL 1B95 62 PUSH3 0x453631 1B99 02 MUL 1B9A 60 PUSH1 0x44 1B9C 82 DUP3 1B9D 01 ADD 1B9E 52 MSTORE 1B9F 90 SWAP1 1BA0 51 MLOAD 1BA1 90 SWAP1 1BA2 81 DUP2 1BA3 90 SWAP1 1BA4 03 SUB 1BA5 60 PUSH1 0x64 1BA7 01 ADD 1BA8 90 SWAP1 1BA9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B81 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1B88 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1B8F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1B9E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453631 * (0x01 << 0xe8) // @1BA9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1BAA: // Incoming jump from 0x1B71, if stack[-1] == stack[-2] 1BAA 5B JUMPDEST 1BAB 61 PUSH2 0x1bb2 1BAE 61 PUSH2 0x5357 1BB1 56 *JUMP // Stack delta = +1 // Outputs[1] { @1BAB stack[0] = 0x1bb2 } // Block ends with call to 0x5357, returns to 0x1BB2 label_1BB2: // Incoming return from call to 0x5357 at 0x1BB1 // Inputs[3] // { // @1BBE memory[0x40:0x60] // @1BC7 stack[-4] // @1BCB stack[-2] // } 1BB2 5B JUMPDEST 1BB3 60 PUSH1 0x00 1BB5 80 DUP1 1BB6 60 PUSH1 0x00 1BB8 80 DUP1 1BB9 61 PUSH2 0x1bd0 1BBC 60 PUSH1 0x40 1BBE 51 MLOAD 1BBF 80 DUP1 1BC0 60 PUSH1 0x20 1BC2 01 ADD 1BC3 60 PUSH1 0x40 1BC5 52 MSTORE 1BC6 80 DUP1 1BC7 8A DUP11 1BC8 81 DUP2 1BC9 52 MSTORE 1BCA 50 POP 1BCB 87 DUP8 1BCC 61 PUSH2 0x33e3 1BCF 56 *JUMP // Stack delta = +7 // Outputs[9] // { // @1BB3 stack[0] = 0x00 // @1BB5 stack[1] = 0x00 // @1BB6 stack[2] = 0x00 // @1BB8 stack[3] = 0x00 // @1BB9 stack[4] = 0x1bd0 // @1BBE stack[5] = memory[0x40:0x60] // @1BC5 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1BC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @1BCB stack[6] = stack[-2] // } // Block ends with call to 0x33e3, returns to 0x1BD0 label_1BD0: // Incoming return from call to 0x33E3 at 0x1BCF // Inputs[4] // { // @1BD1 stack[-1] // @1BD1 stack[-2] // @1BD2 stack[-9] // @1BD4 stack[-7] // } 1BD0 5B JUMPDEST 1BD1 90 SWAP1 1BD2 97 SWAP8 1BD3 50 POP 1BD4 94 SWAP5 1BD5 50 POP 1BD6 60 PUSH1 0x00 1BD8 87 DUP8 1BD9 60 PUSH1 0x03 1BDB 81 DUP2 1BDC 11 GT 1BDD 15 ISZERO 1BDE 61 PUSH2 0x1be3 1BE1 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1BD2 stack[-9] = stack[-2] // @1BD4 stack[-7] = stack[-1] // @1BD6 stack[-2] = 0x00 // @1BD8 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1be3, if !(stack[-2] > 0x03) label_1BE2: // Incoming jump from 0x1BE1, if not !(stack[-2] > 0x03) 1BE2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1BE2 assert(); } // Block terminates label_1BE3: // Incoming jump from 0x1BE1, if !(stack[-2] > 0x03) // Inputs[2] // { // @1BE4 stack[-2] // @1BE4 stack[-1] // } 1BE3 5B JUMPDEST 1BE4 14 EQ 1BE5 61 PUSH2 0x1c21 1BE8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1c21, if stack[-1] == stack[-2] label_1BE9: // Incoming jump from 0x1BE8, if not stack[-1] == stack[-2] // Inputs[3] // { // @1BEC memory[0x40:0x60] // @1C17 memory[0x40:0x60] // @1C20 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1BE9 60 PUSH1 0x40 1BEB 80 DUP1 1BEC 51 MLOAD 1BED 60 PUSH1 0x01 1BEF 60 PUSH1 0xe5 1BF1 1B SHL 1BF2 62 PUSH3 0x461bcd 1BF6 02 MUL 1BF7 81 DUP2 1BF8 52 MSTORE 1BF9 60 PUSH1 0x20 1BFB 60 PUSH1 0x04 1BFD 82 DUP3 1BFE 01 ADD 1BFF 52 MSTORE 1C00 60 PUSH1 0x03 1C02 60 PUSH1 0x24 1C04 82 DUP3 1C05 01 ADD 1C06 52 MSTORE 1C07 60 PUSH1 0x01 1C09 60 PUSH1 0xe9 1C0B 1B SHL 1C0C 62 PUSH3 0x229b19 1C10 02 MUL 1C11 60 PUSH1 0x44 1C13 82 DUP3 1C14 01 ADD 1C15 52 MSTORE 1C16 90 SWAP1 1C17 51 MLOAD 1C18 90 SWAP1 1C19 81 DUP2 1C1A 90 SWAP1 1C1B 03 SUB 1C1C 60 PUSH1 0x64 1C1E 01 ADD 1C1F 90 SWAP1 1C20 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1BF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1BFF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1C06 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1C15 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229b19 * (0x01 << 0xe9) // @1C20 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1C21: // Incoming jump from 0x1BE8, if stack[-1] == stack[-2] // Inputs[2] // { // @1C25 stack[-5] // @1C26 stack[-11] // } 1C21 5B JUMPDEST 1C22 61 PUSH2 0x1c2b 1C25 85 DUP6 1C26 8C DUP13 1C27 61 PUSH2 0x3057 1C2A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C22 stack[0] = 0x1c2b // @1C25 stack[1] = stack[-5] // @1C26 stack[2] = stack[-11] // } // Block ends with call to 0x3057, returns to 0x1C2B label_1C2B: // Incoming return from call to 0x3057 at 0x1C2A // Inputs[4] // { // @1C2C stack[-2] // @1C2C stack[-1] // @1C2D stack[-9] // @1C2F stack[-6] // } 1C2B 5B JUMPDEST 1C2C 90 SWAP1 1C2D 97 SWAP8 1C2E 50 POP 1C2F 93 SWAP4 1C30 50 POP 1C31 60 PUSH1 0x00 1C33 87 DUP8 1C34 60 PUSH1 0x03 1C36 81 DUP2 1C37 11 GT 1C38 15 ISZERO 1C39 61 PUSH2 0x1c3e 1C3C 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1C2D stack[-9] = stack[-2] // @1C2F stack[-6] = stack[-1] // @1C31 stack[-2] = 0x00 // @1C33 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1c3e, if !(stack[-2] > 0x03) label_1C3D: // Incoming jump from 0x1C3C, if not !(stack[-2] > 0x03) 1C3D FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C3D assert(); } // Block terminates label_1C3E: // Incoming jump from 0x1C3C, if !(stack[-2] > 0x03) // Inputs[2] // { // @1C3F stack[-1] // @1C3F stack[-2] // } 1C3E 5B JUMPDEST 1C3F 14 EQ 1C40 61 PUSH2 0x1c7c 1C43 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1c7c, if stack[-1] == stack[-2] label_1C44: // Incoming jump from 0x1C43, if not stack[-1] == stack[-2] // Inputs[3] // { // @1C47 memory[0x40:0x60] // @1C72 memory[0x40:0x60] // @1C7B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1C44 60 PUSH1 0x40 1C46 80 DUP1 1C47 51 MLOAD 1C48 60 PUSH1 0x01 1C4A 60 PUSH1 0xe5 1C4C 1B SHL 1C4D 62 PUSH3 0x461bcd 1C51 02 MUL 1C52 81 DUP2 1C53 52 MSTORE 1C54 60 PUSH1 0x20 1C56 60 PUSH1 0x04 1C58 82 DUP3 1C59 01 ADD 1C5A 52 MSTORE 1C5B 60 PUSH1 0x03 1C5D 60 PUSH1 0x24 1C5F 82 DUP3 1C60 01 ADD 1C61 52 MSTORE 1C62 60 PUSH1 0x01 1C64 60 PUSH1 0xe8 1C66 1B SHL 1C67 62 PUSH3 0x453633 1C6B 02 MUL 1C6C 60 PUSH1 0x44 1C6E 82 DUP3 1C6F 01 ADD 1C70 52 MSTORE 1C71 90 SWAP1 1C72 51 MLOAD 1C73 90 SWAP1 1C74 81 DUP2 1C75 90 SWAP1 1C76 03 SUB 1C77 60 PUSH1 0x64 1C79 01 ADD 1C7A 90 SWAP1 1C7B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1C53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1C5A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1C61 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1C70 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453633 * (0x01 << 0xe8) // @1C7B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1C7C: // Incoming jump from 0x1C43, if stack[-1] == stack[-2] // Inputs[2] // { // @1C80 stack[-4] // @1C81 stack[-11] // } 1C7C 5B JUMPDEST 1C7D 61 PUSH2 0x1c86 1C80 84 DUP5 1C81 8C DUP13 1C82 61 PUSH2 0x2586 1C85 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C7D stack[0] = 0x1c86 // @1C80 stack[1] = stack[-4] // @1C81 stack[2] = stack[-11] // } // Block ends with call to 0x2586, returns to 0x1C86 label_1C86: // Incoming return from call to 0x2586 at 0x1C85 // Inputs[4] // { // @1C87 stack[-1] // @1C87 stack[-2] // @1C88 stack[-9] // @1C8A stack[-5] // } 1C86 5B JUMPDEST 1C87 90 SWAP1 1C88 97 SWAP8 1C89 50 POP 1C8A 92 SWAP3 1C8B 50 POP 1C8C 60 PUSH1 0x00 1C8E 87 DUP8 1C8F 60 PUSH1 0x03 1C91 81 DUP2 1C92 11 GT 1C93 15 ISZERO 1C94 61 PUSH2 0x1c99 1C97 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1C88 stack[-9] = stack[-2] // @1C8A stack[-5] = stack[-1] // @1C8C stack[-2] = 0x00 // @1C8E stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1c99, if !(stack[-2] > 0x03) label_1C98: // Incoming jump from 0x1C97, if not !(stack[-2] > 0x03) 1C98 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1C98 assert(); } // Block terminates label_1C99: // Incoming jump from 0x1C97, if !(stack[-2] > 0x03) // Inputs[2] // { // @1C9A stack[-2] // @1C9A stack[-1] // } 1C99 5B JUMPDEST 1C9A 14 EQ 1C9B 61 PUSH2 0x1cd7 1C9E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1cd7, if stack[-1] == stack[-2] label_1C9F: // Incoming jump from 0x1C9E, if not stack[-1] == stack[-2] // Inputs[3] // { // @1CA2 memory[0x40:0x60] // @1CCD memory[0x40:0x60] // @1CD6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1C9F 60 PUSH1 0x40 1CA1 80 DUP1 1CA2 51 MLOAD 1CA3 60 PUSH1 0x01 1CA5 60 PUSH1 0xe5 1CA7 1B SHL 1CA8 62 PUSH3 0x461bcd 1CAC 02 MUL 1CAD 81 DUP2 1CAE 52 MSTORE 1CAF 60 PUSH1 0x20 1CB1 60 PUSH1 0x04 1CB3 82 DUP3 1CB4 01 ADD 1CB5 52 MSTORE 1CB6 60 PUSH1 0x03 1CB8 60 PUSH1 0x24 1CBA 82 DUP3 1CBB 01 ADD 1CBC 52 MSTORE 1CBD 60 PUSH1 0x01 1CBF 60 PUSH1 0xea 1CC1 1B SHL 1CC2 62 PUSH3 0x114d8d 1CC6 02 MUL 1CC7 60 PUSH1 0x44 1CC9 82 DUP3 1CCA 01 ADD 1CCB 52 MSTORE 1CCC 90 SWAP1 1CCD 51 MLOAD 1CCE 90 SWAP1 1CCF 81 DUP2 1CD0 90 SWAP1 1CD1 03 SUB 1CD2 60 PUSH1 0x64 1CD4 01 ADD 1CD5 90 SWAP1 1CD6 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1CAE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1CB5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1CBC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1CCB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x114d8d * (0x01 << 0xea) // @1CD6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1CD7: // Incoming jump from 0x1C9E, if stack[-1] == stack[-2] // Inputs[4] // { // @1CDD memory[0x40:0x60] // @1CE8 storage[0x0b] // @1CEC stack[-4] // @1CED stack[-10] // } 1CD7 5B JUMPDEST 1CD8 61 PUSH2 0x1cf2 1CDB 60 PUSH1 0x40 1CDD 51 MLOAD 1CDE 80 DUP1 1CDF 60 PUSH1 0x20 1CE1 01 ADD 1CE2 60 PUSH1 0x40 1CE4 52 MSTORE 1CE5 80 DUP1 1CE6 60 PUSH1 0x0b 1CE8 54 SLOAD 1CE9 81 DUP2 1CEA 52 MSTORE 1CEB 50 POP 1CEC 85 DUP6 1CED 8C DUP13 1CEE 61 PUSH2 0x344b 1CF1 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1CD8 stack[0] = 0x1cf2 // @1CDD stack[1] = memory[0x40:0x60] // @1CE4 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1CEA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x0b] // @1CEC stack[2] = stack[-4] // @1CED stack[3] = stack[-10] // } // Block ends with call to 0x344b, returns to 0x1CF2 label_1CF2: // Incoming return from call to 0x344B at 0x1CF1 // Inputs[4] // { // @1CF3 stack[-1] // @1CF3 stack[-2] // @1CF4 stack[-9] // @1CF6 stack[-4] // } 1CF2 5B JUMPDEST 1CF3 90 SWAP1 1CF4 97 SWAP8 1CF5 50 POP 1CF6 91 SWAP2 1CF7 50 POP 1CF8 60 PUSH1 0x00 1CFA 87 DUP8 1CFB 60 PUSH1 0x03 1CFD 81 DUP2 1CFE 11 GT 1CFF 15 ISZERO 1D00 61 PUSH2 0x1d05 1D03 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1CF4 stack[-9] = stack[-2] // @1CF6 stack[-4] = stack[-1] // @1CF8 stack[-2] = 0x00 // @1CFA stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1d05, if !(stack[-2] > 0x03) label_1D04: // Incoming jump from 0x1D03, if not !(stack[-2] > 0x03) 1D04 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1D04 assert(); } // Block terminates label_1D05: // Incoming jump from 0x1D03, if !(stack[-2] > 0x03) // Inputs[2] // { // @1D06 stack[-1] // @1D06 stack[-2] // } 1D05 5B JUMPDEST 1D06 14 EQ 1D07 61 PUSH2 0x1d43 1D0A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1d43, if stack[-1] == stack[-2] label_1D0B: // Incoming jump from 0x1D0A, if not stack[-1] == stack[-2] // Inputs[3] // { // @1D0E memory[0x40:0x60] // @1D39 memory[0x40:0x60] // @1D42 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1D0B 60 PUSH1 0x40 1D0D 80 DUP1 1D0E 51 MLOAD 1D0F 60 PUSH1 0x01 1D11 60 PUSH1 0xe5 1D13 1B SHL 1D14 62 PUSH3 0x461bcd 1D18 02 MUL 1D19 81 DUP2 1D1A 52 MSTORE 1D1B 60 PUSH1 0x20 1D1D 60 PUSH1 0x04 1D1F 82 DUP3 1D20 01 ADD 1D21 52 MSTORE 1D22 60 PUSH1 0x03 1D24 60 PUSH1 0x24 1D26 82 DUP3 1D27 01 ADD 1D28 52 MSTORE 1D29 60 PUSH1 0x01 1D2B 60 PUSH1 0xe8 1D2D 1B SHL 1D2E 62 PUSH3 0x453635 1D32 02 MUL 1D33 60 PUSH1 0x44 1D35 82 DUP3 1D36 01 ADD 1D37 52 MSTORE 1D38 90 SWAP1 1D39 51 MLOAD 1D3A 90 SWAP1 1D3B 81 DUP2 1D3C 90 SWAP1 1D3D 03 SUB 1D3E 60 PUSH1 0x64 1D40 01 ADD 1D41 90 SWAP1 1D42 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1D1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1D21 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D28 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1D37 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453635 * (0x01 << 0xe8) // @1D42 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1D43: // Incoming jump from 0x1D0A, if stack[-1] == stack[-2] // Inputs[2] // { // @1D47 stack[-5] // @1D48 stack[-9] // } 1D43 5B JUMPDEST 1D44 61 PUSH2 0x1d4e 1D47 85 DUP6 1D48 8A DUP11 1D49 8B DUP12 1D4A 61 PUSH2 0x344b 1D4D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D44 stack[0] = 0x1d4e // @1D47 stack[1] = stack[-5] // @1D48 stack[2] = stack[-9] // @1D49 stack[3] = stack[-9] // } // Block ends with call to 0x344b, returns to 0x1D4E label_1D4E: // Incoming return from call to 0x344B at 0x1D4D // Inputs[4] // { // @1D4F stack[-2] // @1D4F stack[-1] // @1D50 stack[-9] // @1D52 stack[-3] // } 1D4E 5B JUMPDEST 1D4F 90 SWAP1 1D50 97 SWAP8 1D51 50 POP 1D52 90 SWAP1 1D53 50 POP 1D54 60 PUSH1 0x00 1D56 87 DUP8 1D57 60 PUSH1 0x03 1D59 81 DUP2 1D5A 11 GT 1D5B 15 ISZERO 1D5C 61 PUSH2 0x1d61 1D5F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1D50 stack[-9] = stack[-2] // @1D52 stack[-3] = stack[-1] // @1D54 stack[-2] = 0x00 // @1D56 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x1d61, if !(stack[-2] > 0x03) label_1D60: // Incoming jump from 0x1D5F, if not !(stack[-2] > 0x03) 1D60 FE *ASSERT // Stack delta = +0 // Outputs[1] { @1D60 assert(); } // Block terminates label_1D61: // Incoming jump from 0x1D5F, if !(stack[-2] > 0x03) // Inputs[2] // { // @1D62 stack[-2] // @1D62 stack[-1] // } 1D61 5B JUMPDEST 1D62 14 EQ 1D63 61 PUSH2 0x1d9f 1D66 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1d9f, if stack[-1] == stack[-2] label_1D67: // Incoming jump from 0x1D66, if not stack[-1] == stack[-2] // Inputs[3] // { // @1D6A memory[0x40:0x60] // @1D95 memory[0x40:0x60] // @1D9E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1D67 60 PUSH1 0x40 1D69 80 DUP1 1D6A 51 MLOAD 1D6B 60 PUSH1 0x01 1D6D 60 PUSH1 0xe5 1D6F 1B SHL 1D70 62 PUSH3 0x461bcd 1D74 02 MUL 1D75 81 DUP2 1D76 52 MSTORE 1D77 60 PUSH1 0x20 1D79 60 PUSH1 0x04 1D7B 82 DUP3 1D7C 01 ADD 1D7D 52 MSTORE 1D7E 60 PUSH1 0x03 1D80 60 PUSH1 0x24 1D82 82 DUP3 1D83 01 ADD 1D84 52 MSTORE 1D85 60 PUSH1 0x01 1D87 60 PUSH1 0xe9 1D89 1B SHL 1D8A 62 PUSH3 0x229b1b 1D8E 02 MUL 1D8F 60 PUSH1 0x44 1D91 82 DUP3 1D92 01 ADD 1D93 52 MSTORE 1D94 90 SWAP1 1D95 51 MLOAD 1D96 90 SWAP1 1D97 81 DUP2 1D98 90 SWAP1 1D99 03 SUB 1D9A 60 PUSH1 0x64 1D9C 01 ADD 1D9D 90 SWAP1 1D9E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1D76 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1D7D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1D84 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1D93 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229b1b * (0x01 << 0xe9) // @1D9E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1D9F: // Incoming jump from 0x1D66, if stack[-1] == stack[-2] // Inputs[7] // { // @1DA2 stack[-14] // @1DA3 stack[-1] // @1DA9 stack[-2] // @1DAE stack[-3] // @1DB5 stack[-7] // @1DBB stack[-16] // @1DBC stack[-15] // } 1D9F 5B JUMPDEST 1DA0 60 PUSH1 0x08 1DA2 9D SWAP14 1DA3 90 SWAP1 1DA4 9D SWAP14 1DA5 55 SSTORE 1DA6 60 PUSH1 0x09 1DA8 9C SWAP13 1DA9 90 SWAP1 1DAA 9C SWAP13 1DAB 55 SSTORE 1DAC 60 PUSH1 0x06 1DAE 55 SSTORE 1DAF 50 POP 1DB0 50 POP 1DB1 50 POP 1DB2 60 PUSH1 0x0a 1DB4 97 SWAP8 1DB5 90 SWAP1 1DB6 97 SWAP8 1DB7 55 SSTORE 1DB8 50 POP 1DB9 60 PUSH1 0x00 1DBB 97 SWAP8 1DBC 96 SWAP7 1DBD 50 POP 1DBE 50 POP 1DBF 50 POP 1DC0 50 POP 1DC1 50 POP 1DC2 50 POP 1DC3 50 POP 1DC4 56 *JUMP // Stack delta = -15 // Outputs[5] // { // @1DA5 storage[0x08] = stack[-14] // @1DAB storage[0x09] = stack[-1] // @1DAE storage[0x06] = stack[-3] // @1DB7 storage[0x0a] = stack[-2] // @1DBB stack[-16] = 0x00 // } // Block ends with unconditional jump to stack[-16] label_1DC5: // Incoming jump from 0x0737 // Inputs[1] { @1DC9 storage[0x00] } 1DC5 5B JUMPDEST 1DC6 60 PUSH1 0x00 1DC8 80 DUP1 1DC9 54 SLOAD 1DCA 62 PUSH3 0x010000 1DCE 90 SWAP1 1DCF 04 DIV 1DD0 60 PUSH1 0xff 1DD2 16 AND 1DD3 61 PUSH2 0x1e0f 1DD6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DC6 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e0f, if 0xff & storage[0x00] / 0x010000 label_1DD7: // Incoming jump from 0x1DD6, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @1DDA memory[0x40:0x60] // @1E05 memory[0x40:0x60] // @1E0E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1DD7 60 PUSH1 0x40 1DD9 80 DUP1 1DDA 51 MLOAD 1DDB 60 PUSH1 0x01 1DDD 60 PUSH1 0xe5 1DDF 1B SHL 1DE0 62 PUSH3 0x461bcd 1DE4 02 MUL 1DE5 81 DUP2 1DE6 52 MSTORE 1DE7 60 PUSH1 0x20 1DE9 60 PUSH1 0x04 1DEB 82 DUP3 1DEC 01 ADD 1DED 52 MSTORE 1DEE 60 PUSH1 0x03 1DF0 60 PUSH1 0x24 1DF2 82 DUP3 1DF3 01 ADD 1DF4 52 MSTORE 1DF5 60 PUSH1 0x01 1DF7 60 PUSH1 0xe8 1DF9 1B SHL 1DFA 62 PUSH3 0x453637 1DFE 02 MUL 1DFF 60 PUSH1 0x44 1E01 82 DUP3 1E02 01 ADD 1E03 52 MSTORE 1E04 90 SWAP1 1E05 51 MLOAD 1E06 90 SWAP1 1E07 81 DUP2 1E08 90 SWAP1 1E09 03 SUB 1E0A 60 PUSH1 0x64 1E0C 01 ADD 1E0D 90 SWAP1 1E0E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1DE6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1DED memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1DF4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1E03 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @1E0E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1E0F: // Incoming jump from 0x1DD6, if 0xff & storage[0x00] / 0x010000 // Inputs[5] // { // @1E13 storage[0x00] // @1E1F msg.sender // @1E20 msg.sender // @1E21 stack[-3] // @1E22 stack[-2] // } 1E0F 5B JUMPDEST 1E10 60 PUSH1 0x00 1E12 80 DUP1 1E13 54 SLOAD 1E14 62 PUSH3 0xff0000 1E18 19 NOT 1E19 16 AND 1E1A 81 DUP2 1E1B 55 SSTORE 1E1C 61 PUSH2 0x1e27 1E1F 33 CALLER 1E20 33 CALLER 1E21 86 DUP7 1E22 86 DUP7 1E23 61 PUSH2 0x25ac 1E26 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1E10 stack[0] = 0x00 // @1E1B storage[0x00] = ~0xff0000 & storage[0x00] // @1E1C stack[1] = 0x1e27 // @1E1F stack[2] = msg.sender // @1E20 stack[3] = msg.sender // @1E21 stack[4] = stack[-3] // @1E22 stack[5] = stack[-2] // } // Block ends with call to 0x25ac, returns to 0x1E27 label_1E27: // Incoming return from call to 0x25AC at 0x1E26 // Incoming return from call to 0x25AC at 0x1E26 // Inputs[6] // { // @1E28 stack[-1] // @1E28 stack[-2] // @1E29 stack[-3] // @1E2E storage[0x00] // @1E3C stack[-6] // @1E3D stack[-5] // } 1E27 5B JUMPDEST 1E28 14 EQ 1E29 90 SWAP1 1E2A 50 POP 1E2B 60 PUSH1 0x00 1E2D 80 DUP1 1E2E 54 SLOAD 1E2F 62 PUSH3 0xff0000 1E33 19 NOT 1E34 16 AND 1E35 62 PUSH3 0x010000 1E39 17 OR 1E3A 90 SWAP1 1E3B 55 SSTORE 1E3C 92 SWAP3 1E3D 91 SWAP2 1E3E 50 POP 1E3F 50 POP 1E40 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1E3B storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @1E3C stack[-6] = stack[-1] == stack[-2] // } // Block ends with unconditional jump to stack[-6] label_1E41: // Incoming call from 0x074C, returns to 0x0374 // Inputs[2] // { // @1E44 storage[0x09] // @1E45 stack[-1] // } 1E41 5B JUMPDEST 1E42 60 PUSH1 0x09 1E44 54 SLOAD 1E45 81 DUP2 1E46 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E44 stack[0] = storage[0x09] } // Block ends with unconditional jump to stack[-1] label_1E47: // Incoming jump from 0x077A // Inputs[3] // { // @1E4D stack[-2] // @1E4E msg.value // @1E4F stack[-1] // } 1E47 5B JUMPDEST 1E48 60 PUSH1 0x00 1E4A 61 PUSH2 0x1e54 1E4D 83 DUP4 1E4E 34 CALLVALUE 1E4F 84 DUP5 1E50 61 PUSH2 0x34a7 1E53 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1E48 stack[0] = 0x00 // @1E4A stack[1] = 0x1e54 // @1E4D stack[2] = stack[-2] // @1E4E stack[3] = msg.value // @1E4F stack[4] = stack[-1] // } // Block ends with call to 0x34a7, returns to 0x1E54 label_1E54: // Incoming return from call to 0x34A7 at 0x1E53 // Inputs[3] // { // @1E56 stack[-3] // @1E56 stack[-2] // @1E5E memory[0x40:0x60] // } 1E54 5B JUMPDEST 1E55 50 POP 1E56 90 SWAP1 1E57 50 POP 1E58 61 PUSH2 0x1e7f 1E5B 81 DUP2 1E5C 60 PUSH1 0x40 1E5E 51 MLOAD 1E5F 80 DUP1 1E60 60 PUSH1 0x40 1E62 01 ADD 1E63 60 PUSH1 0x40 1E65 52 MSTORE 1E66 80 DUP1 1E67 60 PUSH1 0x03 1E69 81 DUP2 1E6A 52 MSTORE 1E6B 60 PUSH1 0x20 1E6D 01 ADD 1E6E 60 PUSH1 0x01 1E70 60 PUSH1 0xe9 1E72 1B SHL 1E73 62 PUSH3 0x229b9b 1E77 02 MUL 1E78 81 DUP2 1E79 52 MSTORE 1E7A 50 POP 1E7B 61 PUSH2 0x361a 1E7E 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @1E56 stack[-3] = stack[-2] // @1E58 stack[-2] = 0x1e7f // @1E5B stack[-1] = stack[-2] // @1E5E stack[0] = memory[0x40:0x60] // @1E65 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1E6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03 // @1E79 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x229b9b * (0x01 << 0xe9) // } // Block ends with call to 0x361a, returns to 0x1E7F label_1E7F: // Incoming return from call to 0x361A at 0x1E7E // Inputs[1] { @1E83 stack[-4] } 1E7F 5B JUMPDEST 1E80 50 POP 1E81 50 POP 1E82 50 POP 1E83 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1E84: // Incoming call from 0x078F, returns to 0x0374 // Inputs[1] { @1E87 storage[0x01] } 1E84 5B JUMPDEST 1E85 60 PUSH1 0x01 1E87 54 SLOAD 1E88 60 PUSH1 0x00 1E8A 90 SWAP1 1E8B 60 PUSH1 0x01 1E8D 60 PUSH1 0x01 1E8F 60 PUSH1 0xa0 1E91 1B SHL 1E92 03 SUB 1E93 16 AND 1E94 63 PUSH4 0xb8168816 1E99 61 PUSH2 0x1ea0 1E9C 61 PUSH2 0x306e 1E9F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E8A stack[0] = 0x00 // @1E93 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x01] // @1E94 stack[2] = 0xb8168816 // @1E99 stack[3] = 0x1ea0 // } // Block ends with call to 0x306e, returns to 0x1EA0 label_1EA0: // Incoming return from call to 0x306E at 0x1E9F // Inputs[9] // { // @1EA3 storage[0x06] // @1EA6 storage[0x0a] // @1EA9 storage[0x0b] // @1EAC memory[0x40:0x60] // @1EAD stack[-2] // @1EBD stack[-1] // @1EDF memory[0x40:0x60] // @1EE4 stack[-3] // @1EE6 address(stack[-3]).code.length // } 1EA0 5B JUMPDEST 1EA1 60 PUSH1 0x06 1EA3 54 SLOAD 1EA4 60 PUSH1 0x0a 1EA6 54 SLOAD 1EA7 60 PUSH1 0x0b 1EA9 54 SLOAD 1EAA 60 PUSH1 0x40 1EAC 51 MLOAD 1EAD 85 DUP6 1EAE 63 PUSH4 0xffffffff 1EB3 16 AND 1EB4 60 PUSH1 0xe0 1EB6 1B SHL 1EB7 81 DUP2 1EB8 52 MSTORE 1EB9 60 PUSH1 0x04 1EBB 01 ADD 1EBC 80 DUP1 1EBD 85 DUP6 1EBE 81 DUP2 1EBF 52 MSTORE 1EC0 60 PUSH1 0x20 1EC2 01 ADD 1EC3 84 DUP5 1EC4 81 DUP2 1EC5 52 MSTORE 1EC6 60 PUSH1 0x20 1EC8 01 ADD 1EC9 83 DUP4 1ECA 81 DUP2 1ECB 52 MSTORE 1ECC 60 PUSH1 0x20 1ECE 01 ADD 1ECF 82 DUP3 1ED0 81 DUP2 1ED1 52 MSTORE 1ED2 60 PUSH1 0x20 1ED4 01 ADD 1ED5 94 SWAP5 1ED6 50 POP 1ED7 50 POP 1ED8 50 POP 1ED9 50 POP 1EDA 50 POP 1EDB 60 PUSH1 0x20 1EDD 60 PUSH1 0x40 1EDF 51 MLOAD 1EE0 80 DUP1 1EE1 83 DUP4 1EE2 03 SUB 1EE3 81 DUP2 1EE4 86 DUP7 1EE5 80 DUP1 1EE6 3B EXTCODESIZE 1EE7 15 ISZERO 1EE8 80 DUP1 1EE9 15 ISZERO 1EEA 61 PUSH2 0x1ef2 1EED 57 *JUMPI // Stack delta = +6 // Outputs[12] // { // @1EB8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @1EBF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @1EC5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = storage[0x06] // @1ECB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = storage[0x0a] // @1ED1 memory[0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = storage[0x0b] // @1ED5 stack[-1] = 0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @1EDB stack[0] = 0x20 // @1EDF stack[1] = memory[0x40:0x60] // @1EE2 stack[2] = (0x20 + 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1EE3 stack[3] = memory[0x40:0x60] // @1EE4 stack[4] = stack[-3] // @1EE7 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1ef2, if !!address(stack[-3]).code.length label_1EEE: // Incoming jump from 0x1EED, if not !!address(stack[-3]).code.length // Inputs[1] { @1EF1 memory[0x00:0x00] } 1EEE 60 PUSH1 0x00 1EF0 80 DUP1 1EF1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EF1 revert(memory[0x00:0x00]); } // Block terminates label_1EF2: // Incoming jump from 0x1EED, if !!address(stack[-3]).code.length // Incoming jump from 0x2322, if !!address(stack[-3]).code.length // Inputs[8] // { // @1EF4 msg.gas // @1EF5 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1EF5 memory[stack[-3]:stack[-3] + stack[-4]] // @1EF5 stack[-4] // @1EF5 stack[-5] // @1EF5 stack[-6] // @1EF5 stack[-2] // @1EF5 stack[-3] // } 1EF2 5B JUMPDEST 1EF3 50 POP 1EF4 5A GAS 1EF5 FA STATICCALL 1EF6 15 ISZERO 1EF7 80 DUP1 1EF8 15 ISZERO 1EF9 61 PUSH2 0x1f06 1EFC 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1EF5 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1EF6 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1f06, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1EFD: // Incoming jump from 0x1EFC, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1EFD returndata.length // @1F01 returndata[0x00:0x00 + returndata.length] // @1F02 returndata.length // @1F05 memory[0x00:0x00 + returndata.length] // } 1EFD 3D RETURNDATASIZE 1EFE 60 PUSH1 0x00 1F00 80 DUP1 1F01 3E RETURNDATACOPY 1F02 3D RETURNDATASIZE 1F03 60 PUSH1 0x00 1F05 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1F01 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1F05 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1F06: // Incoming jump from 0x1EFC, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1F0D memory[0x40:0x60] // @1F0E returndata.length // } 1F06 5B JUMPDEST 1F07 50 POP 1F08 50 POP 1F09 50 POP 1F0A 50 POP 1F0B 60 PUSH1 0x40 1F0D 51 MLOAD 1F0E 3D RETURNDATASIZE 1F0F 60 PUSH1 0x20 1F11 81 DUP2 1F12 10 LT 1F13 15 ISZERO 1F14 61 PUSH2 0x1f1c 1F17 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1F0D stack[-4] = memory[0x40:0x60] // @1F0E stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1f1c, if !(returndata.length < 0x20) label_1F18: // Incoming jump from 0x1F17, if not !(returndata.length < 0x20) // Inputs[1] { @1F1B memory[0x00:0x00] } 1F18 60 PUSH1 0x00 1F1A 80 DUP1 1F1B FD *REVERT // Stack delta = +0 // Outputs[1] { @1F1B revert(memory[0x00:0x00]); } // Block terminates label_1F1C: // Incoming jump from 0x1F17, if !(returndata.length < 0x20) // Inputs[4] // { // @1F1E memory[stack[-2]:stack[-2] + 0x20] // @1F1E stack[-2] // @1F1F stack[-3] // @1F21 stack[-4] // } 1F1C 5B JUMPDEST 1F1D 50 POP 1F1E 51 MLOAD 1F1F 90 SWAP1 1F20 50 POP 1F21 90 SWAP1 1F22 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F21 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1F23: // Incoming jump from 0x07D2 // Inputs[1] { @1F27 storage[0x00] } 1F23 5B JUMPDEST 1F24 60 PUSH1 0x00 1F26 80 DUP1 1F27 54 SLOAD 1F28 62 PUSH3 0x010000 1F2C 90 SWAP1 1F2D 04 DIV 1F2E 60 PUSH1 0xff 1F30 16 AND 1F31 61 PUSH2 0x1f6d 1F34 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F24 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f6d, if 0xff & storage[0x00] / 0x010000 label_1F35: // Incoming jump from 0x1F34, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @1F38 memory[0x40:0x60] // @1F63 memory[0x40:0x60] // @1F6C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1F35 60 PUSH1 0x40 1F37 80 DUP1 1F38 51 MLOAD 1F39 60 PUSH1 0x01 1F3B 60 PUSH1 0xe5 1F3D 1B SHL 1F3E 62 PUSH3 0x461bcd 1F42 02 MUL 1F43 81 DUP2 1F44 52 MSTORE 1F45 60 PUSH1 0x20 1F47 60 PUSH1 0x04 1F49 82 DUP3 1F4A 01 ADD 1F4B 52 MSTORE 1F4C 60 PUSH1 0x03 1F4E 60 PUSH1 0x24 1F50 82 DUP3 1F51 01 ADD 1F52 52 MSTORE 1F53 60 PUSH1 0x01 1F55 60 PUSH1 0xe8 1F57 1B SHL 1F58 62 PUSH3 0x453637 1F5C 02 MUL 1F5D 60 PUSH1 0x44 1F5F 82 DUP3 1F60 01 ADD 1F61 52 MSTORE 1F62 90 SWAP1 1F63 51 MLOAD 1F64 90 SWAP1 1F65 81 DUP2 1F66 90 SWAP1 1F67 03 SUB 1F68 60 PUSH1 0x64 1F6A 01 ADD 1F6B 90 SWAP1 1F6C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1F44 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1F4B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1F52 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1F61 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @1F6C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1F6D: // Incoming jump from 0x1F34, if 0xff & storage[0x00] / 0x010000 // Inputs[5] // { // @1F71 storage[0x00] // @1F7D msg.sender // @1F7E stack[-4] // @1F7F stack[-3] // @1F80 stack[-2] // } 1F6D 5B JUMPDEST 1F6E 60 PUSH1 0x00 1F70 80 DUP1 1F71 54 SLOAD 1F72 62 PUSH3 0xff0000 1F76 19 NOT 1F77 16 AND 1F78 90 SWAP1 1F79 55 SSTORE 1F7A 61 PUSH2 0x1f85 1F7D 33 CALLER 1F7E 85 DUP6 1F7F 85 DUP6 1F80 85 DUP6 1F81 61 PUSH2 0x381c 1F84 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1F79 storage[0x00] = ~0xff0000 & storage[0x00] // @1F7A stack[0] = 0x1f85 // @1F7D stack[1] = msg.sender // @1F7E stack[2] = stack[-4] // @1F7F stack[3] = stack[-3] // @1F80 stack[4] = stack[-2] // } // Block ends with call to 0x381c, returns to 0x1F85 label_1F85: // Incoming return from call to 0x381C at 0x1F84 // Inputs[5] // { // @1F86 stack[-1] // @1F86 stack[-2] // @1F8B storage[0x00] // @1F99 stack[-6] // @1F9A stack[-5] // } 1F85 5B JUMPDEST 1F86 90 SWAP1 1F87 50 POP 1F88 60 PUSH1 0x00 1F8A 80 DUP1 1F8B 54 SLOAD 1F8C 62 PUSH3 0xff0000 1F90 19 NOT 1F91 16 AND 1F92 62 PUSH3 0x010000 1F96 17 OR 1F97 90 SWAP1 1F98 55 SSTORE 1F99 93 SWAP4 1F9A 92 SWAP3 1F9B 50 POP 1F9C 50 POP 1F9D 50 POP 1F9E 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1F98 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @1F99 stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_1F9F: // Incoming call from 0x14E2, returns to 0x14E3 // Incoming call from 0x07E7, returns to 0x0374 // Inputs[1] { @1FA3 storage[0x00] } 1F9F 5B JUMPDEST 1FA0 60 PUSH1 0x00 1FA2 80 DUP1 1FA3 54 SLOAD 1FA4 62 PUSH3 0x010000 1FA8 90 SWAP1 1FA9 04 DIV 1FAA 60 PUSH1 0xff 1FAC 16 AND 1FAD 61 PUSH2 0x1fe9 1FB0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FA0 stack[0] = 0x00 } // Block ends with conditional jump to 0x1fe9, if 0xff & storage[0x00] / 0x010000 label_1FB1: // Incoming jump from 0x1FB0, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @1FB4 memory[0x40:0x60] // @1FDF memory[0x40:0x60] // @1FE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1FB1 60 PUSH1 0x40 1FB3 80 DUP1 1FB4 51 MLOAD 1FB5 60 PUSH1 0x01 1FB7 60 PUSH1 0xe5 1FB9 1B SHL 1FBA 62 PUSH3 0x461bcd 1FBE 02 MUL 1FBF 81 DUP2 1FC0 52 MSTORE 1FC1 60 PUSH1 0x20 1FC3 60 PUSH1 0x04 1FC5 82 DUP3 1FC6 01 ADD 1FC7 52 MSTORE 1FC8 60 PUSH1 0x03 1FCA 60 PUSH1 0x24 1FCC 82 DUP3 1FCD 01 ADD 1FCE 52 MSTORE 1FCF 60 PUSH1 0x01 1FD1 60 PUSH1 0xe8 1FD3 1B SHL 1FD4 62 PUSH3 0x453637 1FD8 02 MUL 1FD9 60 PUSH1 0x44 1FDB 82 DUP3 1FDC 01 ADD 1FDD 52 MSTORE 1FDE 90 SWAP1 1FDF 51 MLOAD 1FE0 90 SWAP1 1FE1 81 DUP2 1FE2 90 SWAP1 1FE3 03 SUB 1FE4 60 PUSH1 0x64 1FE6 01 ADD 1FE7 90 SWAP1 1FE8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1FC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @1FC7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1FCE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @1FDD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @1FE8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1FE9: // Incoming jump from 0x1FB0, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @1FED storage[0x00] } 1FE9 5B JUMPDEST 1FEA 60 PUSH1 0x00 1FEC 80 DUP1 1FED 54 SLOAD 1FEE 62 PUSH3 0xff0000 1FF2 19 NOT 1FF3 16 AND 1FF4 81 DUP2 1FF5 55 SSTORE 1FF6 61 PUSH2 0x1ffd 1FF9 61 PUSH2 0x1a38 1FFC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1FEA stack[0] = 0x00 // @1FF5 storage[0x00] = ~0xff0000 & storage[0x00] // @1FF6 stack[1] = 0x1ffd // } // Block ends with call to 0x1a38, returns to 0x1FFD label_1FFD: // Incoming return from call to 0x1A38 at 0x1FFC // Incoming return from call to 0x1A38 at 0x1FFC // Inputs[2] // { // @1FFE stack[-2] // @1FFE stack[-1] // } 1FFD 5B JUMPDEST 1FFE 14 EQ 1FFF 61 PUSH2 0x203a 2002 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x203a, if stack[-1] == stack[-2] label_2003: // Incoming jump from 0x2002, if not stack[-1] == stack[-2] // Inputs[3] // { // @2006 memory[0x40:0x60] // @2030 memory[0x40:0x60] // @2039 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2003 60 PUSH1 0x40 2005 80 DUP1 2006 51 MLOAD 2007 60 PUSH1 0x01 2009 60 PUSH1 0xe5 200B 1B SHL 200C 62 PUSH3 0x461bcd 2010 02 MUL 2011 81 DUP2 2012 52 MSTORE 2013 60 PUSH1 0x20 2015 60 PUSH1 0x04 2017 82 DUP3 2018 01 ADD 2019 52 MSTORE 201A 60 PUSH1 0x02 201C 60 PUSH1 0x24 201E 82 DUP3 201F 01 ADD 2020 52 MSTORE 2021 60 PUSH1 0x01 2023 60 PUSH1 0xf0 2025 1B SHL 2026 61 PUSH2 0x4535 2029 02 MUL 202A 60 PUSH1 0x44 202C 82 DUP3 202D 01 ADD 202E 52 MSTORE 202F 90 SWAP1 2030 51 MLOAD 2031 90 SWAP1 2032 81 DUP2 2033 90 SWAP1 2034 03 SUB 2035 60 PUSH1 0x64 2037 01 ADD 2038 90 SWAP1 2039 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2012 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2019 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2020 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @202E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @2039 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_203A: // Incoming jump from 0x2002, if stack[-1] == stack[-2] 203A 5B JUMPDEST 203B 61 PUSH2 0x2042 203E 61 PUSH2 0x1271 2041 56 *JUMP // Stack delta = +1 // Outputs[1] { @203B stack[0] = 0x2042 } // Block ends with call to 0x1271, returns to 0x2042 label_2042: // Incoming return from call to 0x1271 at 0x2041 // Inputs[4] // { // @2043 stack[-1] // @2043 stack[-2] // @2048 storage[0x00] // @2056 stack[-3] // } 2042 5B JUMPDEST 2043 90 SWAP1 2044 50 POP 2045 60 PUSH1 0x00 2047 80 DUP1 2048 54 SLOAD 2049 62 PUSH3 0xff0000 204D 19 NOT 204E 16 AND 204F 62 PUSH3 0x010000 2053 17 OR 2054 90 SWAP1 2055 55 SSTORE 2056 90 SWAP1 2057 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2055 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @2056 stack[-3] = stack[-1] // } // Block ends with unconditional jump to stack[-3] label_2058: // Incoming jump from 0x081A // Inputs[3] // { // @2061 stack[-1] // @2070 memory[0x00:0x40] // @2071 storage[keccak256(memory[0x00:0x40])] // } 2058 5B JUMPDEST 2059 60 PUSH1 0x01 205B 60 PUSH1 0x01 205D 60 PUSH1 0xa0 205F 1B SHL 2060 03 SUB 2061 81 DUP2 2062 16 AND 2063 60 PUSH1 0x00 2065 90 SWAP1 2066 81 DUP2 2067 52 MSTORE 2068 60 PUSH1 0x0d 206A 60 PUSH1 0x20 206C 52 MSTORE 206D 60 PUSH1 0x40 206F 81 DUP2 2070 20 SHA3 2071 54 SLOAD 2072 81 DUP2 2073 90 SWAP1 2074 81 DUP2 2075 90 SWAP1 2076 81 DUP2 2077 90 SWAP1 2078 81 DUP2 2079 80 DUP1 207A 80 DUP1 207B 61 PUSH2 0x2083 207E 89 DUP10 207F 61 PUSH2 0x330c 2082 56 *JUMP // Stack delta = +10 // Outputs[12] // { // @2065 stack[0] = 0x00 // @2067 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @206C memory[0x20:0x40] = 0x0d // @2073 stack[1] = 0x00 // @2075 stack[2] = 0x00 // @2077 stack[4] = storage[keccak256(memory[0x00:0x40])] // @2077 stack[3] = 0x00 // @2078 stack[5] = 0x00 // @2079 stack[6] = 0x00 // @207A stack[7] = 0x00 // @207B stack[8] = 0x2083 // @207E stack[9] = stack[-1] // } // Block ends with call to 0x330c, returns to 0x2083 label_2083: // Incoming return from call to 0x330C at 0x2082 // Inputs[4] // { // @2084 stack[-5] // @2084 stack[-1] // @2086 stack[-2] // @2086 stack[-3] // } 2083 5B JUMPDEST 2084 93 SWAP4 2085 50 POP 2086 90 SWAP1 2087 50 POP 2088 60 PUSH1 0x00 208A 81 DUP2 208B 60 PUSH1 0x03 208D 81 DUP2 208E 11 GT 208F 15 ISZERO 2090 61 PUSH2 0x2095 2093 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2084 stack[-5] = stack[-1] // @2086 stack[-3] = stack[-2] // @2088 stack[-2] = 0x00 // @208A stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x2095, if !(stack[-2] > 0x03) label_2094: // Incoming jump from 0x2093, if not !(stack[-2] > 0x03) 2094 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2094 assert(); } // Block terminates label_2095: // Incoming jump from 0x2093, if !(stack[-2] > 0x03) // Inputs[2] // { // @2096 stack[-2] // @2096 stack[-1] // } 2095 5B JUMPDEST 2096 14 EQ 2097 61 PUSH2 0x20b3 209A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x20b3, if stack[-1] == stack[-2] label_209B: // Incoming jump from 0x209A, if not stack[-1] == stack[-2] // Inputs[5] // { // @209E stack[-8] // @20A2 stack[-7] // @20A5 stack[-6] // @20A8 stack[-5] // @20AD stack[-4] // } 209B 60 PUSH1 0x09 209D 5B JUMPDEST 209E 97 SWAP8 209F 50 POP 20A0 60 PUSH1 0x00 20A2 96 SWAP7 20A3 50 POP 20A4 86 DUP7 20A5 95 SWAP6 20A6 50 POP 20A7 85 DUP6 20A8 94 SWAP5 20A9 50 POP 20AA 61 PUSH2 0x20e6 20AD 93 SWAP4 20AE 50 POP 20AF 50 POP 20B0 50 POP 20B1 50 POP 20B2 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @209E stack[-8] = 0x09 // @20A2 stack[-7] = 0x00 // @20A5 stack[-6] = 0x00 // @20A8 stack[-5] = 0x00 // } // Block ends with unconditional jump to 0x20e6 label_20B3: // Incoming jump from 0x209A, if stack[-1] == stack[-2] 20B3 5B JUMPDEST 20B4 61 PUSH2 0x20bb 20B7 61 PUSH2 0x23f6 20BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @20B4 stack[0] = 0x20bb } // Block ends with call to 0x23f6, returns to 0x20BB label_20BB: // Incoming return from call to 0x23F6 at 0x20BA // Inputs[4] // { // @20BC stack[-1] // @20BC stack[-4] // @20BE stack[-3] // @20BE stack[-2] // } 20BB 5B JUMPDEST 20BC 92 SWAP3 20BD 50 POP 20BE 90 SWAP1 20BF 50 POP 20C0 60 PUSH1 0x00 20C2 81 DUP2 20C3 60 PUSH1 0x03 20C5 81 DUP2 20C6 11 GT 20C7 15 ISZERO 20C8 61 PUSH2 0x20cd 20CB 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @20BC stack[-4] = stack[-1] // @20BE stack[-3] = stack[-2] // @20C0 stack[-2] = 0x00 // @20C2 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x20cd, if !(stack[-2] > 0x03) label_20CC: // Incoming jump from 0x20CB, if not !(stack[-2] > 0x03) 20CC FE *ASSERT // Stack delta = +0 // Outputs[1] { @20CC assert(); } // Block terminates label_20CD: // Incoming jump from 0x20CB, if !(stack[-2] > 0x03) // Inputs[2] // { // @20CE stack[-1] // @20CE stack[-2] // } 20CD 5B JUMPDEST 20CE 14 EQ 20CF 61 PUSH2 0x20d9 20D2 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x20d9, if stack[-1] == stack[-2] label_20D3: // Incoming jump from 0x20D2, if not stack[-1] == stack[-2] 20D3 60 PUSH1 0x09 20D5 61 PUSH2 0x209d 20D8 56 *JUMP // Stack delta = +1 // Outputs[1] { @20D3 stack[0] = 0x09 } // Block ends with unconditional jump to 0x209d label_20D9: // Incoming jump from 0x20D2, if stack[-1] == stack[-2] // Inputs[7] // { // @20DD stack[-8] // @20DF stack[-4] // @20DF stack[-2] // @20E0 stack[-7] // @20E2 stack[-3] // @20E2 stack[-6] // @20E4 stack[-5] // } 20D9 5B JUMPDEST 20DA 50 POP 20DB 60 PUSH1 0x00 20DD 96 SWAP7 20DE 50 POP 20DF 91 SWAP2 20E0 94 SWAP5 20E1 50 POP 20E2 92 SWAP3 20E3 50 POP 20E4 90 SWAP1 20E5 50 POP // Stack delta = -4 // Outputs[4] // { // @20DD stack[-8] = 0x00 // @20E0 stack[-7] = stack[-4] // @20E2 stack[-6] = stack[-3] // @20E4 stack[-5] = stack[-2] // } // Block continues label_20E6: // Incoming jump from 0x20B2 // Incoming jump from 0x20E5 // Incoming jump from 0x20B2 // Inputs[6] // { // @20E7 stack[-3] // @20E7 stack[-1] // @20E8 stack[-5] // @20EA stack[-4] // @20EA stack[-2] // @20EB stack[-6] // } 20E6 5B JUMPDEST 20E7 91 SWAP2 20E8 93 SWAP4 20E9 50 POP 20EA 91 SWAP2 20EB 93 SWAP4 20EC 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @20E7 stack[-3] = stack[-1] // @20E8 stack[-5] = stack[-3] // @20EA stack[-4] = stack[-2] // @20EB stack[-6] = stack[-4] // } // Block ends with unconditional jump to stack[-6] label_20ED: // Incoming jump from 0x086A // Inputs[1] { @20F3 stack[-1] } 20ED 5B JUMPDEST 20EE 60 PUSH1 0x00 20F0 61 PUSH2 0x18aa 20F3 82 DUP3 20F4 61 PUSH2 0x3a96 20F7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20EE stack[0] = 0x00 // @20F0 stack[1] = 0x18aa // @20F3 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x3a96 label_20F8: // Incoming jump from 0x09CC // Inputs[1] { @20FB storage[0x00] } 20F8 5B JUMPDEST 20F9 60 PUSH1 0x00 20FB 54 SLOAD 20FC 61 PUSH2 0x0100 20FF 90 SWAP1 2100 04 DIV 2101 60 PUSH1 0xff 2103 16 AND 2104 80 DUP1 2105 61 PUSH2 0x2111 2108 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2103 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x2111, if 0xff & storage[0x00] / 0x0100 label_2109: // Incoming jump from 0x2108, if not 0xff & storage[0x00] / 0x0100 2109 50 POP 210A 61 PUSH2 0x2111 210D 61 PUSH2 0x3b3b 2110 56 *JUMP // Stack delta = +0 // Outputs[1] { @210A stack[-1] = 0x2111 } // Block ends with call to 0x3b3b, returns to 0x2111 label_2111: // Incoming return from call to 0x3B3B at 0x2110 // Incoming jump from 0x2108, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @2112 stack[-1] } 2111 5B JUMPDEST 2112 80 DUP1 2113 61 PUSH2 0x211f 2116 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x211f, if stack[-1] label_2117: // Incoming jump from 0x2116, if not stack[-1] // Inputs[1] { @211A storage[0x00] } 2117 50 POP 2118 60 PUSH1 0x00 211A 54 SLOAD 211B 60 PUSH1 0xff 211D 16 AND 211E 15 ISZERO 211F 5B JUMPDEST 2120 61 PUSH2 0x215d 2123 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x215d, if !(0xff & storage[0x00]) label_2124: // Incoming jump from 0x2123, if not stack[-1] // Incoming jump from 0x2123, if not !(0xff & storage[0x00]) // Inputs[3] // { // @2126 memory[0x40:0x60] // @2157 memory[0x40:0x60] // @215C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2124 60 PUSH1 0x40 2126 51 MLOAD 2127 60 PUSH1 0x01 2129 60 PUSH1 0xe5 212B 1B SHL 212C 62 PUSH3 0x461bcd 2130 02 MUL 2131 81 DUP2 2132 52 MSTORE 2133 60 PUSH1 0x04 2135 01 ADD 2136 80 DUP1 2137 80 DUP1 2138 60 PUSH1 0x20 213A 01 ADD 213B 82 DUP3 213C 81 DUP2 213D 03 SUB 213E 82 DUP3 213F 52 MSTORE 2140 60 PUSH1 0x2e 2142 81 DUP2 2143 52 MSTORE 2144 60 PUSH1 0x20 2146 01 ADD 2147 80 DUP1 2148 61 PUSH2 0x54a3 214B 60 PUSH1 0x2e 214D 91 SWAP2 214E 39 CODECOPY 214F 60 PUSH1 0x40 2151 01 ADD 2152 91 SWAP2 2153 50 POP 2154 50 POP 2155 60 PUSH1 0x40 2157 51 MLOAD 2158 80 DUP1 2159 91 SWAP2 215A 03 SUB 215B 90 SWAP1 215C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2132 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @213F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2143 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @214E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x54a3:0x54d1] // @215C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_215D: // Incoming jump from 0x2123, if stack[-1] // Incoming jump from 0x2123, if !(0xff & storage[0x00]) // Inputs[1] { @2160 storage[0x00] } 215D 5B JUMPDEST 215E 60 PUSH1 0x00 2160 54 SLOAD 2161 61 PUSH2 0x0100 2164 90 SWAP1 2165 04 DIV 2166 60 PUSH1 0xff 2168 16 AND 2169 15 ISZERO 216A 80 DUP1 216B 15 ISZERO 216C 61 PUSH2 0x2188 216F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2169 stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x2188, if !!(0xff & storage[0x00] / 0x0100) label_2170: // Incoming jump from 0x216F, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[10] // { // @2173 storage[0x00] // @218C storage[0x05] // @2198 msg.sender // @21A3 stack[-8] // @21A4 stack[-7] // @21A5 stack[-6] // @21A6 stack[-5] // @21A7 stack[-4] // @21A8 stack[-3] // @21A9 stack[-2] // } 2170 60 PUSH1 0x00 2172 80 DUP1 2173 54 SLOAD 2174 60 PUSH1 0xff 2176 19 NOT 2177 61 PUSH2 0xff00 217A 19 NOT 217B 90 SWAP1 217C 91 SWAP2 217D 16 AND 217E 61 PUSH2 0x0100 2181 17 OR 2182 16 AND 2183 60 PUSH1 0x01 2185 17 OR 2186 90 SWAP1 2187 55 SSTORE 2188 5B JUMPDEST 2189 60 PUSH1 0x05 218B 80 DUP1 218C 54 SLOAD 218D 61 PUSH2 0x0100 2190 60 PUSH1 0x01 2192 60 PUSH1 0xa8 2194 1B SHL 2195 03 SUB 2196 19 NOT 2197 16 AND 2198 33 CALLER 2199 61 PUSH2 0x0100 219C 02 MUL 219D 17 OR 219E 90 SWAP1 219F 55 SSTORE 21A0 61 PUSH2 0x21ae 21A3 88 DUP9 21A4 88 DUP9 21A5 88 DUP9 21A6 88 DUP9 21A7 88 DUP9 21A8 88 DUP9 21A9 88 DUP9 21AA 61 PUSH2 0x3b4c 21AD 56 *JUMP // Stack delta = +8 // Outputs[10] // { // @2187 storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) // @219F storage[0x05] = 0x0100 * msg.sender | (~((0x01 << 0xa8) - 0x0100) & storage[0x05]) // @21A0 stack[0] = 0x21ae // @21A3 stack[1] = stack[-8] // @21A4 stack[2] = stack[-7] // @21A5 stack[3] = stack[-6] // @21A6 stack[4] = stack[-5] // @21A7 stack[5] = stack[-4] // @21A8 stack[6] = stack[-3] // @21A9 stack[7] = stack[-2] // } // Block ends with unconditional jump to 0x3b4c 21AE 5B JUMPDEST 21AF 80 DUP1 21B0 15 ISZERO 21B1 61 PUSH2 0x21c0 21B4 57 *JUMPI 21B5 60 PUSH1 0x00 21B7 80 DUP1 21B8 54 SLOAD 21B9 61 PUSH2 0xff00 21BC 19 NOT 21BD 16 AND 21BE 90 SWAP1 21BF 55 SSTORE 21C0 5B JUMPDEST 21C1 50 POP 21C2 50 POP 21C3 50 POP 21C4 50 POP 21C5 50 POP 21C6 50 POP 21C7 50 POP 21C8 50 POP 21C9 56 *JUMP label_21CA: // Incoming call from 0x09E1, returns to 0x0374 // Inputs[2] // { // @21CD storage[0x02] // @21CE stack[-1] // } 21CA 5B JUMPDEST 21CB 60 PUSH1 0x02 21CD 54 SLOAD 21CE 81 DUP2 21CF 56 *JUMP // Stack delta = +1 // Outputs[1] { @21CD stack[0] = storage[0x02] } // Block ends with unconditional jump to stack[-1] label_21D0: // Incoming jump from 0x0A1C // Inputs[6] // { // @21D9 stack[-2] // @21EC memory[0x00:0x40] // @21ED stack[-1] // @21F7 memory[0x00:0x40] // @21F8 storage[keccak256(memory[0x00:0x40])] // @21F9 stack[-3] // } 21D0 5B JUMPDEST 21D1 60 PUSH1 0x01 21D3 60 PUSH1 0x01 21D5 60 PUSH1 0xa0 21D7 1B SHL 21D8 03 SUB 21D9 91 SWAP2 21DA 82 DUP3 21DB 16 AND 21DC 60 PUSH1 0x00 21DE 90 SWAP1 21DF 81 DUP2 21E0 52 MSTORE 21E1 60 PUSH1 0x0e 21E3 60 PUSH1 0x20 21E5 90 SWAP1 21E6 81 DUP2 21E7 52 MSTORE 21E8 60 PUSH1 0x40 21EA 80 DUP1 21EB 83 DUP4 21EC 20 SHA3 21ED 93 SWAP4 21EE 90 SWAP1 21EF 94 SWAP5 21F0 16 AND 21F1 82 DUP3 21F2 52 MSTORE 21F3 91 SWAP2 21F4 90 SWAP1 21F5 91 SWAP2 21F6 52 MSTORE 21F7 20 SHA3 21F8 54 SLOAD 21F9 90 SWAP1 21FA 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @21E0 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @21E7 memory[0x20:0x40] = 0x0e // @21F2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @21F6 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @21F9 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_21FB: // Incoming jump from 0x0A42 // Inputs[2] // { // @2201 stack[-1] // @2202 msg.value // } 21FB 5B JUMPDEST 21FC 60 PUSH1 0x00 21FE 61 PUSH2 0x2207 2201 82 DUP3 2202 34 CALLVALUE 2203 61 PUSH2 0x3daa 2206 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @21FC stack[0] = 0x00 // @21FE stack[1] = 0x2207 // @2201 stack[2] = stack[-1] // @2202 stack[3] = msg.value // } // Block ends with call to 0x3daa, returns to 0x2207 label_2207: // Incoming return from call to 0x3DAA at 0x2206 // Inputs[3] // { // @2209 stack[-3] // @2209 stack[-2] // @2211 memory[0x40:0x60] // } 2207 5B JUMPDEST 2208 50 POP 2209 90 SWAP1 220A 50 POP 220B 61 PUSH2 0x2232 220E 81 DUP2 220F 60 PUSH1 0x40 2211 51 MLOAD 2212 80 DUP1 2213 60 PUSH1 0x40 2215 01 ADD 2216 60 PUSH1 0x40 2218 52 MSTORE 2219 80 DUP1 221A 60 PUSH1 0x03 221C 81 DUP2 221D 52 MSTORE 221E 60 PUSH1 0x20 2220 01 ADD 2221 60 PUSH1 0x01 2223 60 PUSH1 0xe8 2225 1B SHL 2226 62 PUSH3 0x453735 222A 02 MUL 222B 81 DUP2 222C 52 MSTORE 222D 50 POP 222E 61 PUSH2 0x361a 2231 56 *JUMP // Stack delta = +1 // Outputs[7] // { // @2209 stack[-3] = stack[-2] // @220B stack[-2] = 0x2232 // @220E stack[-1] = stack[-2] // @2211 stack[0] = memory[0x40:0x60] // @2218 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @221D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03 // @222C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x453735 * (0x01 << 0xe8) // } // Block ends with call to 0x361a, returns to 0x2232 label_2232: // Incoming return from call to 0x361A at 0x2231 // Incoming jump from 0x3623 // Inputs[1] { @2235 stack[-3] } 2232 5B JUMPDEST 2233 50 POP 2234 50 POP 2235 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_2236: // Incoming jump from 0x0A75 2236 5B JUMPDEST 2237 60 PUSH1 0x00 2239 80 DUP1 223A 61 PUSH2 0x2241 223D 61 PUSH2 0x1a38 2240 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2237 stack[0] = 0x00 // @2239 stack[1] = 0x00 // @223A stack[2] = 0x2241 // } // Block ends with call to 0x1a38, returns to 0x2241 label_2241: // Incoming return from call to 0x1A38 at 0x2240 // Incoming return from call to 0x1A38 at 0x2240 // Inputs[2] // { // @2242 stack[-2] // @2242 stack[-1] // } 2241 5B JUMPDEST 2242 90 SWAP1 2243 50 POP 2244 80 DUP1 2245 15 ISZERO 2246 61 PUSH2 0x2281 2249 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2242 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2281, if !stack[-1] label_224A: // Incoming jump from 0x2249, if not !stack[-1] // Inputs[3] // { // @224D memory[0x40:0x60] // @2277 memory[0x40:0x60] // @2280 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 224A 60 PUSH1 0x40 224C 80 DUP1 224D 51 MLOAD 224E 60 PUSH1 0x01 2250 60 PUSH1 0xe5 2252 1B SHL 2253 62 PUSH3 0x461bcd 2257 02 MUL 2258 81 DUP2 2259 52 MSTORE 225A 60 PUSH1 0x20 225C 60 PUSH1 0x04 225E 82 DUP3 225F 01 ADD 2260 52 MSTORE 2261 60 PUSH1 0x02 2263 60 PUSH1 0x24 2265 82 DUP3 2266 01 ADD 2267 52 MSTORE 2268 60 PUSH1 0x01 226A 60 PUSH1 0xf0 226C 1B SHL 226D 61 PUSH2 0x4535 2270 02 MUL 2271 60 PUSH1 0x44 2273 82 DUP3 2274 01 ADD 2275 52 MSTORE 2276 90 SWAP1 2277 51 MLOAD 2278 90 SWAP1 2279 81 DUP2 227A 90 SWAP1 227B 03 SUB 227C 60 PUSH1 0x64 227E 01 ADD 227F 90 SWAP1 2280 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2259 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2260 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2267 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @2275 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @2280 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2281: // Incoming jump from 0x2249, if !stack[-1] // Inputs[1] { @2285 stack[-3] } 2281 5B JUMPDEST 2282 61 PUSH2 0x1681 2285 83 DUP4 2286 61 PUSH2 0x3e60 2289 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2282 stack[0] = 0x1681 // @2285 stack[1] = stack[-3] // } // Block ends with call to 0x3e60, returns to 0x1681 label_228A: // Incoming call from 0x0A8A, returns to 0x0A8B // Inputs[2] // { // @228D storage[0x01] // @2297 stack[-1] // } 228A 5B JUMPDEST 228B 60 PUSH1 0x01 228D 54 SLOAD 228E 60 PUSH1 0x01 2290 60 PUSH1 0x01 2292 60 PUSH1 0xa0 2294 1B SHL 2295 03 SUB 2296 16 AND 2297 81 DUP2 2298 56 *JUMP // Stack delta = +1 // Outputs[1] { @2296 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x01] } // Block ends with unconditional jump to stack[-1] label_2299: // Incoming call from 0x0ABB, returns to 0x0A8B // Inputs[2] // { // @229C storage[0x00] // @22AD stack[-1] // } 2299 5B JUMPDEST 229A 60 PUSH1 0x00 229C 54 SLOAD 229D 63 PUSH4 0x01000000 22A2 90 SWAP1 22A3 04 DIV 22A4 60 PUSH1 0x01 22A6 60 PUSH1 0x01 22A8 60 PUSH1 0xa0 22AA 1B SHL 22AB 03 SUB 22AC 16 AND 22AD 81 DUP2 22AE 56 *JUMP // Stack delta = +1 // Outputs[1] { @22AC stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 } // Block ends with unconditional jump to stack[-1] label_22AF: // Incoming call from 0x0AD0, returns to 0x0A8B // Inputs[2] // { // @22B2 storage[0x05] // @22C1 stack[-1] // } 22AF 5B JUMPDEST 22B0 60 PUSH1 0x05 22B2 54 SLOAD 22B3 61 PUSH2 0x0100 22B6 90 SWAP1 22B7 04 DIV 22B8 60 PUSH1 0x01 22BA 60 PUSH1 0x01 22BC 60 PUSH1 0xa0 22BE 1B SHL 22BF 03 SUB 22C0 16 AND 22C1 81 DUP2 22C2 56 *JUMP // Stack delta = +1 // Outputs[1] { @22C0 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 } // Block ends with unconditional jump to stack[-1] label_22C3: // Incoming call from 0x0AE5, returns to 0x0374 // Inputs[1] { @22C6 storage[0x01] } 22C3 5B JUMPDEST 22C4 60 PUSH1 0x01 22C6 54 SLOAD 22C7 60 PUSH1 0x00 22C9 90 SWAP1 22CA 60 PUSH1 0x01 22CC 60 PUSH1 0x01 22CE 60 PUSH1 0xa0 22D0 1B SHL 22D1 03 SUB 22D2 16 AND 22D3 63 PUSH4 0x15f24053 22D8 61 PUSH2 0x22df 22DB 61 PUSH2 0x306e 22DE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @22C9 stack[0] = 0x00 // @22D2 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x01] // @22D3 stack[2] = 0x15f24053 // @22D8 stack[3] = 0x22df // } // Block ends with call to 0x306e, returns to 0x22DF label_22DF: // Incoming return from call to 0x306E at 0x22DE // Inputs[8] // { // @22E2 storage[0x06] // @22E5 storage[0x0a] // @22E8 memory[0x40:0x60] // @22E9 stack[-2] // @22F9 stack[-1] // @2314 memory[0x40:0x60] // @2319 stack[-3] // @231B address(stack[-3]).code.length // } 22DF 5B JUMPDEST 22E0 60 PUSH1 0x06 22E2 54 SLOAD 22E3 60 PUSH1 0x0a 22E5 54 SLOAD 22E6 60 PUSH1 0x40 22E8 51 MLOAD 22E9 84 DUP5 22EA 63 PUSH4 0xffffffff 22EF 16 AND 22F0 60 PUSH1 0xe0 22F2 1B SHL 22F3 81 DUP2 22F4 52 MSTORE 22F5 60 PUSH1 0x04 22F7 01 ADD 22F8 80 DUP1 22F9 84 DUP5 22FA 81 DUP2 22FB 52 MSTORE 22FC 60 PUSH1 0x20 22FE 01 ADD 22FF 83 DUP4 2300 81 DUP2 2301 52 MSTORE 2302 60 PUSH1 0x20 2304 01 ADD 2305 82 DUP3 2306 81 DUP2 2307 52 MSTORE 2308 60 PUSH1 0x20 230A 01 ADD 230B 93 SWAP4 230C 50 POP 230D 50 POP 230E 50 POP 230F 50 POP 2310 60 PUSH1 0x20 2312 60 PUSH1 0x40 2314 51 MLOAD 2315 80 DUP1 2316 83 DUP4 2317 03 SUB 2318 81 DUP2 2319 86 DUP7 231A 80 DUP1 231B 3B EXTCODESIZE 231C 15 ISZERO 231D 80 DUP1 231E 15 ISZERO 231F 61 PUSH2 0x1ef2 2322 57 *JUMPI // Stack delta = +6 // Outputs[11] // { // @22F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @22FB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @2301 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = storage[0x06] // @2307 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = storage[0x0a] // @230B stack[-1] = 0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @2310 stack[0] = 0x20 // @2314 stack[1] = memory[0x40:0x60] // @2317 stack[2] = (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @2318 stack[3] = memory[0x40:0x60] // @2319 stack[4] = stack[-3] // @231C stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1ef2, if !!address(stack[-3]).code.length label_2323: // Incoming jump from 0x2322, if not !!address(stack[-3]).code.length // Inputs[1] { @2326 memory[0x00:0x00] } 2323 60 PUSH1 0x00 2325 80 DUP1 2326 FD *REVERT // Stack delta = +0 // Outputs[1] { @2326 revert(memory[0x00:0x00]); } // Block terminates label_2327: // Incoming jump from 0x0B0F // Inputs[1] { @232B storage[0x00] } 2327 5B JUMPDEST 2328 60 PUSH1 0x00 232A 80 DUP1 232B 54 SLOAD 232C 62 PUSH3 0x010000 2330 90 SWAP1 2331 04 DIV 2332 60 PUSH1 0xff 2334 16 AND 2335 61 PUSH2 0x2371 2338 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2328 stack[0] = 0x00 } // Block ends with conditional jump to 0x2371, if 0xff & storage[0x00] / 0x010000 label_2339: // Incoming jump from 0x2338, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @233C memory[0x40:0x60] // @2367 memory[0x40:0x60] // @2370 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2339 60 PUSH1 0x40 233B 80 DUP1 233C 51 MLOAD 233D 60 PUSH1 0x01 233F 60 PUSH1 0xe5 2341 1B SHL 2342 62 PUSH3 0x461bcd 2346 02 MUL 2347 81 DUP2 2348 52 MSTORE 2349 60 PUSH1 0x20 234B 60 PUSH1 0x04 234D 82 DUP3 234E 01 ADD 234F 52 MSTORE 2350 60 PUSH1 0x03 2352 60 PUSH1 0x24 2354 82 DUP3 2355 01 ADD 2356 52 MSTORE 2357 60 PUSH1 0x01 2359 60 PUSH1 0xe8 235B 1B SHL 235C 62 PUSH3 0x453637 2360 02 MUL 2361 60 PUSH1 0x44 2363 82 DUP3 2364 01 ADD 2365 52 MSTORE 2366 90 SWAP1 2367 51 MLOAD 2368 90 SWAP1 2369 81 DUP2 236A 90 SWAP1 236B 03 SUB 236C 60 PUSH1 0x64 236E 01 ADD 236F 90 SWAP1 2370 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2348 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @234F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2356 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2365 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @2370 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2371: // Incoming jump from 0x2338, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @2375 storage[0x00] } 2371 5B JUMPDEST 2372 60 PUSH1 0x00 2374 80 DUP1 2375 54 SLOAD 2376 62 PUSH3 0xff0000 237A 19 NOT 237B 16 AND 237C 81 DUP2 237D 55 SSTORE 237E 61 PUSH2 0x2385 2381 61 PUSH2 0x1a38 2384 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2372 stack[0] = 0x00 // @237D storage[0x00] = ~0xff0000 & storage[0x00] // @237E stack[1] = 0x2385 // } // Block ends with call to 0x1a38, returns to 0x2385 label_2385: // Incoming return from call to 0x1A38 at 0x2384 // Incoming return from call to 0x1A38 at 0x2384 // Inputs[2] // { // @2386 stack[-1] // @2386 stack[-2] // } 2385 5B JUMPDEST 2386 90 SWAP1 2387 50 POP 2388 80 DUP1 2389 15 ISZERO 238A 61 PUSH2 0x23c5 238D 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2386 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x23c5, if !stack[-1] label_238E: // Incoming jump from 0x238D, if not !stack[-1] // Inputs[3] // { // @2391 memory[0x40:0x60] // @23BB memory[0x40:0x60] // @23C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 238E 60 PUSH1 0x40 2390 80 DUP1 2391 51 MLOAD 2392 60 PUSH1 0x01 2394 60 PUSH1 0xe5 2396 1B SHL 2397 62 PUSH3 0x461bcd 239B 02 MUL 239C 81 DUP2 239D 52 MSTORE 239E 60 PUSH1 0x20 23A0 60 PUSH1 0x04 23A2 82 DUP3 23A3 01 ADD 23A4 52 MSTORE 23A5 60 PUSH1 0x02 23A7 60 PUSH1 0x24 23A9 82 DUP3 23AA 01 ADD 23AB 52 MSTORE 23AC 60 PUSH1 0x01 23AE 60 PUSH1 0xf0 23B0 1B SHL 23B1 61 PUSH2 0x4535 23B4 02 MUL 23B5 60 PUSH1 0x44 23B7 82 DUP3 23B8 01 ADD 23B9 52 MSTORE 23BA 90 SWAP1 23BB 51 MLOAD 23BC 90 SWAP1 23BD 81 DUP2 23BE 90 SWAP1 23BF 03 SUB 23C0 60 PUSH1 0x64 23C2 01 ADD 23C3 90 SWAP1 23C4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @239D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @23A4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @23AB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @23B9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @23C4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_23C5: // Incoming jump from 0x238D, if !stack[-1] // Inputs[1] { @23C9 stack[-3] } 23C5 5B JUMPDEST 23C6 61 PUSH2 0x23ce 23C9 83 DUP4 23CA 61 PUSH2 0x3fd8 23CD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23C6 stack[0] = 0x23ce // @23C9 stack[1] = stack[-3] // } // Block ends with call to 0x3fd8, returns to 0x23CE label_23CE: // Incoming return from call to 0x3FD8 at 0x23CD // Inputs[5] // { // @23CF stack[-1] // @23CF stack[-3] // @23D5 storage[0x00] // @23E3 stack[-5] // @23E4 stack[-4] // } 23CE 5B JUMPDEST 23CF 91 SWAP2 23D0 50 POP 23D1 50 POP 23D2 60 PUSH1 0x00 23D4 80 DUP1 23D5 54 SLOAD 23D6 62 PUSH3 0xff0000 23DA 19 NOT 23DB 16 AND 23DC 62 PUSH3 0x010000 23E0 17 OR 23E1 90 SWAP1 23E2 55 SSTORE 23E3 91 SWAP2 23E4 90 SWAP1 23E5 50 POP 23E6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @23E2 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @23E3 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_23E7: // Incoming jump from 0x0B17 // Inputs[1] { @23ED msg.value } 23E7 5B JUMPDEST 23E8 60 PUSH1 0x00 23EA 61 PUSH2 0x11a3 23ED 34 CALLVALUE 23EE 61 PUSH2 0x4105 23F1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23E8 stack[0] = 0x00 // @23EA stack[1] = 0x11a3 // @23ED stack[2] = msg.value // } // Block ends with call to 0x4105, returns to 0x11A3 label_23F2: // Incoming call from 0x4F19, returns to 0x4F1A // Incoming call from 0x3CE4, returns to 0x3CE5 // Incoming call from 0x5229, returns to 0x522A // Incoming call from 0x4031, returns to 0x4032 // Incoming call from 0x3174, returns to 0x3175 // Incoming call from 0x13A1, returns to 0x13A2 // Incoming call from 0x1A42, returns to 0x1A43 // Incoming call from 0x3EBB, returns to 0x3EBC // Incoming call from 0x497A, returns to 0x497B // Incoming call from 0x4932, returns to 0x4933 // Incoming call from 0x15DA, returns to 0x15DB // Incoming call from 0x44C4, returns to 0x44C5 // Incoming call from 0x185E, returns to 0x185F // Incoming call from 0x0C87, returns to 0x0C88 // Inputs[2] // { // @23F3 block.number // @23F4 stack[-1] // } 23F2 5B JUMPDEST 23F3 43 NUMBER 23F4 90 SWAP1 23F5 56 *JUMP // Stack delta = +0 // Outputs[1] { @23F4 stack[-1] = block.number } // Block ends with unconditional jump to stack[-1] label_23F6: // Incoming call from 0x2960, returns to 0x2961 // Incoming call from 0x20BA, returns to 0x20BB // Incoming call from 0x127D, returns to 0x127E // Incoming call from 0x0CD8, returns to 0x0CD9 // Inputs[1] { @23F9 storage[0x07] } 23F6 5B JUMPDEST 23F7 60 PUSH1 0x07 23F9 54 SLOAD 23FA 60 PUSH1 0x00 23FC 90 SWAP1 23FD 81 DUP2 23FE 90 SWAP1 23FF 80 DUP1 2400 61 PUSH2 0x2411 2403 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @23FC stack[0] = 0x00 // @23FE stack[1] = 0x00 // @23FE stack[2] = storage[0x07] // } // Block ends with conditional jump to 0x2411, if storage[0x07] label_2404: // Incoming jump from 0x2403, if not storage[0x07] // Inputs[2] // { // @2408 storage[0x0c] // @240B stack[-3] // } 2404 50 POP 2405 50 POP 2406 60 PUSH1 0x0c 2408 54 SLOAD 2409 60 PUSH1 0x00 240B 91 SWAP2 240C 50 POP 240D 61 PUSH2 0x1629 2410 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2408 stack[-2] = storage[0x0c] // @240B stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x1629 label_2411: // Incoming jump from 0x2403, if storage[0x07] 2411 5B JUMPDEST 2412 60 PUSH1 0x00 2414 61 PUSH2 0x241b 2417 61 PUSH2 0x306e 241A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2412 stack[0] = 0x00 // @2414 stack[1] = 0x241b // } // Block ends with call to 0x306e, returns to 0x241B label_241B: // Incoming return from call to 0x306E at 0x241A // Inputs[2] // { // @241C stack[-2] // @241C stack[-1] // } 241B 5B JUMPDEST 241C 90 SWAP1 241D 50 POP 241E 60 PUSH1 0x00 2420 61 PUSH2 0x2427 2423 61 PUSH2 0x5357 2426 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @241C stack[-2] = stack[-1] // @241E stack[-1] = 0x00 // @2420 stack[0] = 0x2427 // } // Block ends with call to 0x5357, returns to 0x2427 label_2427: // Incoming return from call to 0x5357 at 0x2426 // Inputs[3] // { // @242D stack[-3] // @2430 storage[0x06] // @2433 storage[0x0a] // } 2427 5B JUMPDEST 2428 60 PUSH1 0x00 242A 61 PUSH2 0x2438 242D 84 DUP5 242E 60 PUSH1 0x06 2430 54 SLOAD 2431 60 PUSH1 0x0a 2433 54 SLOAD 2434 61 PUSH2 0x41c6 2437 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2428 stack[0] = 0x00 // @242A stack[1] = 0x2438 // @242D stack[2] = stack[-3] // @2430 stack[3] = storage[0x06] // @2433 stack[4] = storage[0x0a] // } // Block ends with call to 0x41c6, returns to 0x2438 label_2438: // Incoming return from call to 0x41C6 at 0x2437 // Inputs[4] // { // @2439 stack[-5] // @2439 stack[-1] // @243B stack[-2] // @243B stack[-3] // } 2438 5B JUMPDEST 2439 93 SWAP4 243A 50 POP 243B 90 SWAP1 243C 50 POP 243D 60 PUSH1 0x00 243F 81 DUP2 2440 60 PUSH1 0x03 2442 81 DUP2 2443 11 GT 2444 15 ISZERO 2445 61 PUSH2 0x244a 2448 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2439 stack[-5] = stack[-1] // @243B stack[-3] = stack[-2] // @243D stack[-2] = 0x00 // @243F stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x244a, if !(stack[-2] > 0x03) label_2449: // Incoming jump from 0x2448, if not !(stack[-2] > 0x03) 2449 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2449 assert(); } // Block terminates label_244A: // Incoming jump from 0x2448, if !(stack[-2] > 0x03) // Inputs[2] // { // @244B stack[-2] // @244B stack[-1] // } 244A 5B JUMPDEST 244B 14 EQ 244C 61 PUSH2 0x245f 244F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x245f, if stack[-1] == stack[-2] label_2450: // Incoming jump from 0x244F, if not stack[-1] == stack[-2] // Inputs[4] // { // @2450 stack[-7] // @2450 stack[-1] // @2454 stack[-6] // @2459 stack[-5] // } 2450 95 SWAP6 2451 50 POP 2452 60 PUSH1 0x00 2454 94 SWAP5 2455 50 POP 2456 61 PUSH2 0x1629 2459 93 SWAP4 245A 50 POP 245B 50 POP 245C 50 POP 245D 50 POP 245E 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2450 stack[-7] = stack[-1] // @2454 stack[-6] = 0x00 // } // Block ends with unconditional jump to 0x1629 label_245F: // Incoming jump from 0x244F, if stack[-1] == stack[-2] // Inputs[2] // { // @2463 stack[-3] // @2464 stack[-5] // } 245F 5B JUMPDEST 2460 61 PUSH2 0x2469 2463 83 DUP4 2464 86 DUP7 2465 61 PUSH2 0x4204 2468 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2460 stack[0] = 0x2469 // @2463 stack[1] = stack[-3] // @2464 stack[2] = stack[-5] // } // Block ends with call to 0x4204, returns to 0x2469 label_2469: // Incoming return from call to 0x4204 at 0x2468 // Incoming return from call to 0x4204 at 0x2468 // Inputs[4] // { // @246A stack[-4] // @246A stack[-1] // @246C stack[-3] // @246C stack[-2] // } 2469 5B JUMPDEST 246A 92 SWAP3 246B 50 POP 246C 90 SWAP1 246D 50 POP 246E 60 PUSH1 0x00 2470 81 DUP2 2471 60 PUSH1 0x03 2473 81 DUP2 2474 11 GT 2475 15 ISZERO 2476 61 PUSH2 0x247b 2479 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @246A stack[-4] = stack[-1] // @246C stack[-3] = stack[-2] // @246E stack[-2] = 0x00 // @2470 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x247b, if !(stack[-2] > 0x03) label_247A: // Incoming jump from 0x2479, if not !(stack[-2] > 0x03) 247A FE *ASSERT // Stack delta = +0 // Outputs[1] { @247A assert(); } // Block terminates label_247B: // Incoming jump from 0x2479, if !(stack[-2] > 0x03) // Inputs[2] // { // @247C stack[-1] // @247C stack[-2] // } 247B 5B JUMPDEST 247C 14 EQ 247D 61 PUSH2 0x2490 2480 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2490, if stack[-1] == stack[-2] label_2481: // Incoming jump from 0x2480, if not stack[-1] == stack[-2] // Inputs[4] // { // @2481 stack[-1] // @2481 stack[-7] // @2485 stack[-6] // @248A stack[-5] // } 2481 95 SWAP6 2482 50 POP 2483 60 PUSH1 0x00 2485 94 SWAP5 2486 50 POP 2487 61 PUSH2 0x1629 248A 93 SWAP4 248B 50 POP 248C 50 POP 248D 50 POP 248E 50 POP 248F 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2481 stack[-7] = stack[-1] // @2485 stack[-6] = 0x00 // } // Block ends with unconditional jump to 0x1629 label_2490: // Incoming jump from 0x2480, if stack[-1] == stack[-2] // Inputs[5] // { // @2492 memory[stack[-2]:stack[-2] + 0x20] // @2492 stack[-2] // @2495 stack[-7] // @2497 stack[-6] // @249C stack[-5] // } 2490 5B JUMPDEST 2491 50 POP 2492 51 MLOAD 2493 60 PUSH1 0x00 2495 95 SWAP6 2496 50 POP 2497 93 SWAP4 2498 50 POP 2499 61 PUSH2 0x1629 249C 92 SWAP3 249D 50 POP 249E 50 POP 249F 50 POP 24A0 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2495 stack[-7] = 0x00 // @2497 stack[-6] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1629 label_24A1: // Incoming call from 0x461C, returns to 0x461D // Incoming call from 0x0D59, returns to 0x0D5A // Incoming call from 0x5273, returns to 0x5274 // Incoming call from 0x461C, returns to 0x461D // Inputs[2] // { // @24A4 msg.sender // @24AD stack[-2] // } 24A1 5B JUMPDEST 24A2 60 PUSH1 0x00 24A4 33 CALLER 24A5 60 PUSH1 0x01 24A7 60 PUSH1 0x01 24A9 60 PUSH1 0xa0 24AB 1B SHL 24AC 03 SUB 24AD 84 DUP5 24AE 16 AND 24AF 14 EQ 24B0 61 PUSH2 0x24ec 24B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24A2 stack[0] = 0x00 } // Block ends with conditional jump to 0x24ec, if stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender label_24B4: // Incoming jump from 0x24B3, if not stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[3] // { // @24B7 memory[0x40:0x60] // @24E2 memory[0x40:0x60] // @24EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 24B4 60 PUSH1 0x40 24B6 80 DUP1 24B7 51 MLOAD 24B8 60 PUSH1 0x01 24BA 60 PUSH1 0xe5 24BC 1B SHL 24BD 62 PUSH3 0x461bcd 24C1 02 MUL 24C2 81 DUP2 24C3 52 MSTORE 24C4 60 PUSH1 0x20 24C6 60 PUSH1 0x04 24C8 82 DUP3 24C9 01 ADD 24CA 52 MSTORE 24CB 60 PUSH1 0x03 24CD 60 PUSH1 0x24 24CF 82 DUP3 24D0 01 ADD 24D1 52 MSTORE 24D2 60 PUSH1 0x01 24D4 60 PUSH1 0xe8 24D6 1B SHL 24D7 62 PUSH3 0x453737 24DB 02 MUL 24DC 60 PUSH1 0x44 24DE 82 DUP3 24DF 01 ADD 24E0 52 MSTORE 24E1 90 SWAP1 24E2 51 MLOAD 24E3 90 SWAP1 24E4 81 DUP2 24E5 90 SWAP1 24E6 03 SUB 24E7 60 PUSH1 0x64 24E9 01 ADD 24EA 90 SWAP1 24EB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @24C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @24CA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @24D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @24E0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453737 * (0x01 << 0xe8) // @24EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_24EC: // Incoming jump from 0x24B3, if stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @24ED stack[-2] // @24EE msg.value // } 24EC 5B JUMPDEST 24ED 81 DUP2 24EE 34 CALLVALUE 24EF 14 EQ 24F0 61 PUSH2 0x252c 24F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x252c, if msg.value == stack[-2] label_24F4: // Incoming jump from 0x24F3, if not msg.value == stack[-2] // Inputs[3] // { // @24F7 memory[0x40:0x60] // @2522 memory[0x40:0x60] // @252B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 24F4 60 PUSH1 0x40 24F6 80 DUP1 24F7 51 MLOAD 24F8 60 PUSH1 0x01 24FA 60 PUSH1 0xe5 24FC 1B SHL 24FD 62 PUSH3 0x461bcd 2501 02 MUL 2502 81 DUP2 2503 52 MSTORE 2504 60 PUSH1 0x20 2506 60 PUSH1 0x04 2508 82 DUP3 2509 01 ADD 250A 52 MSTORE 250B 60 PUSH1 0x03 250D 60 PUSH1 0x24 250F 82 DUP3 2510 01 ADD 2511 52 MSTORE 2512 60 PUSH1 0x01 2514 60 PUSH1 0xeb 2516 1B SHL 2517 62 PUSH3 0x08a6e7 251B 02 MUL 251C 60 PUSH1 0x44 251E 82 DUP3 251F 01 ADD 2520 52 MSTORE 2521 90 SWAP1 2522 51 MLOAD 2523 90 SWAP1 2524 81 DUP2 2525 90 SWAP1 2526 03 SUB 2527 60 PUSH1 0x64 2529 01 ADD 252A 90 SWAP1 252B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2503 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @250A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2511 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2520 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x08a6e7 * (0x01 << 0xeb) // @252B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_252C: // Incoming jump from 0x24F3, if msg.value == stack[-2] // Inputs[3] // { // @252E stack[-4] // @252E stack[-2] // @252F stack[-3] // } 252C 5B JUMPDEST 252D 50 POP 252E 91 SWAP2 252F 90 SWAP1 2530 50 POP 2531 56 *JUMP // Stack delta = -3 // Outputs[1] { @252E stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2532: // Incoming jump from 0x2AB2 // Incoming jump from 0x0D7A 2532 5B JUMPDEST 2533 60 PUSH1 0x00 2535 80 DUP1 2536 60 PUSH1 0x00 2538 61 PUSH2 0x253f 253B 61 PUSH2 0x5357 253E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2533 stack[0] = 0x00 // @2535 stack[1] = 0x00 // @2536 stack[2] = 0x00 // @2538 stack[3] = 0x253f // } // Block ends with call to 0x5357, returns to 0x253F label_253F: // Incoming return from call to 0x5357 at 0x253E // Inputs[2] // { // @2543 stack[-6] // @2544 stack[-5] // } 253F 5B JUMPDEST 2540 61 PUSH2 0x2549 2543 86 DUP7 2544 86 DUP7 2545 61 PUSH2 0x42b4 2548 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2540 stack[0] = 0x2549 // @2543 stack[1] = stack[-6] // @2544 stack[2] = stack[-5] // } // Block ends with call to 0x42b4, returns to 0x2549 label_2549: // Incoming return from call to 0x42B4 at 0x2548 // Incoming return from call to 0x33E3 at 0x306D // Inputs[4] // { // @254A stack[-1] // @254A stack[-2] // @254B stack[-4] // @254D stack[-3] // } 2549 5B JUMPDEST 254A 90 SWAP1 254B 92 SWAP3 254C 50 POP 254D 90 SWAP1 254E 50 POP 254F 60 PUSH1 0x00 2551 82 DUP3 2552 60 PUSH1 0x03 2554 81 DUP2 2555 11 GT 2556 15 ISZERO 2557 61 PUSH2 0x255c 255A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @254B stack[-4] = stack[-2] // @254D stack[-3] = stack[-1] // @254F stack[-2] = 0x00 // @2551 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x255c, if !(stack[-2] > 0x03) label_255B: // Incoming jump from 0x255A, if not !(stack[-2] > 0x03) 255B FE *ASSERT // Stack delta = +0 // Outputs[1] { @255B assert(); } // Block terminates label_255C: // Incoming jump from 0x255A, if !(stack[-2] > 0x03) // Inputs[2] // { // @255D stack[-1] // @255D stack[-2] // } 255C 5B JUMPDEST 255D 14 EQ 255E 61 PUSH2 0x256d 2561 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x256d, if stack[-1] == stack[-2] label_2562: // Incoming jump from 0x2561, if not stack[-1] == stack[-2] // Inputs[3] // { // @2563 stack[-2] // @2563 stack[-4] // @2567 stack[-3] // } 2562 50 POP 2563 91 SWAP2 2564 50 POP 2565 60 PUSH1 0x00 2567 90 SWAP1 2568 50 POP 2569 61 PUSH2 0x257f 256C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2563 stack[-4] = stack[-2] // @2567 stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x257f label_256D: // Incoming jump from 0x2561, if stack[-1] == stack[-2] // Inputs[1] { @2573 stack[-1] } 256D 5B JUMPDEST 256E 60 PUSH1 0x00 2570 61 PUSH2 0x2578 2573 82 DUP3 2574 61 PUSH2 0x4313 2577 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @256E stack[0] = 0x00 // @2570 stack[1] = 0x2578 // @2573 stack[2] = stack[-1] // } // Block ends with call to 0x4313, returns to 0x2578 label_2578: // Incoming return from call to 0x4313 at 0x2577 // Incoming return from call to 0x4204 at 0x4312 // Inputs[4] // { // @2579 stack[-1] // @2579 stack[-5] // @257B stack[-2] // @257B stack[-6] // } 2578 5B JUMPDEST 2579 93 SWAP4 257A 50 POP 257B 93 SWAP4 257C 50 POP 257D 50 POP 257E 50 POP // Stack delta = -4 // Outputs[2] // { // @2579 stack[-5] = stack[-1] // @257B stack[-6] = stack[-2] // } // Block continues label_257F: // Incoming jump from 0x33D6 // Incoming jump from 0x33E2 // Incoming jump from 0x4304 // Incoming jump from 0x4822 // Incoming jump from 0x4296 // Incoming jump from 0x4817 // Incoming jump from 0x4254 // Incoming jump from 0x4836 // Incoming jump from 0x256C // Incoming jump from 0x259D // Incoming jump from 0x25AB // Incoming jump from 0x342F // Incoming jump from 0x257E // Incoming jump from 0x47F6 // Inputs[5] // { // @2580 stack[-1] // @2580 stack[-4] // @2582 stack[-5] // @2582 stack[-2] // @2583 stack[-3] // } 257F 5B JUMPDEST 2580 92 SWAP3 2581 50 POP 2582 92 SWAP3 2583 90 SWAP1 2584 50 POP 2585 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2580 stack[-4] = stack[-1] // @2582 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_2586: // Incoming jump from 0x3497 // Incoming call from 0x1C85, returns to 0x1C86 // Incoming call from 0x50AF, returns to 0x50B0 // Incoming call from 0x41D5, returns to 0x41D6 // Incoming call from 0x5032, returns to 0x5033 // Incoming call from 0x27C9, returns to 0x27CA // Incoming call from 0x39E7, returns to 0x39E8 // Incoming call from 0x517A, returns to 0x517B // Inputs[2] // { // @258A stack[-2] // @258B stack[-1] // } 2586 5B JUMPDEST 2587 60 PUSH1 0x00 2589 80 DUP1 258A 83 DUP4 258B 83 DUP4 258C 01 ADD 258D 84 DUP5 258E 81 DUP2 258F 10 LT 2590 61 PUSH2 0x259e 2593 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2587 stack[0] = 0x00 // @2589 stack[1] = 0x00 // @258C stack[2] = stack[-1] + stack[-2] // } // Block ends with conditional jump to 0x259e, if stack[-1] + stack[-2] < stack[-2] label_2594: // Incoming jump from 0x2593, if not stack[-1] + stack[-2] < stack[-2] // Inputs[3] // { // @2596 stack[-3] // @2598 stack[-2] // @2598 stack[-1] // } 2594 60 PUSH1 0x00 2596 92 SWAP3 2597 50 POP 2598 90 SWAP1 2599 50 POP 259A 61 PUSH2 0x257f 259D 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2596 stack[-3] = 0x00 // @2598 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x257f label_259E: // Incoming jump from 0x2593, if stack[-1] + stack[-2] < stack[-2] // Inputs[2] // { // @25A2 stack[-3] // @25A6 stack[-2] // } 259E 5B JUMPDEST 259F 50 POP 25A0 60 PUSH1 0x02 25A2 91 SWAP2 25A3 50 POP 25A4 60 PUSH1 0x00 25A6 90 SWAP1 25A7 50 POP 25A8 61 PUSH2 0x257f 25AB 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @25A2 stack[-3] = 0x02 // @25A6 stack[-2] = 0x00 // } // Block ends with unconditional jump to 0x257f label_25AC: // Incoming call from 0x1336, returns to 0x1337 // Incoming call from 0x1E26, returns to 0x1E27 // Inputs[8] // { // @25B0 storage[0x00] // @25B4 memory[0x40:0x60] // @25C2 address(this) // @25D0 stack[-3] // @25D8 stack[-2] // @25E4 stack[-1] // @25E8 memory[0x40:0x60] // @2610 address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } 25AC 5B JUMPDEST 25AD 60 PUSH1 0x00 25AF 80 DUP1 25B0 54 SLOAD 25B1 60 PUSH1 0x40 25B3 80 DUP1 25B4 51 MLOAD 25B5 60 PUSH1 0x01 25B7 60 PUSH1 0xe3 25B9 1B SHL 25BA 63 PUSH4 0x17b9b84b 25BF 02 MUL 25C0 81 DUP2 25C1 52 MSTORE 25C2 30 ADDRESS 25C3 60 PUSH1 0x04 25C5 82 DUP3 25C6 01 ADD 25C7 52 MSTORE 25C8 60 PUSH1 0x01 25CA 60 PUSH1 0x01 25CC 60 PUSH1 0xa0 25CE 1B SHL 25CF 03 SUB 25D0 87 DUP8 25D1 81 DUP2 25D2 16 AND 25D3 60 PUSH1 0x24 25D5 83 DUP4 25D6 01 ADD 25D7 52 MSTORE 25D8 86 DUP7 25D9 81 DUP2 25DA 16 AND 25DB 60 PUSH1 0x44 25DD 83 DUP4 25DE 01 ADD 25DF 52 MSTORE 25E0 60 PUSH1 0x64 25E2 82 DUP3 25E3 01 ADD 25E4 86 DUP7 25E5 90 SWAP1 25E6 52 MSTORE 25E7 91 SWAP2 25E8 51 MLOAD 25E9 84 DUP5 25EA 93 SWAP4 25EB 63 PUSH4 0x01000000 25F0 90 SWAP1 25F1 04 DIV 25F2 90 SWAP1 25F3 92 SWAP3 25F4 16 AND 25F5 91 SWAP2 25F6 63 PUSH4 0xbdcdc258 25FB 91 SWAP2 25FC 60 PUSH1 0x84 25FE 80 DUP1 25FF 82 DUP3 2600 01 ADD 2601 92 SWAP3 2602 60 PUSH1 0x20 2604 92 SWAP3 2605 90 SWAP1 2606 91 SWAP2 2607 90 SWAP1 2608 82 DUP3 2609 90 SWAP1 260A 03 SUB 260B 01 ADD 260C 81 DUP2 260D 87 DUP8 260E 87 DUP8 260F 80 DUP1 2610 3B EXTCODESIZE 2611 15 ISZERO 2612 80 DUP1 2613 15 ISZERO 2614 61 PUSH2 0x261c 2617 57 *JUMPI // Stack delta = +12 // Outputs[17] // { // @25AD stack[0] = 0x00 // @25C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x17b9b84b * (0x01 << 0xe3) // @25C7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @25D7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @25DF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @25E6 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-1] // @25EA stack[1] = 0x00 // @25F5 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @25FB stack[3] = 0xbdcdc258 // @2601 stack[4] = memory[0x40:0x60] + 0x84 // @2604 stack[5] = 0x20 // @2606 stack[6] = memory[0x40:0x60] // @260B stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x84 // @260C stack[8] = memory[0x40:0x60] // @260D stack[9] = 0x00 // @260E stack[10] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @2611 stack[11] = !address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } // Block ends with conditional jump to 0x261c, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length label_2618: // Incoming jump from 0x2617, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[1] { @261B memory[0x00:0x00] } 2618 60 PUSH1 0x00 261A 80 DUP1 261B FD *REVERT // Stack delta = +0 // Outputs[1] { @261B revert(memory[0x00:0x00]); } // Block terminates label_261C: // Incoming jump from 0x2617, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[9] // { // @261E msg.gas // @261F stack[-7] // @261F stack[-3] // @261F stack[-5] // @261F memory[stack[-4]:stack[-4] + stack[-5]] // @261F stack[-4] // @261F stack[-2] // @261F address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @261F stack[-6] // } 261C 5B JUMPDEST 261D 50 POP 261E 5A GAS 261F F1 CALL 2620 15 ISZERO 2621 80 DUP1 2622 15 ISZERO 2623 61 PUSH2 0x2630 2626 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @261F memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2620 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2630, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2627: // Incoming jump from 0x2626, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2627 returndata.length // @262B returndata[0x00:0x00 + returndata.length] // @262C returndata.length // @262F memory[0x00:0x00 + returndata.length] // } 2627 3D RETURNDATASIZE 2628 60 PUSH1 0x00 262A 80 DUP1 262B 3E RETURNDATACOPY 262C 3D RETURNDATASIZE 262D 60 PUSH1 0x00 262F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @262B memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @262F revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2630: // Incoming jump from 0x2626, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @2637 memory[0x40:0x60] // @2638 returndata.length // } 2630 5B JUMPDEST 2631 50 POP 2632 50 POP 2633 50 POP 2634 50 POP 2635 60 PUSH1 0x40 2637 51 MLOAD 2638 3D RETURNDATASIZE 2639 60 PUSH1 0x20 263B 81 DUP2 263C 10 LT 263D 15 ISZERO 263E 61 PUSH2 0x2646 2641 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2637 stack[-4] = memory[0x40:0x60] // @2638 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2646, if !(returndata.length < 0x20) label_2642: // Incoming jump from 0x2641, if not !(returndata.length < 0x20) // Inputs[1] { @2645 memory[0x00:0x00] } 2642 60 PUSH1 0x00 2644 80 DUP1 2645 FD *REVERT // Stack delta = +0 // Outputs[1] { @2645 revert(memory[0x00:0x00]); } // Block terminates label_2646: // Incoming jump from 0x2641, if !(returndata.length < 0x20) // Inputs[3] // { // @2648 stack[-2] // @2648 memory[stack[-2]:stack[-2] + 0x20] // @2649 stack[-3] // } 2646 5B JUMPDEST 2647 50 POP 2648 51 MLOAD 2649 90 SWAP1 264A 50 POP 264B 80 DUP1 264C 15 ISZERO 264D 61 PUSH2 0x2665 2650 57 *JUMPI // Stack delta = -2 // Outputs[1] { @2649 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2665, if !memory[stack[-2]:stack[-2] + 0x20] label_2651: // Incoming jump from 0x2650, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @2658 stack[-1] } 2651 61 PUSH2 0x265d 2654 60 PUSH1 0x03 2656 60 PUSH1 0x4a 2658 83 DUP4 2659 61 PUSH2 0x4322 265C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2651 stack[0] = 0x265d // @2654 stack[1] = 0x03 // @2656 stack[2] = 0x4a // @2658 stack[3] = stack[-1] // } // Block ends with call to 0x4322, returns to 0x265D label_265D: // Incoming return from call to 0x4322 at 0x265C // Incoming return from call to 0x4388 at 0x268A // Inputs[2] // { // @265E stack[-3] // @265E stack[-1] // } 265D 5B JUMPDEST 265E 91 SWAP2 265F 50 POP 2660 50 POP 2661 61 PUSH2 0x1560 2664 56 *JUMP // Stack delta = -2 // Outputs[1] { @265E stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1560 label_2665: // Incoming jump from 0x2650, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @2666 stack[-4] // @2670 stack[-5] // } 2665 5B JUMPDEST 2666 83 DUP4 2667 60 PUSH1 0x01 2669 60 PUSH1 0x01 266B 60 PUSH1 0xa0 266D 1B SHL 266E 03 SUB 266F 16 AND 2670 85 DUP6 2671 60 PUSH1 0x01 2673 60 PUSH1 0x01 2675 60 PUSH1 0xa0 2677 1B SHL 2678 03 SUB 2679 16 AND 267A 14 EQ 267B 15 ISZERO 267C 61 PUSH2 0x268b 267F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x268b, if !((0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-4]) label_2680: // Incoming jump from 0x267F, if not !((0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-4]) 2680 61 PUSH2 0x265d 2683 60 PUSH1 0x02 2685 60 PUSH1 0x4b 2687 61 PUSH2 0x4388 268A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2680 stack[0] = 0x265d // @2683 stack[1] = 0x02 // @2685 stack[2] = 0x4b // } // Block ends with call to 0x4388, returns to 0x265D label_268B: // Incoming jump from 0x267F, if !((0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-4]) // Inputs[2] // { // @2696 stack[-6] // @269A stack[-5] // } 268B 5B JUMPDEST 268C 60 PUSH1 0x00 268E 60 PUSH1 0x01 2690 60 PUSH1 0x01 2692 60 PUSH1 0xa0 2694 1B SHL 2695 03 SUB 2696 87 DUP8 2697 81 DUP2 2698 16 AND 2699 90 SWAP1 269A 87 DUP8 269B 16 AND 269C 14 EQ 269D 15 ISZERO 269E 61 PUSH2 0x26aa 26A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @268C stack[0] = 0x00 } // Block ends with conditional jump to 0x26aa, if !(stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-6]) label_26A2: // Incoming jump from 0x26A1, if not !(stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-6]) 26A2 50 POP 26A3 60 PUSH1 0x00 26A5 19 NOT 26A6 61 PUSH2 0x26d2 26A9 56 *JUMP // Stack delta = +0 // Outputs[1] { @26A5 stack[-1] = ~0x00 } // Block ends with unconditional jump to 0x26d2 label_26AA: // Incoming jump from 0x26A1, if !(stack[-5] & (0x01 << 0xa0) - 0x01 == (0x01 << 0xa0) - 0x01 & stack[-6]) // Inputs[6] // { // @26B5 stack[-6] // @26C7 memory[0x00:0x40] // @26C9 stack[-7] // @26D0 memory[0x00:0x40] // @26D1 storage[keccak256(memory[0x00:0x40])] // @26DD stack[-4] // } 26AA 5B JUMPDEST 26AB 50 POP 26AC 60 PUSH1 0x01 26AE 60 PUSH1 0x01 26B0 60 PUSH1 0xa0 26B2 1B SHL 26B3 03 SUB 26B4 80 DUP1 26B5 86 DUP7 26B6 16 AND 26B7 60 PUSH1 0x00 26B9 90 SWAP1 26BA 81 DUP2 26BB 52 MSTORE 26BC 60 PUSH1 0x0e 26BE 60 PUSH1 0x20 26C0 90 SWAP1 26C1 81 DUP2 26C2 52 MSTORE 26C3 60 PUSH1 0x40 26C5 80 DUP1 26C6 83 DUP4 26C7 20 SHA3 26C8 93 SWAP4 26C9 8A DUP11 26CA 16 AND 26CB 83 DUP4 26CC 52 MSTORE 26CD 92 SWAP3 26CE 90 SWAP1 26CF 52 MSTORE 26D0 20 SHA3 26D1 54 SLOAD 26D2 5B JUMPDEST 26D3 60 PUSH1 0x00 26D5 80 DUP1 26D6 60 PUSH1 0x00 26D8 80 DUP1 26D9 61 PUSH2 0x26e2 26DC 85 DUP6 26DD 89 DUP10 26DE 61 PUSH2 0x33c0 26E1 56 *JUMP // Stack delta = +7 // Outputs[12] // { // @26BB memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @26C2 memory[0x20:0x40] = 0x0e // @26CC memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @26CF memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @26D1 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @26D3 stack[0] = 0x00 // @26D5 stack[1] = 0x00 // @26D6 stack[2] = 0x00 // @26D8 stack[3] = 0x00 // @26D9 stack[4] = 0x26e2 // @26DC stack[5] = storage[keccak256(memory[0x00:0x40])] // @26DD stack[6] = stack[-4] // } // Block ends with call to 0x33c0, returns to 0x26E2 label_26E2: // Incoming return from call to 0x33C0 at 0x26E1 // Incoming return from call to 0x33C0 at 0x26E1 // Inputs[4] // { // @26E3 stack[-2] // @26E3 stack[-1] // @26E4 stack[-6] // @26E6 stack[-5] // } 26E2 5B JUMPDEST 26E3 90 SWAP1 26E4 94 SWAP5 26E5 50 POP 26E6 92 SWAP3 26E7 50 POP 26E8 60 PUSH1 0x00 26EA 84 DUP5 26EB 60 PUSH1 0x03 26ED 81 DUP2 26EE 11 GT 26EF 15 ISZERO 26F0 61 PUSH2 0x26f5 26F3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @26E4 stack[-6] = stack[-2] // @26E6 stack[-5] = stack[-1] // @26E8 stack[-2] = 0x00 // @26EA stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x26f5, if !(stack[-2] > 0x03) label_26F4: // Incoming jump from 0x26F3, if not !(stack[-2] > 0x03) 26F4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @26F4 assert(); } // Block terminates label_26F5: // Incoming jump from 0x26F3, if !(stack[-2] > 0x03) // Inputs[2] // { // @26F6 stack[-1] // @26F6 stack[-2] // } 26F5 5B JUMPDEST 26F6 14 EQ 26F7 61 PUSH2 0x2733 26FA 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2733, if stack[-1] == stack[-2] label_26FB: // Incoming jump from 0x26FA, if not stack[-1] == stack[-2] // Inputs[3] // { // @26FE memory[0x40:0x60] // @2729 memory[0x40:0x60] // @2732 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 26FB 60 PUSH1 0x40 26FD 80 DUP1 26FE 51 MLOAD 26FF 60 PUSH1 0x01 2701 60 PUSH1 0xe5 2703 1B SHL 2704 62 PUSH3 0x461bcd 2708 02 MUL 2709 81 DUP2 270A 52 MSTORE 270B 60 PUSH1 0x20 270D 60 PUSH1 0x04 270F 82 DUP3 2710 01 ADD 2711 52 MSTORE 2712 60 PUSH1 0x03 2714 60 PUSH1 0x24 2716 82 DUP3 2717 01 ADD 2718 52 MSTORE 2719 60 PUSH1 0x01 271B 60 PUSH1 0xec 271D 1B SHL 271E 62 PUSH3 0x045373 2722 02 MUL 2723 60 PUSH1 0x44 2725 82 DUP3 2726 01 ADD 2727 52 MSTORE 2728 90 SWAP1 2729 51 MLOAD 272A 90 SWAP1 272B 81 DUP2 272C 90 SWAP1 272D 03 SUB 272E 60 PUSH1 0x64 2730 01 ADD 2731 90 SWAP1 2732 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @270A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2711 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2718 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2727 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x045373 * (0x01 << 0xec) // @2732 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2733: // Incoming jump from 0x26FA, if stack[-1] == stack[-2] // Inputs[4] // { // @273C stack[-10] // @274B memory[0x00:0x40] // @274C storage[keccak256(memory[0x00:0x40])] // @2751 stack[-8] // } 2733 5B JUMPDEST 2734 60 PUSH1 0x01 2736 60 PUSH1 0x01 2738 60 PUSH1 0xa0 273A 1B SHL 273B 03 SUB 273C 8A DUP11 273D 16 AND 273E 60 PUSH1 0x00 2740 90 SWAP1 2741 81 DUP2 2742 52 MSTORE 2743 60 PUSH1 0x0d 2745 60 PUSH1 0x20 2747 52 MSTORE 2748 60 PUSH1 0x40 274A 90 SWAP1 274B 20 SHA3 274C 54 SLOAD 274D 61 PUSH2 0x2756 2750 90 SWAP1 2751 89 DUP10 2752 61 PUSH2 0x33c0 2755 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2742 memory[0x00:0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @2747 memory[0x20:0x40] = 0x0d // @2750 stack[0] = 0x2756 // @2750 stack[1] = storage[keccak256(memory[0x00:0x40])] // @2751 stack[2] = stack[-8] // } // Block ends with call to 0x33c0, returns to 0x2756 label_2756: // Incoming return from call to 0x33C0 at 0x2755 // Inputs[4] // { // @2757 stack[-2] // @2757 stack[-1] // @2758 stack[-6] // @275A stack[-4] // } 2756 5B JUMPDEST 2757 90 SWAP1 2758 94 SWAP5 2759 50 POP 275A 91 SWAP2 275B 50 POP 275C 60 PUSH1 0x00 275E 84 DUP5 275F 60 PUSH1 0x03 2761 81 DUP2 2762 11 GT 2763 15 ISZERO 2764 61 PUSH2 0x2769 2767 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2758 stack[-6] = stack[-2] // @275A stack[-4] = stack[-1] // @275C stack[-2] = 0x00 // @275E stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x2769, if !(stack[-2] > 0x03) label_2768: // Incoming jump from 0x2767, if not !(stack[-2] > 0x03) 2768 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2768 assert(); } // Block terminates label_2769: // Incoming jump from 0x2767, if !(stack[-2] > 0x03) // Inputs[2] // { // @276A stack[-1] // @276A stack[-2] // } 2769 5B JUMPDEST 276A 14 EQ 276B 61 PUSH2 0x27a7 276E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x27a7, if stack[-1] == stack[-2] label_276F: // Incoming jump from 0x276E, if not stack[-1] == stack[-2] // Inputs[3] // { // @2772 memory[0x40:0x60] // @279D memory[0x40:0x60] // @27A6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 276F 60 PUSH1 0x40 2771 80 DUP1 2772 51 MLOAD 2773 60 PUSH1 0x01 2775 60 PUSH1 0xe5 2777 1B SHL 2778 62 PUSH3 0x461bcd 277C 02 MUL 277D 81 DUP2 277E 52 MSTORE 277F 60 PUSH1 0x20 2781 60 PUSH1 0x04 2783 82 DUP3 2784 01 ADD 2785 52 MSTORE 2786 60 PUSH1 0x03 2788 60 PUSH1 0x24 278A 82 DUP3 278B 01 ADD 278C 52 MSTORE 278D 60 PUSH1 0x01 278F 60 PUSH1 0xe8 2791 1B SHL 2792 62 PUSH3 0x453731 2796 02 MUL 2797 60 PUSH1 0x44 2799 82 DUP3 279A 01 ADD 279B 52 MSTORE 279C 90 SWAP1 279D 51 MLOAD 279E 90 SWAP1 279F 81 DUP2 27A0 90 SWAP1 27A1 03 SUB 27A2 60 PUSH1 0x64 27A4 01 ADD 27A5 90 SWAP1 27A6 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @277E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2785 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @278C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @279B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453731 * (0x01 << 0xe8) // @27A6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_27A7: // Incoming jump from 0x276E, if stack[-1] == stack[-2] // Inputs[4] // { // @27B0 stack[-9] // @27BF memory[0x00:0x40] // @27C0 storage[keccak256(memory[0x00:0x40])] // @27C5 stack[-8] // } 27A7 5B JUMPDEST 27A8 60 PUSH1 0x01 27AA 60 PUSH1 0x01 27AC 60 PUSH1 0xa0 27AE 1B SHL 27AF 03 SUB 27B0 89 DUP10 27B1 16 AND 27B2 60 PUSH1 0x00 27B4 90 SWAP1 27B5 81 DUP2 27B6 52 MSTORE 27B7 60 PUSH1 0x0d 27B9 60 PUSH1 0x20 27BB 52 MSTORE 27BC 60 PUSH1 0x40 27BE 90 SWAP1 27BF 20 SHA3 27C0 54 SLOAD 27C1 61 PUSH2 0x27ca 27C4 90 SWAP1 27C5 89 DUP10 27C6 61 PUSH2 0x2586 27C9 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @27B6 memory[0x00:0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @27BB memory[0x20:0x40] = 0x0d // @27C4 stack[0] = 0x27ca // @27C4 stack[1] = storage[keccak256(memory[0x00:0x40])] // @27C5 stack[2] = stack[-8] // } // Block ends with call to 0x2586, returns to 0x27CA label_27CA: // Incoming return from call to 0x2586 at 0x27C9 // Inputs[4] // { // @27CB stack[-1] // @27CB stack[-2] // @27CC stack[-6] // @27CE stack[-3] // } 27CA 5B JUMPDEST 27CB 90 SWAP1 27CC 94 SWAP5 27CD 50 POP 27CE 90 SWAP1 27CF 50 POP 27D0 60 PUSH1 0x00 27D2 84 DUP5 27D3 60 PUSH1 0x03 27D5 81 DUP2 27D6 11 GT 27D7 15 ISZERO 27D8 61 PUSH2 0x27dd 27DB 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @27CC stack[-6] = stack[-2] // @27CE stack[-3] = stack[-1] // @27D0 stack[-2] = 0x00 // @27D2 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x27dd, if !(stack[-2] > 0x03) label_27DC: // Incoming jump from 0x27DB, if not !(stack[-2] > 0x03) 27DC FE *ASSERT // Stack delta = +0 // Outputs[1] { @27DC assert(); } // Block terminates label_27DD: // Incoming jump from 0x27DB, if !(stack[-2] > 0x03) // Inputs[2] // { // @27DE stack[-2] // @27DE stack[-1] // } 27DD 5B JUMPDEST 27DE 14 EQ 27DF 61 PUSH2 0x281b 27E2 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x281b, if stack[-1] == stack[-2] label_27E3: // Incoming jump from 0x27E2, if not stack[-1] == stack[-2] // Inputs[3] // { // @27E6 memory[0x40:0x60] // @2811 memory[0x40:0x60] // @281A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 27E3 60 PUSH1 0x40 27E5 80 DUP1 27E6 51 MLOAD 27E7 60 PUSH1 0x01 27E9 60 PUSH1 0xe5 27EB 1B SHL 27EC 62 PUSH3 0x461bcd 27F0 02 MUL 27F1 81 DUP2 27F2 52 MSTORE 27F3 60 PUSH1 0x20 27F5 60 PUSH1 0x04 27F7 82 DUP3 27F8 01 ADD 27F9 52 MSTORE 27FA 60 PUSH1 0x03 27FC 60 PUSH1 0x24 27FE 82 DUP3 27FF 01 ADD 2800 52 MSTORE 2801 60 PUSH1 0x01 2803 60 PUSH1 0xe9 2805 1B SHL 2806 62 PUSH3 0x229b99 280A 02 MUL 280B 60 PUSH1 0x44 280D 82 DUP3 280E 01 ADD 280F 52 MSTORE 2810 90 SWAP1 2811 51 MLOAD 2812 90 SWAP1 2813 81 DUP2 2814 90 SWAP1 2815 03 SUB 2816 60 PUSH1 0x64 2818 01 ADD 2819 90 SWAP1 281A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @27F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @27F9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2800 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @280F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229b99 * (0x01 << 0xe9) // @281A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_281B: // Incoming jump from 0x27E2, if stack[-1] == stack[-2] // Inputs[7] // { // @2825 stack[-10] // @2835 memory[0x00:0x40] // @2836 stack[-2] // @283A stack[-9] // @283E memory[0x00:0x40] // @283F stack[-1] // @2845 stack[-5] // } 281B 5B JUMPDEST 281C 60 PUSH1 0x01 281E 60 PUSH1 0x01 2820 60 PUSH1 0xa0 2822 1B SHL 2823 03 SUB 2824 80 DUP1 2825 8B DUP12 2826 16 AND 2827 60 PUSH1 0x00 2829 90 SWAP1 282A 81 DUP2 282B 52 MSTORE 282C 60 PUSH1 0x0d 282E 60 PUSH1 0x20 2830 52 MSTORE 2831 60 PUSH1 0x40 2833 80 DUP1 2834 82 DUP3 2835 20 SHA3 2836 85 DUP6 2837 90 SWAP1 2838 55 SSTORE 2839 91 SWAP2 283A 8B DUP12 283B 16 AND 283C 81 DUP2 283D 52 MSTORE 283E 20 SHA3 283F 81 DUP2 2840 90 SWAP1 2841 55 SSTORE 2842 60 PUSH1 0x00 2844 19 NOT 2845 85 DUP6 2846 14 EQ 2847 61 PUSH2 0x2873 284A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @282B memory[0x00:0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @2830 memory[0x20:0x40] = 0x0d // @2838 storage[keccak256(memory[0x00:0x40])] = stack[-2] // @283D memory[0x00:0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @2841 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with conditional jump to 0x2873, if stack[-5] == ~0x00 label_284B: // Incoming jump from 0x284A, if not stack[-5] == ~0x00 // Inputs[13] // { // @2854 stack[-10] // @2866 memory[0x00:0x40] // @2868 stack[-11] // @286F memory[0x00:0x40] // @2870 stack[-3] // @2874 stack[-9] // @288B memory[0x00:0x20] // @2894 memory[0x00:0x20] // @2897 stack[-8] // @289A memory[0x40:0x60] // @28A7 memory[0x40:0x60] // @28AC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @28B0 stack[-12] // } 284B 60 PUSH1 0x01 284D 60 PUSH1 0x01 284F 60 PUSH1 0xa0 2851 1B SHL 2852 03 SUB 2853 80 DUP1 2854 8B DUP12 2855 16 AND 2856 60 PUSH1 0x00 2858 90 SWAP1 2859 81 DUP2 285A 52 MSTORE 285B 60 PUSH1 0x0e 285D 60 PUSH1 0x20 285F 90 SWAP1 2860 81 DUP2 2861 52 MSTORE 2862 60 PUSH1 0x40 2864 80 DUP1 2865 83 DUP4 2866 20 SHA3 2867 93 SWAP4 2868 8F DUP16 2869 16 AND 286A 83 DUP4 286B 52 MSTORE 286C 92 SWAP3 286D 90 SWAP1 286E 52 MSTORE 286F 20 SHA3 2870 83 DUP4 2871 90 SWAP1 2872 55 SSTORE 2873 5B JUMPDEST 2874 88 DUP9 2875 60 PUSH1 0x01 2877 60 PUSH1 0x01 2879 60 PUSH1 0xa0 287B 1B SHL 287C 03 SUB 287D 16 AND 287E 8A DUP11 287F 60 PUSH1 0x01 2881 60 PUSH1 0x01 2883 60 PUSH1 0xa0 2885 1B SHL 2886 03 SUB 2887 16 AND 2888 60 PUSH1 0x00 288A 80 DUP1 288B 51 MLOAD 288C 60 PUSH1 0x20 288E 61 PUSH2 0x54d1 2891 83 DUP4 2892 39 CODECOPY 2893 81 DUP2 2894 51 MLOAD 2895 91 SWAP2 2896 52 MSTORE 2897 8A DUP11 2898 60 PUSH1 0x40 289A 51 MLOAD 289B 80 DUP1 289C 82 DUP3 289D 81 DUP2 289E 52 MSTORE 289F 60 PUSH1 0x20 28A1 01 ADD 28A2 91 SWAP2 28A3 50 POP 28A4 50 POP 28A5 60 PUSH1 0x40 28A7 51 MLOAD 28A8 80 DUP1 28A9 91 SWAP2 28AA 03 SUB 28AB 90 SWAP1 28AC A3 LOG3 28AD 50 POP 28AE 60 PUSH1 0x00 28B0 9A SWAP11 28B1 99 SWAP10 28B2 50 POP 28B3 50 POP 28B4 50 POP 28B5 50 POP 28B6 50 POP 28B7 50 POP 28B8 50 POP 28B9 50 POP 28BA 50 POP 28BB 50 POP 28BC 56 *JUMP // Stack delta = -11 // Outputs[10] // { // @285A memory[0x00:0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @2861 memory[0x20:0x40] = 0x0e // @286B memory[0x00:0x20] = stack[-11] & (0x01 << 0xa0) - 0x01 // @286E memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2872 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @2892 memory[0x00:0x20] = code[0x54d1:0x54f1] // @2896 memory[0x00:0x20] = memory[0x00:0x20] // @289E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-8] // @28AC log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [memory[0x00:0x20], stack[-10] & (0x01 << 0xa0) - 0x01, stack[-9] & (0x01 << 0xa0) - 0x01]); // @28B0 stack[-12] = 0x00 // } // Block ends with unconditional jump to stack[-12] label_28BD: // Incoming call from 0x14B7, returns to 0x12CF // Incoming call from 0x18A9, returns to 0x18AA // Inputs[1] { @28C1 storage[0x00] } 28BD 5B JUMPDEST 28BE 60 PUSH1 0x00 28C0 80 DUP1 28C1 54 SLOAD 28C2 62 PUSH3 0x010000 28C6 90 SWAP1 28C7 04 DIV 28C8 60 PUSH1 0xff 28CA 16 AND 28CB 61 PUSH2 0x2907 28CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28BE stack[0] = 0x00 } // Block ends with conditional jump to 0x2907, if 0xff & storage[0x00] / 0x010000 label_28CF: // Incoming jump from 0x28CE, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @28D2 memory[0x40:0x60] // @28FD memory[0x40:0x60] // @2906 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 28CF 60 PUSH1 0x40 28D1 80 DUP1 28D2 51 MLOAD 28D3 60 PUSH1 0x01 28D5 60 PUSH1 0xe5 28D7 1B SHL 28D8 62 PUSH3 0x461bcd 28DC 02 MUL 28DD 81 DUP2 28DE 52 MSTORE 28DF 60 PUSH1 0x20 28E1 60 PUSH1 0x04 28E3 82 DUP3 28E4 01 ADD 28E5 52 MSTORE 28E6 60 PUSH1 0x03 28E8 60 PUSH1 0x24 28EA 82 DUP3 28EB 01 ADD 28EC 52 MSTORE 28ED 60 PUSH1 0x01 28EF 60 PUSH1 0xe8 28F1 1B SHL 28F2 62 PUSH3 0x453637 28F6 02 MUL 28F7 60 PUSH1 0x44 28F9 82 DUP3 28FA 01 ADD 28FB 52 MSTORE 28FC 90 SWAP1 28FD 51 MLOAD 28FE 90 SWAP1 28FF 81 DUP2 2900 90 SWAP1 2901 03 SUB 2902 60 PUSH1 0x64 2904 01 ADD 2905 90 SWAP1 2906 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @28DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @28E5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @28EC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @28FB memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @2906 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2907: // Incoming jump from 0x28CE, if 0xff & storage[0x00] / 0x010000 // Inputs[2] // { // @290B storage[0x00] // @2914 stack[-2] // } 2907 5B JUMPDEST 2908 60 PUSH1 0x00 290A 80 DUP1 290B 54 SLOAD 290C 62 PUSH3 0xff0000 2910 19 NOT 2911 16 AND 2912 90 SWAP1 2913 55 SSTORE 2914 81 DUP2 2915 61 PUSH2 0x2951 2918 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2913 storage[0x00] = ~0xff0000 & storage[0x00] } // Block ends with conditional jump to 0x2951, if stack[-2] label_2919: // Incoming jump from 0x2918, if not stack[-2] // Inputs[3] // { // @291C memory[0x40:0x60] // @2947 memory[0x40:0x60] // @2950 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2919 60 PUSH1 0x40 291B 80 DUP1 291C 51 MLOAD 291D 60 PUSH1 0x01 291F 60 PUSH1 0xe5 2921 1B SHL 2922 62 PUSH3 0x461bcd 2926 02 MUL 2927 81 DUP2 2928 52 MSTORE 2929 60 PUSH1 0x20 292B 60 PUSH1 0x04 292D 82 DUP3 292E 01 ADD 292F 52 MSTORE 2930 60 PUSH1 0x03 2932 60 PUSH1 0x24 2934 82 DUP3 2935 01 ADD 2936 52 MSTORE 2937 60 PUSH1 0x01 2939 60 PUSH1 0xea 293B 1B SHL 293C 62 PUSH3 0x114ccd 2940 02 MUL 2941 60 PUSH1 0x44 2943 82 DUP3 2944 01 ADD 2945 52 MSTORE 2946 90 SWAP1 2947 51 MLOAD 2948 90 SWAP1 2949 81 DUP2 294A 90 SWAP1 294B 03 SUB 294C 60 PUSH1 0x64 294E 01 ADD 294F 90 SWAP1 2950 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2928 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @292F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2936 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2945 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x114ccd * (0x01 << 0xea) // @2950 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2951: // Incoming jump from 0x2918, if stack[-2] 2951 5B JUMPDEST 2952 61 PUSH2 0x2959 2955 61 PUSH2 0x536a 2958 56 *JUMP // Stack delta = +1 // Outputs[1] { @2952 stack[0] = 0x2959 } // Block ends with call to 0x536a, returns to 0x2959 label_2959: // Incoming return from call to 0x536A at 0x2958 2959 5B JUMPDEST 295A 61 PUSH2 0x2961 295D 61 PUSH2 0x23f6 2960 56 *JUMP // Stack delta = +1 // Outputs[1] { @295A stack[0] = 0x2961 } // Block ends with call to 0x23f6, returns to 0x2961 label_2961: // Incoming return from call to 0x23F6 at 0x2960 // Inputs[3] // { // @2964 stack[-3] // @2966 stack[-1] // @296D stack[-2] // } 2961 5B JUMPDEST 2962 60 PUSH1 0x40 2964 83 DUP4 2965 01 ADD 2966 81 DUP2 2967 90 SWAP1 2968 52 MSTORE 2969 60 PUSH1 0x20 296B 83 DUP4 296C 01 ADD 296D 82 DUP3 296E 60 PUSH1 0x03 2970 81 DUP2 2971 11 GT 2972 15 ISZERO 2973 61 PUSH2 0x2978 2976 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2968 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] = stack[-1] // @296C stack[0] = stack[-3] + 0x20 // @296D stack[1] = stack[-2] // } // Block ends with conditional jump to 0x2978, if !(stack[-2] > 0x03) label_2977: // Incoming jump from 0x2976, if not !(stack[-2] > 0x03) 2977 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2977 assert(); } // Block terminates label_2978: // Incoming jump from 0x2976, if !(stack[-2] > 0x03) // Inputs[1] { @297B stack[-1] } 2978 5B JUMPDEST 2979 60 PUSH1 0x03 297B 81 DUP2 297C 11 GT 297D 15 ISZERO 297E 61 PUSH2 0x2983 2981 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2983, if !(stack[-1] > 0x03) label_2982: // Incoming jump from 0x2981, if not !(stack[-1] > 0x03) 2982 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2982 assert(); } // Block terminates label_2983: // Incoming jump from 0x2981, if !(stack[-1] > 0x03) // Inputs[5] // { // @2984 stack[-1] // @2984 stack[-2] // @2989 stack[-4] // @298B stack[-5] // @298F memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } 2983 5B JUMPDEST 2984 90 SWAP1 2985 52 MSTORE 2986 50 POP 2987 60 PUSH1 0x00 2989 90 SWAP1 298A 50 POP 298B 81 DUP2 298C 60 PUSH1 0x20 298E 01 ADD 298F 51 MLOAD 2990 60 PUSH1 0x03 2992 81 DUP2 2993 11 GT 2994 15 ISZERO 2995 61 PUSH2 0x299a 2998 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @2985 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2989 stack[-4] = 0x00 // @298F stack[-3] = memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } // Block ends with conditional jump to 0x299a, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) label_2999: // Incoming jump from 0x2998, if not !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) 2999 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2999 assert(); } // Block terminates label_299A: // Incoming jump from 0x2998, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @299B stack[-2] // @299B stack[-1] // } 299A 5B JUMPDEST 299B 14 EQ 299C 61 PUSH2 0x29d8 299F 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x29d8, if stack[-1] == stack[-2] label_29A0: // Incoming jump from 0x299F, if not stack[-1] == stack[-2] // Inputs[3] // { // @29A3 memory[0x40:0x60] // @29CE memory[0x40:0x60] // @29D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 29A0 60 PUSH1 0x40 29A2 80 DUP1 29A3 51 MLOAD 29A4 60 PUSH1 0x01 29A6 60 PUSH1 0xe5 29A8 1B SHL 29A9 62 PUSH3 0x461bcd 29AD 02 MUL 29AE 81 DUP2 29AF 52 MSTORE 29B0 60 PUSH1 0x20 29B2 60 PUSH1 0x04 29B4 82 DUP3 29B5 01 ADD 29B6 52 MSTORE 29B7 60 PUSH1 0x03 29B9 60 PUSH1 0x24 29BB 82 DUP3 29BC 01 ADD 29BD 52 MSTORE 29BE 60 PUSH1 0x01 29C0 60 PUSH1 0xe8 29C2 1B SHL 29C3 62 PUSH3 0x453335 29C7 02 MUL 29C8 60 PUSH1 0x44 29CA 82 DUP3 29CB 01 ADD 29CC 52 MSTORE 29CD 90 SWAP1 29CE 51 MLOAD 29CF 90 SWAP1 29D0 81 DUP2 29D1 90 SWAP1 29D2 03 SUB 29D3 60 PUSH1 0x64 29D5 01 ADD 29D6 90 SWAP1 29D7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @29AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @29B6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @29BD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @29CC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453335 * (0x01 << 0xe8) // @29D7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_29D8: // Incoming jump from 0x299F, if stack[-1] == stack[-2] // Inputs[6] // { // @29DC memory[0x40:0x60] // @29E4 stack[-1] // @29E7 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @29F2 stack[-4] // @2A00 memory[0x00:0x40] // @2A01 storage[keccak256(memory[0x00:0x40])] // } 29D8 5B JUMPDEST 29D9 60 PUSH1 0x40 29DB 80 DUP1 29DC 51 MLOAD 29DD 60 PUSH1 0x20 29DF 80 DUP1 29E0 82 DUP3 29E1 01 ADD 29E2 83 DUP4 29E3 52 MSTORE 29E4 83 DUP4 29E5 83 DUP4 29E6 01 ADD 29E7 51 MLOAD 29E8 82 DUP3 29E9 52 MSTORE 29EA 60 PUSH1 0x01 29EC 60 PUSH1 0x01 29EE 60 PUSH1 0xa0 29F0 1B SHL 29F1 03 SUB 29F2 87 DUP8 29F3 16 AND 29F4 60 PUSH1 0x00 29F6 90 SWAP1 29F7 81 DUP2 29F8 52 MSTORE 29F9 60 PUSH1 0x0d 29FB 90 SWAP1 29FC 91 SWAP2 29FD 52 MSTORE 29FE 91 SWAP2 29FF 82 DUP3 2A00 20 SHA3 2A01 54 SLOAD 2A02 82 DUP3 2A03 91 SWAP2 2A04 61 PUSH2 0x2a0c 2A07 91 SWAP2 2A08 61 PUSH2 0x3057 2A0B 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @29E3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @29E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @29F8 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @29FD memory[0x20:0x40] = 0x0d // @29FE stack[0] = 0x00 // @2A03 stack[1] = 0x00 // @2A03 stack[3] = memory[0x40:0x60] // @2A07 stack[2] = 0x2a0c // @2A07 stack[4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x3057, returns to 0x2A0C label_2A0C: // Incoming return from call to 0x3057 at 0x2A0B // Inputs[4] // { // @2A0D stack[-2] // @2A0D stack[-1] // @2A0E stack[-4] // @2A10 stack[-3] // } 2A0C 5B JUMPDEST 2A0D 90 SWAP1 2A0E 92 SWAP3 2A0F 50 POP 2A10 90 SWAP1 2A11 50 POP 2A12 60 PUSH1 0x00 2A14 82 DUP3 2A15 60 PUSH1 0x03 2A17 81 DUP2 2A18 11 GT 2A19 15 ISZERO 2A1A 61 PUSH2 0x2a1f 2A1D 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @2A0E stack[-4] = stack[-2] // @2A10 stack[-3] = stack[-1] // @2A12 stack[-2] = 0x00 // @2A14 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x2a1f, if !(stack[-2] > 0x03) label_2A1E: // Incoming jump from 0x2A1D, if not !(stack[-2] > 0x03) 2A1E FE *ASSERT // Stack delta = +0 // Outputs[1] { @2A1E assert(); } // Block terminates label_2A1F: // Incoming jump from 0x2A1D, if !(stack[-2] > 0x03) // Inputs[2] // { // @2A20 stack[-2] // @2A20 stack[-1] // } 2A1F 5B JUMPDEST 2A20 14 EQ 2A21 61 PUSH2 0x2a5d 2A24 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2a5d, if stack[-1] == stack[-2] label_2A25: // Incoming jump from 0x2A24, if not stack[-1] == stack[-2] // Inputs[3] // { // @2A28 memory[0x40:0x60] // @2A53 memory[0x40:0x60] // @2A5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2A25 60 PUSH1 0x40 2A27 80 DUP1 2A28 51 MLOAD 2A29 60 PUSH1 0x01 2A2B 60 PUSH1 0xe5 2A2D 1B SHL 2A2E 62 PUSH3 0x461bcd 2A32 02 MUL 2A33 81 DUP2 2A34 52 MSTORE 2A35 60 PUSH1 0x20 2A37 60 PUSH1 0x04 2A39 82 DUP3 2A3A 01 ADD 2A3B 52 MSTORE 2A3C 60 PUSH1 0x03 2A3E 60 PUSH1 0x24 2A40 82 DUP3 2A41 01 ADD 2A42 52 MSTORE 2A43 60 PUSH1 0x01 2A45 60 PUSH1 0xe9 2A47 1B SHL 2A48 62 PUSH3 0x22999b 2A4C 02 MUL 2A4D 60 PUSH1 0x44 2A4F 82 DUP3 2A50 01 ADD 2A51 52 MSTORE 2A52 90 SWAP1 2A53 51 MLOAD 2A54 90 SWAP1 2A55 81 DUP2 2A56 90 SWAP1 2A57 03 SUB 2A58 60 PUSH1 0x64 2A5A 01 ADD 2A5B 90 SWAP1 2A5C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2A34 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2A3B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2A42 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2A51 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x22999b * (0x01 << 0xe9) // @2A5C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2A5D: // Incoming jump from 0x2A24, if stack[-1] == stack[-2] // Inputs[1] { @2A61 stack[-5] } 2A5D 5B JUMPDEST 2A5E 60 PUSH1 0x00 2A60 19 NOT 2A61 85 DUP6 2A62 14 EQ 2A63 15 ISZERO 2A64 61 PUSH2 0x2a91 2A67 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2a91, if !(stack[-5] == ~0x00) label_2A68: // Incoming jump from 0x2A67, if not !(stack[-5] == ~0x00) // Inputs[5] // { // @2A6A stack[-3] // @2A6C stack[-1] // @2A77 stack[-6] // @2A86 memory[0x00:0x40] // @2A87 storage[keccak256(memory[0x00:0x40])] // } 2A68 60 PUSH1 0xa0 2A6A 83 DUP4 2A6B 01 ADD 2A6C 81 DUP2 2A6D 90 SWAP1 2A6E 52 MSTORE 2A6F 60 PUSH1 0x01 2A71 60 PUSH1 0x01 2A73 60 PUSH1 0xa0 2A75 1B SHL 2A76 03 SUB 2A77 86 DUP7 2A78 16 AND 2A79 60 PUSH1 0x00 2A7B 90 SWAP1 2A7C 81 DUP2 2A7D 52 MSTORE 2A7E 60 PUSH1 0x0d 2A80 60 PUSH1 0x20 2A82 52 MSTORE 2A83 60 PUSH1 0x40 2A85 90 SWAP1 2A86 20 SHA3 2A87 54 SLOAD 2A88 60 PUSH1 0x80 2A8A 84 DUP5 2A8B 01 ADD 2A8C 52 MSTORE 2A8D 61 PUSH2 0x2b2a 2A90 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2A6E memory[stack[-3] + 0xa0:stack[-3] + 0xa0 + 0x20] = stack[-1] // @2A7D memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2A82 memory[0x20:0x40] = 0x0d // @2A8C memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x2b2a label_2A91: // Incoming jump from 0x2A67, if !(stack[-5] == ~0x00) // Inputs[4] // { // @2A94 stack[-3] // @2A96 stack[-5] // @2A9C memory[0x40:0x60] // @2AA6 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } 2A91 5B JUMPDEST 2A92 60 PUSH1 0xa0 2A94 83 DUP4 2A95 01 ADD 2A96 85 DUP6 2A97 90 SWAP1 2A98 52 MSTORE 2A99 60 PUSH1 0x40 2A9B 80 DUP1 2A9C 51 MLOAD 2A9D 60 PUSH1 0x20 2A9F 81 DUP2 2AA0 01 ADD 2AA1 82 DUP3 2AA2 52 MSTORE 2AA3 90 SWAP1 2AA4 84 DUP5 2AA5 01 ADD 2AA6 51 MLOAD 2AA7 81 DUP2 2AA8 52 MSTORE 2AA9 61 PUSH2 0x2ab3 2AAC 90 SWAP1 2AAD 86 DUP7 2AAE 90 SWAP1 2AAF 61 PUSH2 0x2532 2AB2 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @2A98 memory[stack[-3] + 0xa0:stack[-3] + 0xa0 + 0x20] = stack[-5] // @2AA2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @2AA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @2AAC stack[0] = 0x2ab3 // @2AAE stack[1] = stack[-5] // @2AAE stack[2] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2532 2AB3 5B JUMPDEST 2AB4 60 PUSH1 0x80 2AB6 85 DUP6 2AB7 01 ADD 2AB8 81 DUP2 2AB9 90 SWAP1 2ABA 52 MSTORE 2ABB 60 PUSH1 0x20 2ABD 85 DUP6 2ABE 01 ADD 2ABF 82 DUP3 2AC0 60 PUSH1 0x03 2AC2 81 DUP2 2AC3 11 GT 2AC4 15 ISZERO 2AC5 61 PUSH2 0x2aca 2AC8 57 *JUMPI 2AC9 FE *ASSERT 2ACA 5B JUMPDEST 2ACB 60 PUSH1 0x03 2ACD 81 DUP2 2ACE 11 GT 2ACF 15 ISZERO 2AD0 61 PUSH2 0x2ad5 2AD3 57 *JUMPI 2AD4 FE *ASSERT 2AD5 5B JUMPDEST 2AD6 90 SWAP1 2AD7 52 MSTORE 2AD8 50 POP 2AD9 60 PUSH1 0x00 2ADB 90 SWAP1 2ADC 50 POP 2ADD 83 DUP4 2ADE 60 PUSH1 0x20 2AE0 01 ADD 2AE1 51 MLOAD 2AE2 60 PUSH1 0x03 2AE4 81 DUP2 2AE5 11 GT 2AE6 15 ISZERO 2AE7 61 PUSH2 0x2aec 2AEA 57 *JUMPI 2AEB FE *ASSERT 2AEC 5B JUMPDEST 2AED 14 EQ 2AEE 61 PUSH2 0x2b2a 2AF1 57 *JUMPI 2AF2 60 PUSH1 0x40 2AF4 80 DUP1 2AF5 51 MLOAD 2AF6 60 PUSH1 0x01 2AF8 60 PUSH1 0xe5 2AFA 1B SHL 2AFB 62 PUSH3 0x461bcd 2AFF 02 MUL 2B00 81 DUP2 2B01 52 MSTORE 2B02 60 PUSH1 0x20 2B04 60 PUSH1 0x04 2B06 82 DUP3 2B07 01 ADD 2B08 52 MSTORE 2B09 60 PUSH1 0x03 2B0B 60 PUSH1 0x24 2B0D 82 DUP3 2B0E 01 ADD 2B0F 52 MSTORE 2B10 60 PUSH1 0x01 2B12 60 PUSH1 0xe8 2B14 1B SHL 2B15 62 PUSH3 0x453337 2B19 02 MUL 2B1A 60 PUSH1 0x44 2B1C 82 DUP3 2B1D 01 ADD 2B1E 52 MSTORE 2B1F 90 SWAP1 2B20 51 MLOAD 2B21 90 SWAP1 2B22 81 DUP2 2B23 90 SWAP1 2B24 03 SUB 2B25 60 PUSH1 0x64 2B27 01 ADD 2B28 90 SWAP1 2B29 FD *REVERT label_2B2A: // Incoming jump from 0x2A90 // Inputs[4] // { // @2B33 stack[-6] // @2B42 memory[0x00:0x40] // @2B43 storage[keccak256(memory[0x00:0x40])] // @2B44 stack[-1] // } 2B2A 5B JUMPDEST 2B2B 60 PUSH1 0x01 2B2D 60 PUSH1 0x01 2B2F 60 PUSH1 0xa0 2B31 1B SHL 2B32 03 SUB 2B33 86 DUP7 2B34 16 AND 2B35 60 PUSH1 0x00 2B37 90 SWAP1 2B38 81 DUP2 2B39 52 MSTORE 2B3A 60 PUSH1 0x0f 2B3C 60 PUSH1 0x20 2B3E 52 MSTORE 2B3F 60 PUSH1 0x40 2B41 90 SWAP1 2B42 20 SHA3 2B43 54 SLOAD 2B44 81 DUP2 2B45 11 GT 2B46 15 ISZERO 2B47 61 PUSH2 0x2beb 2B4A 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2B39 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2B3E memory[0x20:0x40] = 0x0f // } // Block ends with conditional jump to 0x2beb, if !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) label_2B4B: // Incoming jump from 0x2B4A, if not !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[4] // { // @2B53 stack[-6] // @2B62 memory[0x00:0x40] // @2B63 storage[keccak256(memory[0x00:0x40])] // @2B68 stack[-1] // } 2B4B 60 PUSH1 0x01 2B4D 60 PUSH1 0x01 2B4F 60 PUSH1 0xa0 2B51 1B SHL 2B52 03 SUB 2B53 86 DUP7 2B54 16 AND 2B55 60 PUSH1 0x00 2B57 90 SWAP1 2B58 81 DUP2 2B59 52 MSTORE 2B5A 60 PUSH1 0x0f 2B5C 60 PUSH1 0x20 2B5E 52 MSTORE 2B5F 60 PUSH1 0x40 2B61 90 SWAP1 2B62 20 SHA3 2B63 54 SLOAD 2B64 61 PUSH2 0x2b6e 2B67 90 SWAP1 2B68 82 DUP3 2B69 90 SWAP1 2B6A 61 PUSH2 0x33c0 2B6D 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2B59 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2B5E memory[0x20:0x40] = 0x0f // @2B67 stack[0] = 0x2b6e // @2B69 stack[1] = stack[-1] // @2B69 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x33c0, returns to 0x2B6E label_2B6E: // Incoming return from call to 0x33C0 at 0x2B6D // Inputs[3] // { // @2B72 stack[-5] // @2B74 stack[-1] // @2B7B stack[-2] // } 2B6E 5B JUMPDEST 2B6F 61 PUSH2 0x0120 2B72 85 DUP6 2B73 01 ADD 2B74 81 DUP2 2B75 90 SWAP1 2B76 52 MSTORE 2B77 60 PUSH1 0x20 2B79 85 DUP6 2B7A 01 ADD 2B7B 82 DUP3 2B7C 60 PUSH1 0x03 2B7E 81 DUP2 2B7F 11 GT 2B80 15 ISZERO 2B81 61 PUSH2 0x2b86 2B84 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2B76 memory[stack[-5] + 0x0120:stack[-5] + 0x0120 + 0x20] = stack[-1] // @2B7A stack[0] = stack[-5] + 0x20 // @2B7B stack[1] = stack[-2] // } // Block ends with conditional jump to 0x2b86, if !(stack[-2] > 0x03) label_2B85: // Incoming jump from 0x2B84, if not !(stack[-2] > 0x03) 2B85 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2B85 assert(); } // Block terminates label_2B86: // Incoming jump from 0x2B84, if !(stack[-2] > 0x03) // Inputs[1] { @2B89 stack[-1] } 2B86 5B JUMPDEST 2B87 60 PUSH1 0x03 2B89 81 DUP2 2B8A 11 GT 2B8B 15 ISZERO 2B8C 61 PUSH2 0x2b91 2B8F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2b91, if !(stack[-1] > 0x03) label_2B90: // Incoming jump from 0x2B8F, if not !(stack[-1] > 0x03) 2B90 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2B90 assert(); } // Block terminates label_2B91: // Incoming jump from 0x2B8F, if !(stack[-1] > 0x03) // Inputs[5] // { // @2B92 stack[-2] // @2B92 stack[-1] // @2B97 stack[-4] // @2B99 stack[-7] // @2B9D memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } 2B91 5B JUMPDEST 2B92 90 SWAP1 2B93 52 MSTORE 2B94 50 POP 2B95 60 PUSH1 0x00 2B97 90 SWAP1 2B98 50 POP 2B99 83 DUP4 2B9A 60 PUSH1 0x20 2B9C 01 ADD 2B9D 51 MLOAD 2B9E 60 PUSH1 0x03 2BA0 81 DUP2 2BA1 11 GT 2BA2 15 ISZERO 2BA3 61 PUSH2 0x2ba8 2BA6 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @2B93 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2B97 stack[-4] = 0x00 // @2B9D stack[-3] = memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } // Block ends with conditional jump to 0x2ba8, if !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) label_2BA7: // Incoming jump from 0x2BA6, if not !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) 2BA7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2BA7 assert(); } // Block terminates label_2BA8: // Incoming jump from 0x2BA6, if !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) // Inputs[2] // { // @2BA9 stack[-1] // @2BA9 stack[-2] // } 2BA8 5B JUMPDEST 2BA9 14 EQ 2BAA 61 PUSH2 0x2be6 2BAD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2be6, if stack[-1] == stack[-2] label_2BAE: // Incoming jump from 0x2BAD, if not stack[-1] == stack[-2] // Inputs[3] // { // @2BB1 memory[0x40:0x60] // @2BDC memory[0x40:0x60] // @2BE5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2BAE 60 PUSH1 0x40 2BB0 80 DUP1 2BB1 51 MLOAD 2BB2 60 PUSH1 0x01 2BB4 60 PUSH1 0xe5 2BB6 1B SHL 2BB7 62 PUSH3 0x461bcd 2BBB 02 MUL 2BBC 81 DUP2 2BBD 52 MSTORE 2BBE 60 PUSH1 0x20 2BC0 60 PUSH1 0x04 2BC2 82 DUP3 2BC3 01 ADD 2BC4 52 MSTORE 2BC5 60 PUSH1 0x03 2BC7 60 PUSH1 0x24 2BC9 82 DUP3 2BCA 01 ADD 2BCB 52 MSTORE 2BCC 60 PUSH1 0x01 2BCE 60 PUSH1 0xeb 2BD0 1B SHL 2BD1 62 PUSH3 0x08a667 2BD5 02 MUL 2BD6 60 PUSH1 0x44 2BD8 82 DUP3 2BD9 01 ADD 2BDA 52 MSTORE 2BDB 90 SWAP1 2BDC 51 MLOAD 2BDD 90 SWAP1 2BDE 81 DUP2 2BDF 90 SWAP1 2BE0 03 SUB 2BE1 60 PUSH1 0x64 2BE3 01 ADD 2BE4 90 SWAP1 2BE5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2BBD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2BC4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2BCB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2BDA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x08a667 * (0x01 << 0xeb) // @2BE5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2BE6: // Incoming jump from 0x2BAD, if stack[-1] == stack[-2] 2BE6 5B JUMPDEST 2BE7 61 PUSH2 0x2bf4 2BEA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2bf4 label_2BEB: // Incoming jump from 0x2B4A, if !(stack[-1] > storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @2BF1 stack[-3] // @2BFA memory[0x0120 + stack[-3]:0x0120 + stack[-3] + 0x20] // @2BFF memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] // } 2BEB 5B JUMPDEST 2BEC 60 PUSH1 0x00 2BEE 61 PUSH2 0x0120 2BF1 84 DUP5 2BF2 01 ADD 2BF3 52 MSTORE 2BF4 5B JUMPDEST 2BF5 82 DUP3 2BF6 61 PUSH2 0x0120 2BF9 01 ADD 2BFA 51 MLOAD 2BFB 83 DUP4 2BFC 60 PUSH1 0xa0 2BFE 01 ADD 2BFF 51 MLOAD 2C00 10 LT 2C01 61 PUSH2 0x2cff 2C04 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2BF3 memory[stack[-3] + 0x0120:stack[-3] + 0x0120 + 0x20] = 0x00 } // Block ends with conditional jump to 0x2cff, if memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] < memory[0x0120 + stack[-3]:0x0120 + stack[-3] + 0x20] label_2C05: // Incoming jump from 0x2C04, if not memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] < memory[0x0120 + stack[-3]:0x0120 + stack[-3] + 0x20] // Incoming jump from 0x2C04, if not memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] < memory[0x0120 + stack[-3]:0x0120 + stack[-3] + 0x20] // Inputs[3] // { // @2C08 stack[-3] // @2C0C memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] // @2C12 memory[0x0120 + stack[-3]:0x0120 + stack[-3] + 0x20] // } 2C05 61 PUSH2 0x2c17 2C08 83 DUP4 2C09 60 PUSH1 0xa0 2C0B 01 ADD 2C0C 51 MLOAD 2C0D 84 DUP5 2C0E 61 PUSH2 0x0120 2C11 01 ADD 2C12 51 MLOAD 2C13 61 PUSH2 0x33c0 2C16 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C05 stack[0] = 0x2c17 // @2C0C stack[1] = memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] // @2C12 stack[2] = memory[0x0120 + stack[-3]:0x0120 + stack[-3] + 0x20] // } // Block ends with call to 0x33c0, returns to 0x2C17 label_2C17: // Incoming return from call to 0x33C0 at 0x2C16 // Inputs[3] // { // @2C1B stack[-5] // @2C1D stack[-1] // @2C24 stack[-2] // } 2C17 5B JUMPDEST 2C18 61 PUSH2 0x0140 2C1B 85 DUP6 2C1C 01 ADD 2C1D 81 DUP2 2C1E 90 SWAP1 2C1F 52 MSTORE 2C20 60 PUSH1 0x20 2C22 85 DUP6 2C23 01 ADD 2C24 82 DUP3 2C25 60 PUSH1 0x03 2C27 81 DUP2 2C28 11 GT 2C29 15 ISZERO 2C2A 61 PUSH2 0x2c2f 2C2D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2C1F memory[stack[-5] + 0x0140:stack[-5] + 0x0140 + 0x20] = stack[-1] // @2C23 stack[0] = stack[-5] + 0x20 // @2C24 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x2c2f, if !(stack[-2] > 0x03) label_2C2E: // Incoming jump from 0x2C2D, if not !(stack[-2] > 0x03) 2C2E FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C2E assert(); } // Block terminates label_2C2F: // Incoming jump from 0x2C2D, if !(stack[-2] > 0x03) // Inputs[1] { @2C32 stack[-1] } 2C2F 5B JUMPDEST 2C30 60 PUSH1 0x03 2C32 81 DUP2 2C33 11 GT 2C34 15 ISZERO 2C35 61 PUSH2 0x2c3a 2C38 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2c3a, if !(stack[-1] > 0x03) label_2C39: // Incoming jump from 0x2C38, if not !(stack[-1] > 0x03) 2C39 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C39 assert(); } // Block terminates label_2C3A: // Incoming jump from 0x2C38, if !(stack[-1] > 0x03) // Inputs[7] // { // @2C3B stack[-1] // @2C3B stack[-2] // @2C47 stack[-10] // @2C56 memory[0x00:0x40] // @2C57 storage[keccak256(memory[0x00:0x40])] // @2C5B stack[-7] // @2C5D memory[stack[-7] + 0x0140:stack[-7] + 0x0140 + 0x20] // } 2C3A 5B JUMPDEST 2C3B 90 SWAP1 2C3C 52 MSTORE 2C3D 50 POP 2C3E 50 POP 2C3F 60 PUSH1 0x01 2C41 60 PUSH1 0x01 2C43 60 PUSH1 0xa0 2C45 1B SHL 2C46 03 SUB 2C47 86 DUP7 2C48 16 AND 2C49 60 PUSH1 0x00 2C4B 90 SWAP1 2C4C 81 DUP2 2C4D 52 MSTORE 2C4E 60 PUSH1 0x0f 2C50 60 PUSH1 0x20 2C52 52 MSTORE 2C53 60 PUSH1 0x40 2C55 90 SWAP1 2C56 20 SHA3 2C57 54 SLOAD 2C58 61 PUSH2 0x0140 2C5B 84 DUP5 2C5C 01 ADD 2C5D 51 MLOAD 2C5E 61 PUSH2 0x2c67 2C61 91 SWAP2 2C62 90 SWAP1 2C63 61 PUSH2 0x33c0 2C66 56 *JUMP // Stack delta = -1 // Outputs[6] // { // @2C3C memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2C4D memory[0x00:0x20] = stack[-10] & (0x01 << 0xa0) - 0x01 // @2C52 memory[0x20:0x40] = 0x0f // @2C61 stack[-4] = 0x2c67 // @2C62 stack[-2] = memory[stack[-7] + 0x0140:stack[-7] + 0x0140 + 0x20] // @2C62 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x33c0, returns to 0x2C67 label_2C67: // Incoming return from call to 0x33C0 at 0x2C66 // Inputs[3] // { // @2C6B stack[-5] // @2C6D stack[-1] // @2C74 stack[-2] // } 2C67 5B JUMPDEST 2C68 61 PUSH2 0x0100 2C6B 85 DUP6 2C6C 01 ADD 2C6D 81 DUP2 2C6E 90 SWAP1 2C6F 52 MSTORE 2C70 60 PUSH1 0x20 2C72 85 DUP6 2C73 01 ADD 2C74 82 DUP3 2C75 60 PUSH1 0x03 2C77 81 DUP2 2C78 11 GT 2C79 15 ISZERO 2C7A 61 PUSH2 0x2c7f 2C7D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2C6F memory[stack[-5] + 0x0100:stack[-5] + 0x0100 + 0x20] = stack[-1] // @2C73 stack[0] = stack[-5] + 0x20 // @2C74 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x2c7f, if !(stack[-2] > 0x03) label_2C7E: // Incoming jump from 0x2C7D, if not !(stack[-2] > 0x03) 2C7E FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C7E assert(); } // Block terminates label_2C7F: // Incoming jump from 0x2C7D, if !(stack[-2] > 0x03) // Inputs[1] { @2C82 stack[-1] } 2C7F 5B JUMPDEST 2C80 60 PUSH1 0x03 2C82 81 DUP2 2C83 11 GT 2C84 15 ISZERO 2C85 61 PUSH2 0x2c8a 2C88 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2c8a, if !(stack[-1] > 0x03) label_2C89: // Incoming jump from 0x2C88, if not !(stack[-1] > 0x03) 2C89 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2C89 assert(); } // Block terminates label_2C8A: // Incoming jump from 0x2C88, if !(stack[-1] > 0x03) // Inputs[5] // { // @2C8B stack[-2] // @2C8B stack[-1] // @2C90 stack[-4] // @2C92 stack[-7] // @2C96 memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } 2C8A 5B JUMPDEST 2C8B 90 SWAP1 2C8C 52 MSTORE 2C8D 50 POP 2C8E 60 PUSH1 0x00 2C90 90 SWAP1 2C91 50 POP 2C92 83 DUP4 2C93 60 PUSH1 0x20 2C95 01 ADD 2C96 51 MLOAD 2C97 60 PUSH1 0x03 2C99 81 DUP2 2C9A 11 GT 2C9B 15 ISZERO 2C9C 61 PUSH2 0x2ca1 2C9F 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @2C8C memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2C90 stack[-4] = 0x00 // @2C96 stack[-3] = memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } // Block ends with conditional jump to 0x2ca1, if !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) label_2CA0: // Incoming jump from 0x2C9F, if not !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) 2CA0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2CA0 assert(); } // Block terminates label_2CA1: // Incoming jump from 0x2C9F, if !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) // Inputs[2] // { // @2CA2 stack[-1] // @2CA2 stack[-2] // } 2CA1 5B JUMPDEST 2CA2 14 EQ 2CA3 61 PUSH2 0x2cdf 2CA6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2cdf, if stack[-1] == stack[-2] label_2CA7: // Incoming jump from 0x2CA6, if not stack[-1] == stack[-2] // Inputs[3] // { // @2CAA memory[0x40:0x60] // @2CD5 memory[0x40:0x60] // @2CDE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2CA7 60 PUSH1 0x40 2CA9 80 DUP1 2CAA 51 MLOAD 2CAB 60 PUSH1 0x01 2CAD 60 PUSH1 0xe5 2CAF 1B SHL 2CB0 62 PUSH3 0x461bcd 2CB4 02 MUL 2CB5 81 DUP2 2CB6 52 MSTORE 2CB7 60 PUSH1 0x20 2CB9 60 PUSH1 0x04 2CBB 82 DUP3 2CBC 01 ADD 2CBD 52 MSTORE 2CBE 60 PUSH1 0x03 2CC0 60 PUSH1 0x24 2CC2 82 DUP3 2CC3 01 ADD 2CC4 52 MSTORE 2CC5 60 PUSH1 0x01 2CC7 60 PUSH1 0xe8 2CC9 1B SHL 2CCA 62 PUSH3 0x453339 2CCE 02 MUL 2CCF 60 PUSH1 0x44 2CD1 82 DUP3 2CD2 01 ADD 2CD3 52 MSTORE 2CD4 90 SWAP1 2CD5 51 MLOAD 2CD6 90 SWAP1 2CD7 81 DUP2 2CD8 90 SWAP1 2CD9 03 SUB 2CDA 60 PUSH1 0x64 2CDC 01 ADD 2CDD 90 SWAP1 2CDE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2CB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2CBD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2CC4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2CD3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453339 * (0x01 << 0xe8) // @2CDE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2CDF: // Incoming jump from 0x2CA6, if stack[-1] == stack[-2] // Inputs[4] // { // @2CE3 stack[-3] // @2CE5 memory[stack[-3] + 0x0100:stack[-3] + 0x0100 + 0x20] // @2CEE stack[-6] // @2CFD memory[0x00:0x40] // } 2CDF 5B JUMPDEST 2CE0 61 PUSH2 0x0100 2CE3 83 DUP4 2CE4 01 ADD 2CE5 51 MLOAD 2CE6 60 PUSH1 0x01 2CE8 60 PUSH1 0x01 2CEA 60 PUSH1 0xa0 2CEC 1B SHL 2CED 03 SUB 2CEE 87 DUP8 2CEF 16 AND 2CF0 60 PUSH1 0x00 2CF2 90 SWAP1 2CF3 81 DUP2 2CF4 52 MSTORE 2CF5 60 PUSH1 0x0f 2CF7 60 PUSH1 0x20 2CF9 52 MSTORE 2CFA 60 PUSH1 0x40 2CFC 90 SWAP1 2CFD 20 SHA3 2CFE 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @2CF4 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2CF9 memory[0x20:0x40] = 0x0f // @2CFE storage[keccak256(memory[0x00:0x40])] = memory[stack[-3] + 0x0100:stack[-3] + 0x0100 + 0x20] // } // Block continues label_2CFF: // Incoming jump from 0x2CFE // Incoming jump from 0x2C04, if memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] < memory[0x0120 + stack[-3]:0x0120 + stack[-3] + 0x20] // Incoming jump from 0x2C04, if memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] < memory[0x0120 + stack[-3]:0x0120 + stack[-3] + 0x20] // Inputs[8] // { // @2D03 storage[0x00] // @2D06 stack[-3] // @2D08 memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] // @2D0C memory[0x40:0x60] // @2D1A address(this) // @2D28 stack[-6] // @2D39 memory[0x40:0x60] // @2D61 address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } 2CFF 5B JUMPDEST 2D00 60 PUSH1 0x00 2D02 80 DUP1 2D03 54 SLOAD 2D04 60 PUSH1 0x80 2D06 85 DUP6 2D07 01 ADD 2D08 51 MLOAD 2D09 60 PUSH1 0x40 2D0B 80 DUP1 2D0C 51 MLOAD 2D0D 60 PUSH1 0x01 2D0F 60 PUSH1 0xe0 2D11 1B SHL 2D12 63 PUSH4 0xeabe7d91 2D17 02 MUL 2D18 81 DUP2 2D19 52 MSTORE 2D1A 30 ADDRESS 2D1B 60 PUSH1 0x04 2D1D 82 DUP3 2D1E 01 ADD 2D1F 52 MSTORE 2D20 60 PUSH1 0x01 2D22 60 PUSH1 0x01 2D24 60 PUSH1 0xa0 2D26 1B SHL 2D27 03 SUB 2D28 8B DUP12 2D29 81 DUP2 2D2A 16 AND 2D2B 60 PUSH1 0x24 2D2D 83 DUP4 2D2E 01 ADD 2D2F 52 MSTORE 2D30 60 PUSH1 0x44 2D32 82 DUP3 2D33 01 ADD 2D34 93 SWAP4 2D35 90 SWAP1 2D36 93 SWAP4 2D37 52 MSTORE 2D38 90 SWAP1 2D39 51 MLOAD 2D3A 63 PUSH4 0x01000000 2D3F 90 SWAP1 2D40 93 SWAP4 2D41 04 DIV 2D42 90 SWAP1 2D43 91 SWAP2 2D44 16 AND 2D45 92 SWAP3 2D46 63 PUSH4 0xeabe7d91 2D4B 92 SWAP3 2D4C 60 PUSH1 0x64 2D4E 80 DUP1 2D4F 84 DUP5 2D50 01 ADD 2D51 93 SWAP4 2D52 60 PUSH1 0x20 2D54 93 SWAP4 2D55 90 SWAP1 2D56 83 DUP4 2D57 90 SWAP1 2D58 03 SUB 2D59 90 SWAP1 2D5A 91 SWAP2 2D5B 01 ADD 2D5C 90 SWAP1 2D5D 82 DUP3 2D5E 90 SWAP1 2D5F 87 DUP8 2D60 80 DUP1 2D61 3B EXTCODESIZE 2D62 15 ISZERO 2D63 80 DUP1 2D64 15 ISZERO 2D65 61 PUSH2 0x2d6d 2D68 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @2D19 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xeabe7d91 * (0x01 << 0xe0) // @2D1F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @2D2F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @2D37 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] // @2D45 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @2D4B stack[1] = 0xeabe7d91 // @2D4B stack[4] = memory[0x40:0x60] // @2D51 stack[2] = memory[0x40:0x60] + 0x64 // @2D54 stack[3] = 0x20 // @2D5C stack[5] = 0x64 + (memory[0x40:0x60] - memory[0x40:0x60]) // @2D5E stack[6] = memory[0x40:0x60] // @2D5E stack[7] = 0x00 // @2D5F stack[8] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @2D62 stack[9] = !address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } // Block ends with conditional jump to 0x2d6d, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length label_2D69: // Incoming jump from 0x2D68, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[1] { @2D6C memory[0x00:0x00] } 2D69 60 PUSH1 0x00 2D6B 80 DUP1 2D6C FD *REVERT // Stack delta = +0 // Outputs[1] { @2D6C revert(memory[0x00:0x00]); } // Block terminates label_2D6D: // Incoming jump from 0x2D68, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[9] // { // @2D6F msg.gas // @2D70 stack[-7] // @2D70 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2D70 stack[-4] // @2D70 stack[-2] // @2D70 stack[-3] // @2D70 stack[-6] // @2D70 stack[-5] // @2D70 memory[stack[-4]:stack[-4] + stack[-5]] // } 2D6D 5B JUMPDEST 2D6E 50 POP 2D6F 5A GAS 2D70 F1 CALL 2D71 15 ISZERO 2D72 80 DUP1 2D73 15 ISZERO 2D74 61 PUSH2 0x2d81 2D77 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @2D70 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @2D71 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x2d81, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_2D78: // Incoming jump from 0x2D77, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @2D78 returndata.length // @2D7C returndata[0x00:0x00 + returndata.length] // @2D7D returndata.length // @2D80 memory[0x00:0x00 + returndata.length] // } 2D78 3D RETURNDATASIZE 2D79 60 PUSH1 0x00 2D7B 80 DUP1 2D7C 3E RETURNDATACOPY 2D7D 3D RETURNDATASIZE 2D7E 60 PUSH1 0x00 2D80 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2D7C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2D80 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_2D81: // Incoming jump from 0x2D77, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @2D88 memory[0x40:0x60] // @2D89 returndata.length // } 2D81 5B JUMPDEST 2D82 50 POP 2D83 50 POP 2D84 50 POP 2D85 50 POP 2D86 60 PUSH1 0x40 2D88 51 MLOAD 2D89 3D RETURNDATASIZE 2D8A 60 PUSH1 0x20 2D8C 81 DUP2 2D8D 10 LT 2D8E 15 ISZERO 2D8F 61 PUSH2 0x2d97 2D92 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @2D88 stack[-4] = memory[0x40:0x60] // @2D89 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x2d97, if !(returndata.length < 0x20) label_2D93: // Incoming jump from 0x2D92, if not !(returndata.length < 0x20) // Inputs[1] { @2D96 memory[0x00:0x00] } 2D93 60 PUSH1 0x00 2D95 80 DUP1 2D96 FD *REVERT // Stack delta = +0 // Outputs[1] { @2D96 revert(memory[0x00:0x00]); } // Block terminates label_2D97: // Incoming jump from 0x2D92, if !(returndata.length < 0x20) // Inputs[3] // { // @2D99 memory[stack[-2]:stack[-2] + 0x20] // @2D99 stack[-2] // @2D9C stack[-5] // } 2D97 5B JUMPDEST 2D98 50 POP 2D99 51 MLOAD 2D9A 60 PUSH1 0x60 2D9C 84 DUP5 2D9D 01 ADD 2D9E 81 DUP2 2D9F 90 SWAP1 2DA0 52 MSTORE 2DA1 15 ISZERO 2DA2 61 PUSH2 0x2dde 2DA5 57 *JUMPI // Stack delta = -2 // Outputs[1] { @2DA0 memory[stack[-5] + 0x60:stack[-5] + 0x60 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2dde, if !memory[stack[-2]:stack[-2] + 0x20] label_2DA6: // Incoming jump from 0x2DA5, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @2DA9 memory[0x40:0x60] // @2DD4 memory[0x40:0x60] // @2DDD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2DA6 60 PUSH1 0x40 2DA8 80 DUP1 2DA9 51 MLOAD 2DAA 60 PUSH1 0x01 2DAC 60 PUSH1 0xe5 2DAE 1B SHL 2DAF 62 PUSH3 0x461bcd 2DB3 02 MUL 2DB4 81 DUP2 2DB5 52 MSTORE 2DB6 60 PUSH1 0x20 2DB8 60 PUSH1 0x04 2DBA 82 DUP3 2DBB 01 ADD 2DBC 52 MSTORE 2DBD 60 PUSH1 0x03 2DBF 60 PUSH1 0x24 2DC1 82 DUP3 2DC2 01 ADD 2DC3 52 MSTORE 2DC4 60 PUSH1 0x01 2DC6 60 PUSH1 0xec 2DC8 1B SHL 2DC9 62 PUSH3 0x045343 2DCD 02 MUL 2DCE 60 PUSH1 0x44 2DD0 82 DUP3 2DD1 01 ADD 2DD2 52 MSTORE 2DD3 90 SWAP1 2DD4 51 MLOAD 2DD5 90 SWAP1 2DD6 81 DUP2 2DD7 90 SWAP1 2DD8 03 SUB 2DD9 60 PUSH1 0x64 2DDB 01 ADD 2DDC 90 SWAP1 2DDD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2DB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2DBC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2DC3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2DD2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x045343 * (0x01 << 0xec) // @2DDD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2DDE: // Incoming jump from 0x2DA5, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @2DE4 storage[0x07] // @2DE5 stack[-3] // @2DE9 memory[0x80 + stack[-3]:0x80 + stack[-3] + 0x20] // } 2DDE 5B JUMPDEST 2DDF 61 PUSH2 0x2dee 2DE2 60 PUSH1 0x07 2DE4 54 SLOAD 2DE5 84 DUP5 2DE6 60 PUSH1 0x80 2DE8 01 ADD 2DE9 51 MLOAD 2DEA 61 PUSH2 0x33c0 2DED 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2DDF stack[0] = 0x2dee // @2DE4 stack[1] = storage[0x07] // @2DE9 stack[2] = memory[0x80 + stack[-3]:0x80 + stack[-3] + 0x20] // } // Block ends with call to 0x33c0, returns to 0x2DEE label_2DEE: // Incoming return from call to 0x33C0 at 0x2DED // Inputs[3] // { // @2DF1 stack[-5] // @2DF3 stack[-1] // @2DFA stack[-2] // } 2DEE 5B JUMPDEST 2DEF 60 PUSH1 0xc0 2DF1 85 DUP6 2DF2 01 ADD 2DF3 81 DUP2 2DF4 90 SWAP1 2DF5 52 MSTORE 2DF6 60 PUSH1 0x20 2DF8 85 DUP6 2DF9 01 ADD 2DFA 82 DUP3 2DFB 60 PUSH1 0x03 2DFD 81 DUP2 2DFE 11 GT 2DFF 15 ISZERO 2E00 61 PUSH2 0x2e05 2E03 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2DF5 memory[stack[-5] + 0xc0:stack[-5] + 0xc0 + 0x20] = stack[-1] // @2DF9 stack[0] = stack[-5] + 0x20 // @2DFA stack[1] = stack[-2] // } // Block ends with conditional jump to 0x2e05, if !(stack[-2] > 0x03) label_2E04: // Incoming jump from 0x2E03, if not !(stack[-2] > 0x03) 2E04 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2E04 assert(); } // Block terminates label_2E05: // Incoming jump from 0x2E03, if !(stack[-2] > 0x03) // Inputs[1] { @2E08 stack[-1] } 2E05 5B JUMPDEST 2E06 60 PUSH1 0x03 2E08 81 DUP2 2E09 11 GT 2E0A 15 ISZERO 2E0B 61 PUSH2 0x2e10 2E0E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2e10, if !(stack[-1] > 0x03) label_2E0F: // Incoming jump from 0x2E0E, if not !(stack[-1] > 0x03) 2E0F FE *ASSERT // Stack delta = +0 // Outputs[1] { @2E0F assert(); } // Block terminates label_2E10: // Incoming jump from 0x2E0E, if !(stack[-1] > 0x03) // Inputs[5] // { // @2E11 stack[-2] // @2E11 stack[-1] // @2E16 stack[-4] // @2E18 stack[-7] // @2E1C memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } 2E10 5B JUMPDEST 2E11 90 SWAP1 2E12 52 MSTORE 2E13 50 POP 2E14 60 PUSH1 0x00 2E16 90 SWAP1 2E17 50 POP 2E18 83 DUP4 2E19 60 PUSH1 0x20 2E1B 01 ADD 2E1C 51 MLOAD 2E1D 60 PUSH1 0x03 2E1F 81 DUP2 2E20 11 GT 2E21 15 ISZERO 2E22 61 PUSH2 0x2e27 2E25 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @2E12 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2E16 stack[-4] = 0x00 // @2E1C stack[-3] = memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } // Block ends with conditional jump to 0x2e27, if !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) label_2E26: // Incoming jump from 0x2E25, if not !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) 2E26 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2E26 assert(); } // Block terminates label_2E27: // Incoming jump from 0x2E25, if !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) // Inputs[2] // { // @2E28 stack[-2] // @2E28 stack[-1] // } 2E27 5B JUMPDEST 2E28 14 EQ 2E29 61 PUSH2 0x2e65 2E2C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2e65, if stack[-1] == stack[-2] label_2E2D: // Incoming jump from 0x2E2C, if not stack[-1] == stack[-2] // Inputs[3] // { // @2E30 memory[0x40:0x60] // @2E5B memory[0x40:0x60] // @2E64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2E2D 60 PUSH1 0x40 2E2F 80 DUP1 2E30 51 MLOAD 2E31 60 PUSH1 0x01 2E33 60 PUSH1 0xe5 2E35 1B SHL 2E36 62 PUSH3 0x461bcd 2E3A 02 MUL 2E3B 81 DUP2 2E3C 52 MSTORE 2E3D 60 PUSH1 0x20 2E3F 60 PUSH1 0x04 2E41 82 DUP3 2E42 01 ADD 2E43 52 MSTORE 2E44 60 PUSH1 0x03 2E46 60 PUSH1 0x24 2E48 82 DUP3 2E49 01 ADD 2E4A 52 MSTORE 2E4B 60 PUSH1 0x01 2E4D 60 PUSH1 0xe8 2E4F 1B SHL 2E50 62 PUSH3 0x453431 2E54 02 MUL 2E55 60 PUSH1 0x44 2E57 82 DUP3 2E58 01 ADD 2E59 52 MSTORE 2E5A 90 SWAP1 2E5B 51 MLOAD 2E5C 90 SWAP1 2E5D 81 DUP2 2E5E 90 SWAP1 2E5F 03 SUB 2E60 60 PUSH1 0x64 2E62 01 ADD 2E63 90 SWAP1 2E64 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2E3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2E43 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2E4A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2E59 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453431 * (0x01 << 0xe8) // @2E64 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2E65: // Incoming jump from 0x2E2C, if stack[-1] == stack[-2] // Inputs[5] // { // @2E6E stack[-6] // @2E7D memory[0x00:0x40] // @2E7E storage[keccak256(memory[0x00:0x40])] // @2E81 stack[-3] // @2E83 memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] // } 2E65 5B JUMPDEST 2E66 60 PUSH1 0x01 2E68 60 PUSH1 0x01 2E6A 60 PUSH1 0xa0 2E6C 1B SHL 2E6D 03 SUB 2E6E 86 DUP7 2E6F 16 AND 2E70 60 PUSH1 0x00 2E72 90 SWAP1 2E73 81 DUP2 2E74 52 MSTORE 2E75 60 PUSH1 0x0d 2E77 60 PUSH1 0x20 2E79 52 MSTORE 2E7A 60 PUSH1 0x40 2E7C 90 SWAP1 2E7D 20 SHA3 2E7E 54 SLOAD 2E7F 60 PUSH1 0x80 2E81 84 DUP5 2E82 01 ADD 2E83 51 MLOAD 2E84 61 PUSH2 0x2e8d 2E87 91 SWAP2 2E88 90 SWAP1 2E89 61 PUSH2 0x33c0 2E8C 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2E74 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @2E79 memory[0x20:0x40] = 0x0d // @2E87 stack[0] = 0x2e8d // @2E88 stack[1] = storage[keccak256(memory[0x00:0x40])] // @2E88 stack[2] = memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] // } // Block ends with call to 0x33c0, returns to 0x2E8D label_2E8D: // Incoming return from call to 0x33C0 at 0x2E8C // Inputs[3] // { // @2E90 stack[-5] // @2E92 stack[-1] // @2E99 stack[-2] // } 2E8D 5B JUMPDEST 2E8E 60 PUSH1 0xe0 2E90 85 DUP6 2E91 01 ADD 2E92 81 DUP2 2E93 90 SWAP1 2E94 52 MSTORE 2E95 60 PUSH1 0x20 2E97 85 DUP6 2E98 01 ADD 2E99 82 DUP3 2E9A 60 PUSH1 0x03 2E9C 81 DUP2 2E9D 11 GT 2E9E 15 ISZERO 2E9F 61 PUSH2 0x2ea4 2EA2 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2E94 memory[stack[-5] + 0xe0:stack[-5] + 0xe0 + 0x20] = stack[-1] // @2E98 stack[0] = stack[-5] + 0x20 // @2E99 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x2ea4, if !(stack[-2] > 0x03) label_2EA3: // Incoming jump from 0x2EA2, if not !(stack[-2] > 0x03) 2EA3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2EA3 assert(); } // Block terminates label_2EA4: // Incoming jump from 0x2EA2, if !(stack[-2] > 0x03) // Inputs[1] { @2EA7 stack[-1] } 2EA4 5B JUMPDEST 2EA5 60 PUSH1 0x03 2EA7 81 DUP2 2EA8 11 GT 2EA9 15 ISZERO 2EAA 61 PUSH2 0x2eaf 2EAD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2eaf, if !(stack[-1] > 0x03) label_2EAE: // Incoming jump from 0x2EAD, if not !(stack[-1] > 0x03) 2EAE FE *ASSERT // Stack delta = +0 // Outputs[1] { @2EAE assert(); } // Block terminates label_2EAF: // Incoming jump from 0x2EAD, if !(stack[-1] > 0x03) // Inputs[5] // { // @2EB0 stack[-1] // @2EB0 stack[-2] // @2EB5 stack[-4] // @2EB7 stack[-7] // @2EBB memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } 2EAF 5B JUMPDEST 2EB0 90 SWAP1 2EB1 52 MSTORE 2EB2 50 POP 2EB3 60 PUSH1 0x00 2EB5 90 SWAP1 2EB6 50 POP 2EB7 83 DUP4 2EB8 60 PUSH1 0x20 2EBA 01 ADD 2EBB 51 MLOAD 2EBC 60 PUSH1 0x03 2EBE 81 DUP2 2EBF 11 GT 2EC0 15 ISZERO 2EC1 61 PUSH2 0x2ec6 2EC4 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @2EB1 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @2EB5 stack[-4] = 0x00 // @2EBB stack[-3] = memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] // } // Block ends with conditional jump to 0x2ec6, if !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) label_2EC5: // Incoming jump from 0x2EC4, if not !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) 2EC5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2EC5 assert(); } // Block terminates label_2EC6: // Incoming jump from 0x2EC4, if !(memory[0x20 + stack[-7]:0x20 + stack[-7] + 0x20] > 0x03) // Inputs[2] // { // @2EC7 stack[-2] // @2EC7 stack[-1] // } 2EC6 5B JUMPDEST 2EC7 14 EQ 2EC8 61 PUSH2 0x2f04 2ECB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2f04, if stack[-1] == stack[-2] label_2ECC: // Incoming jump from 0x2ECB, if not stack[-1] == stack[-2] // Inputs[3] // { // @2ECF memory[0x40:0x60] // @2EFA memory[0x40:0x60] // @2F03 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2ECC 60 PUSH1 0x40 2ECE 80 DUP1 2ECF 51 MLOAD 2ED0 60 PUSH1 0x01 2ED2 60 PUSH1 0xe5 2ED4 1B SHL 2ED5 62 PUSH3 0x461bcd 2ED9 02 MUL 2EDA 81 DUP2 2EDB 52 MSTORE 2EDC 60 PUSH1 0x20 2EDE 60 PUSH1 0x04 2EE0 82 DUP3 2EE1 01 ADD 2EE2 52 MSTORE 2EE3 60 PUSH1 0x03 2EE5 60 PUSH1 0x24 2EE7 82 DUP3 2EE8 01 ADD 2EE9 52 MSTORE 2EEA 60 PUSH1 0x01 2EEC 60 PUSH1 0xe9 2EEE 1B SHL 2EEF 62 PUSH3 0x229a19 2EF3 02 MUL 2EF4 60 PUSH1 0x44 2EF6 82 DUP3 2EF7 01 ADD 2EF8 52 MSTORE 2EF9 90 SWAP1 2EFA 51 MLOAD 2EFB 90 SWAP1 2EFC 81 DUP2 2EFD 90 SWAP1 2EFE 03 SUB 2EFF 60 PUSH1 0x64 2F01 01 ADD 2F02 90 SWAP1 2F03 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2EDB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2EE2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2EE9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2EF8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229a19 * (0x01 << 0xe9) // @2F03 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2F04: // Incoming jump from 0x2ECB, if stack[-1] == stack[-2] // Inputs[2] // { // @2F05 stack[-3] // @2F09 memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] // } 2F04 5B JUMPDEST 2F05 82 DUP3 2F06 60 PUSH1 0xa0 2F08 01 ADD 2F09 51 MLOAD 2F0A 61 PUSH2 0x2f11 2F0D 61 PUSH2 0x306e 2F10 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2F09 stack[0] = memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] // @2F0A stack[1] = 0x2f11 // } // Block ends with call to 0x306e, returns to 0x2F11 label_2F11: // Incoming return from call to 0x306E at 0x2F10 // Inputs[2] // { // @2F12 stack[-1] // @2F12 stack[-2] // } 2F11 5B JUMPDEST 2F12 10 LT 2F13 15 ISZERO 2F14 61 PUSH2 0x2f50 2F17 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2f50, if !(stack[-1] < stack[-2]) label_2F18: // Incoming jump from 0x2F17, if not !(stack[-1] < stack[-2]) // Inputs[3] // { // @2F1B memory[0x40:0x60] // @2F46 memory[0x40:0x60] // @2F4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2F18 60 PUSH1 0x40 2F1A 80 DUP1 2F1B 51 MLOAD 2F1C 60 PUSH1 0x01 2F1E 60 PUSH1 0xe5 2F20 1B SHL 2F21 62 PUSH3 0x461bcd 2F25 02 MUL 2F26 81 DUP2 2F27 52 MSTORE 2F28 60 PUSH1 0x20 2F2A 60 PUSH1 0x04 2F2C 82 DUP3 2F2D 01 ADD 2F2E 52 MSTORE 2F2F 60 PUSH1 0x03 2F31 60 PUSH1 0x24 2F33 82 DUP3 2F34 01 ADD 2F35 52 MSTORE 2F36 60 PUSH1 0x01 2F38 60 PUSH1 0xe8 2F3A 1B SHL 2F3B 62 PUSH3 0x453433 2F3F 02 MUL 2F40 60 PUSH1 0x44 2F42 82 DUP3 2F43 01 ADD 2F44 52 MSTORE 2F45 90 SWAP1 2F46 51 MLOAD 2F47 90 SWAP1 2F48 81 DUP2 2F49 90 SWAP1 2F4A 03 SUB 2F4B 60 PUSH1 0x64 2F4D 01 ADD 2F4E 90 SWAP1 2F4F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2F27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @2F2E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2F35 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @2F44 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453433 * (0x01 << 0xe8) // @2F4F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2F50: // Incoming jump from 0x2F17, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @2F54 stack[-6] // @2F55 stack[-3] // @2F59 memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] // } 2F50 5B JUMPDEST 2F51 61 PUSH2 0x2f5e 2F54 86 DUP7 2F55 84 DUP5 2F56 60 PUSH1 0xa0 2F58 01 ADD 2F59 51 MLOAD 2F5A 61 PUSH2 0x43ee 2F5D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2F51 stack[0] = 0x2f5e // @2F54 stack[1] = stack[-6] // @2F59 stack[2] = memory[0xa0 + stack[-3]:0xa0 + stack[-3] + 0x20] // } // Block ends with call to 0x43ee, returns to 0x2F5E label_2F5E: // Incoming return from call to 0x43EE at 0x2F5D // Inputs[19] // { // @2F62 stack[-4] // @2F64 stack[-1] // @2F69 memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] // @2F6D memory[0x40:0x60] // @2F71 memory[0x40:0x60] // @2F72 address(this) // @2F7C stack[-7] // @2F82 memory[0x00:0x20] // @2F8B memory[0x00:0x20] // @2F96 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @2F9B memory[stack[-4] + 0xc0:stack[-4] + 0xc0 + 0x20] // @2FA3 memory[stack[-4] + 0xe0:stack[-4] + 0xe0 + 0x20] // @2FBD memory[0x00:0x40] // @2FC3 storage[0x00] // @2FC9 memory[stack[-4] + 0x0180:stack[-4] + 0x0180 + 0x20] // @2FCE memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] // @2FD0 memory[0x40:0x60] // @2FEC memory[0x40:0x60] // @300E address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } 2F5E 5B JUMPDEST 2F5F 61 PUSH2 0x0180 2F62 84 DUP5 2F63 01 ADD 2F64 52 MSTORE 2F65 60 PUSH1 0x80 2F67 83 DUP4 2F68 01 ADD 2F69 51 MLOAD 2F6A 60 PUSH1 0x40 2F6C 80 DUP1 2F6D 51 MLOAD 2F6E 91 SWAP2 2F6F 82 DUP3 2F70 52 MSTORE 2F71 51 MLOAD 2F72 30 ADDRESS 2F73 91 SWAP2 2F74 60 PUSH1 0x01 2F76 60 PUSH1 0x01 2F78 60 PUSH1 0xa0 2F7A 1B SHL 2F7B 03 SUB 2F7C 89 DUP10 2F7D 16 AND 2F7E 91 SWAP2 2F7F 60 PUSH1 0x00 2F81 80 DUP1 2F82 51 MLOAD 2F83 60 PUSH1 0x20 2F85 61 PUSH2 0x54d1 2F88 83 DUP4 2F89 39 CODECOPY 2F8A 81 DUP2 2F8B 51 MLOAD 2F8C 91 SWAP2 2F8D 52 MSTORE 2F8E 91 SWAP2 2F8F 81 DUP2 2F90 90 SWAP1 2F91 03 SUB 2F92 60 PUSH1 0x20 2F94 01 ADD 2F95 90 SWAP1 2F96 A3 LOG3 2F97 60 PUSH1 0xc0 2F99 83 DUP4 2F9A 01 ADD 2F9B 51 MLOAD 2F9C 60 PUSH1 0x07 2F9E 55 SSTORE 2F9F 60 PUSH1 0xe0 2FA1 83 DUP4 2FA2 01 ADD 2FA3 51 MLOAD 2FA4 60 PUSH1 0x01 2FA6 60 PUSH1 0x01 2FA8 60 PUSH1 0xa0 2FAA 1B SHL 2FAB 03 SUB 2FAC 80 DUP1 2FAD 88 DUP9 2FAE 16 AND 2FAF 60 PUSH1 0x00 2FB1 90 SWAP1 2FB2 81 DUP2 2FB3 52 MSTORE 2FB4 60 PUSH1 0x0d 2FB6 60 PUSH1 0x20 2FB8 52 MSTORE 2FB9 60 PUSH1 0x40 2FBB 80 DUP1 2FBC 82 DUP3 2FBD 20 SHA3 2FBE 93 SWAP4 2FBF 90 SWAP1 2FC0 93 SWAP4 2FC1 55 SSTORE 2FC2 80 DUP1 2FC3 54 SLOAD 2FC4 61 PUSH2 0x0180 2FC7 87 DUP8 2FC8 01 ADD 2FC9 51 MLOAD 2FCA 60 PUSH1 0x80 2FCC 88 DUP9 2FCD 01 ADD 2FCE 51 MLOAD 2FCF 85 DUP6 2FD0 51 MLOAD 2FD1 60 PUSH1 0x01 2FD3 60 PUSH1 0xe1 2FD5 1B SHL 2FD6 63 PUSH4 0x6640728d 2FDB 02 MUL 2FDC 81 DUP2 2FDD 52 MSTORE 2FDE 60 PUSH1 0x04 2FE0 81 DUP2 2FE1 01 ADD 2FE2 92 SWAP3 2FE3 90 SWAP1 2FE4 92 SWAP3 2FE5 52 MSTORE 2FE6 60 PUSH1 0x24 2FE8 82 DUP3 2FE9 01 ADD 2FEA 52 MSTORE 2FEB 93 SWAP4 2FEC 51 MLOAD 2FED 63 PUSH4 0x01000000 2FF2 90 SWAP1 2FF3 91 SWAP2 2FF4 04 DIV 2FF5 90 SWAP1 2FF6 92 SWAP3 2FF7 16 AND 2FF8 92 SWAP3 2FF9 63 PUSH4 0xcc80e51a 2FFE 92 SWAP3 2FFF 60 PUSH1 0x44 3001 80 DUP1 3002 83 DUP4 3003 01 ADD 3004 93 SWAP4 3005 92 SWAP3 3006 82 DUP3 3007 90 SWAP1 3008 03 SUB 3009 01 ADD 300A 81 DUP2 300B 83 DUP4 300C 87 DUP8 300D 80 DUP1 300E 3B EXTCODESIZE 300F 15 ISZERO 3010 80 DUP1 3011 15 ISZERO 3012 61 PUSH2 0x301a 3015 57 *JUMPI // Stack delta = +9 // Outputs[22] // { // @2F64 memory[stack[-4] + 0x0180:stack[-4] + 0x0180 + 0x20] = stack[-1] // @2F70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] // @2F89 memory[0x00:0x20] = code[0x54d1:0x54f1] // @2F8D memory[0x00:0x20] = memory[0x00:0x20] // @2F96 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [memory[0x00:0x20], stack[-7] & (0x01 << 0xa0) - 0x01, address(this)]); // @2F9E storage[0x07] = memory[stack[-4] + 0xc0:stack[-4] + 0xc0 + 0x20] // @2FB3 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @2FB8 memory[0x20:0x40] = 0x0d // @2FC1 storage[keccak256(memory[0x00:0x40])] = memory[stack[-4] + 0xe0:stack[-4] + 0xe0 + 0x20] // @2FDD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6640728d * (0x01 << 0xe1) // @2FE5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = memory[stack[-4] + 0x0180:stack[-4] + 0x0180 + 0x20] // @2FEA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = memory[stack[-4] + 0x80:stack[-4] + 0x80 + 0x20] // @2FF8 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @2FFE stack[0] = 0xcc80e51a // @2FFE stack[3] = memory[0x40:0x60] // @3004 stack[1] = memory[0x40:0x60] + 0x44 // @3005 stack[2] = 0x00 // @3009 stack[4] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @300A stack[5] = memory[0x40:0x60] // @300B stack[6] = 0x00 // @300C stack[7] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @300F stack[8] = !address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } // Block ends with conditional jump to 0x301a, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length label_3016: // Incoming jump from 0x3015, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[1] { @3019 memory[0x00:0x00] } 3016 60 PUSH1 0x00 3018 80 DUP1 3019 FD *REVERT // Stack delta = +0 // Outputs[1] { @3019 revert(memory[0x00:0x00]); } // Block terminates label_301A: // Incoming jump from 0x3015, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[9] // { // @301C msg.gas // @301D stack[-3] // @301D memory[stack[-4]:stack[-4] + stack[-5]] // @301D stack[-6] // @301D stack[-5] // @301D stack[-4] // @301D stack[-2] // @301D address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @301D stack[-7] // } 301A 5B JUMPDEST 301B 50 POP 301C 5A GAS 301D F1 CALL 301E 15 ISZERO 301F 80 DUP1 3020 15 ISZERO 3021 61 PUSH2 0x302e 3024 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @301D memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @301E stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x302e, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3025: // Incoming jump from 0x3024, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3025 returndata.length // @3029 returndata[0x00:0x00 + returndata.length] // @302A returndata.length // @302D memory[0x00:0x00 + returndata.length] // } 3025 3D RETURNDATASIZE 3026 60 PUSH1 0x00 3028 80 DUP1 3029 3E RETURNDATACOPY 302A 3D RETURNDATASIZE 302B 60 PUSH1 0x00 302D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3029 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @302D revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_302E: // Incoming jump from 0x3024, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @3032 stack[-4] // @3037 stack[-3] // } 302E 5B JUMPDEST 302F 50 POP 3030 60 PUSH1 0x00 3032 92 SWAP3 3033 50 POP 3034 61 PUSH2 0x303b 3037 91 SWAP2 3038 50 POP 3039 50 POP 303A 56 *JUMP // Stack delta = -3 // Outputs[1] { @3032 stack[-4] = 0x00 } // Block ends with unconditional jump to 0x303b label_303B: // Incoming jump from 0x303A // Inputs[5] // { // @303C stack[-5] // @303C stack[-1] // @3044 storage[0x00] // @3052 stack[-8] // @3053 stack[-7] // } 303B 5B JUMPDEST 303C 93 SWAP4 303D 50 POP 303E 50 POP 303F 50 POP 3040 50 POP 3041 60 PUSH1 0x00 3043 80 DUP1 3044 54 SLOAD 3045 62 PUSH3 0xff0000 3049 19 NOT 304A 16 AND 304B 62 PUSH3 0x010000 304F 17 OR 3050 90 SWAP1 3051 55 SSTORE 3052 92 SWAP3 3053 91 SWAP2 3054 50 POP 3055 50 POP 3056 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @3051 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @3052 stack[-8] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_3057: // Incoming call from 0x1C2A, returns to 0x1C2B // Incoming call from 0x150E, returns to 0x150F // Incoming call from 0x2A0B, returns to 0x2A0C 3057 5B JUMPDEST 3058 60 PUSH1 0x00 305A 80 DUP1 305B 60 PUSH1 0x00 305D 61 PUSH2 0x3064 3060 61 PUSH2 0x5357 3063 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3058 stack[0] = 0x00 // @305A stack[1] = 0x00 // @305B stack[2] = 0x00 // @305D stack[3] = 0x3064 // } // Block ends with call to 0x5357, returns to 0x3064 label_3064: // Incoming return from call to 0x5357 at 0x3063 // Inputs[2] // { // @3068 stack[-6] // @3069 stack[-5] // } 3064 5B JUMPDEST 3065 61 PUSH2 0x2549 3068 86 DUP7 3069 86 DUP7 306A 61 PUSH2 0x33e3 306D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3065 stack[0] = 0x2549 // @3068 stack[1] = stack[-6] // @3069 stack[2] = stack[-5] // } // Block ends with call to 0x33e3, returns to 0x2549 label_306E: // Incoming call from 0x4F63, returns to 0x4F64 // Incoming call from 0x2F10, returns to 0x2F11 // Incoming call from 0x22DE, returns to 0x22DF // Incoming call from 0x1571, returns to 0x11A3 // Incoming call from 0x241A, returns to 0x241B // Incoming call from 0x1E9F, returns to 0x1EA0 // Incoming call from 0x1A65, returns to 0x1A66 // Incoming call from 0x31BD, returns to 0x31BE // Inputs[3] // { // @3076 address(this) // @3077 address(this).balance // @3078 msg.value // } 306E 5B JUMPDEST 306F 60 PUSH1 0x00 3071 80 DUP1 3072 80 DUP1 3073 61 PUSH2 0x307d 3076 30 ADDRESS 3077 31 BALANCE 3078 34 CALLVALUE 3079 61 PUSH2 0x33c0 307C 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @306F stack[0] = 0x00 // @3071 stack[1] = 0x00 // @3072 stack[2] = 0x00 // @3073 stack[3] = 0x307d // @3077 stack[4] = address(this).balance // @3078 stack[5] = msg.value // } // Block ends with call to 0x33c0, returns to 0x307D label_307D: // Incoming return from call to 0x33C0 at 0x307C // Inputs[4] // { // @307E stack[-1] // @307E stack[-2] // @307F stack[-4] // @3081 stack[-3] // } 307D 5B JUMPDEST 307E 90 SWAP1 307F 92 SWAP3 3080 50 POP 3081 90 SWAP1 3082 50 POP 3083 60 PUSH1 0x00 3085 82 DUP3 3086 60 PUSH1 0x03 3088 81 DUP2 3089 11 GT 308A 15 ISZERO 308B 61 PUSH2 0x3090 308E 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @307F stack[-4] = stack[-2] // @3081 stack[-3] = stack[-1] // @3083 stack[-2] = 0x00 // @3085 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x3090, if !(stack[-2] > 0x03) label_308F: // Incoming jump from 0x308E, if not !(stack[-2] > 0x03) 308F FE *ASSERT // Stack delta = +0 // Outputs[1] { @308F assert(); } // Block terminates label_3090: // Incoming jump from 0x308E, if !(stack[-2] > 0x03) // Inputs[2] // { // @3091 stack[-1] // @3091 stack[-2] // } 3090 5B JUMPDEST 3091 14 EQ 3092 61 PUSH2 0x12cf 3095 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x12cf, if stack[-1] == stack[-2] label_3096: // Incoming jump from 0x3095, if not stack[-1] == stack[-2] // Inputs[1] { @3099 memory[0x00:0x00] } 3096 60 PUSH1 0x00 3098 80 DUP1 3099 FD *REVERT // Stack delta = +0 // Outputs[1] { @3099 revert(memory[0x00:0x00]); } // Block terminates label_309A: // Incoming call from 0x1623, returns to 0x1624 // Inputs[1] { @309E storage[0x00] } 309A 5B JUMPDEST 309B 60 PUSH1 0x00 309D 80 DUP1 309E 54 SLOAD 309F 81 DUP2 30A0 90 SWAP1 30A1 62 PUSH3 0x010000 30A5 90 SWAP1 30A6 04 DIV 30A7 60 PUSH1 0xff 30A9 16 AND 30AA 61 PUSH2 0x30e6 30AD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @309B stack[0] = 0x00 // @30A0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x30e6, if 0xff & storage[0x00] / 0x010000 label_30AE: // Incoming jump from 0x30AD, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @30B1 memory[0x40:0x60] // @30DC memory[0x40:0x60] // @30E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 30AE 60 PUSH1 0x40 30B0 80 DUP1 30B1 51 MLOAD 30B2 60 PUSH1 0x01 30B4 60 PUSH1 0xe5 30B6 1B SHL 30B7 62 PUSH3 0x461bcd 30BB 02 MUL 30BC 81 DUP2 30BD 52 MSTORE 30BE 60 PUSH1 0x20 30C0 60 PUSH1 0x04 30C2 82 DUP3 30C3 01 ADD 30C4 52 MSTORE 30C5 60 PUSH1 0x03 30C7 60 PUSH1 0x24 30C9 82 DUP3 30CA 01 ADD 30CB 52 MSTORE 30CC 60 PUSH1 0x01 30CE 60 PUSH1 0xe8 30D0 1B SHL 30D1 62 PUSH3 0x453637 30D5 02 MUL 30D6 60 PUSH1 0x44 30D8 82 DUP3 30D9 01 ADD 30DA 52 MSTORE 30DB 90 SWAP1 30DC 51 MLOAD 30DD 90 SWAP1 30DE 81 DUP2 30DF 90 SWAP1 30E0 03 SUB 30E1 60 PUSH1 0x64 30E3 01 ADD 30E4 90 SWAP1 30E5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @30BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @30C4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @30CB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @30DA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @30E5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_30E6: // Incoming jump from 0x30AD, if 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @30EA storage[0x00] // @30F6 msg.sender // @30F8 stack[-3] // } 30E6 5B JUMPDEST 30E7 60 PUSH1 0x00 30E9 80 DUP1 30EA 54 SLOAD 30EB 62 PUSH3 0xff0000 30EF 19 NOT 30F0 16 AND 30F1 90 SWAP1 30F2 55 SSTORE 30F3 61 PUSH2 0x30fd 30F6 33 CALLER 30F7 80 DUP1 30F8 85 DUP6 30F9 61 PUSH2 0x442e 30FC 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @30F2 storage[0x00] = ~0xff0000 & storage[0x00] // @30F3 stack[0] = 0x30fd // @30F6 stack[1] = msg.sender // @30F7 stack[2] = msg.sender // @30F8 stack[3] = stack[-3] // } // Block ends with call to 0x442e, returns to 0x30FD label_30FD: // Incoming return from call to 0x442E at 0x30FC // Inputs[7] // { // @30FE stack[-3] // @30FE stack[-1] // @3100 stack[-4] // @3100 stack[-2] // @3105 storage[0x00] // @3114 stack[-6] // @3116 stack[-5] // } 30FD 5B JUMPDEST 30FE 91 SWAP2 30FF 50 POP 3100 91 SWAP2 3101 50 POP 3102 60 PUSH1 0x00 3104 80 DUP1 3105 54 SLOAD 3106 62 PUSH3 0xff0000 310A 19 NOT 310B 16 AND 310C 62 PUSH3 0x010000 3110 17 OR 3111 90 SWAP1 3112 55 SSTORE 3113 90 SWAP1 3114 92 SWAP3 3115 90 SWAP1 3116 91 SWAP2 3117 50 POP 3118 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @3112 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @3114 stack[-6] = stack[-2] // @3116 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_3119: // Incoming call from 0x1680, returns to 0x1681 // Inputs[2] // { // @311C storage[0x05] // @3130 msg.sender // } 3119 5B JUMPDEST 311A 60 PUSH1 0x05 311C 54 SLOAD 311D 60 PUSH1 0x00 311F 90 SWAP1 3120 81 DUP2 3121 90 SWAP1 3122 61 PUSH2 0x0100 3125 90 SWAP1 3126 04 DIV 3127 60 PUSH1 0x01 3129 60 PUSH1 0x01 312B 60 PUSH1 0xa0 312D 1B SHL 312E 03 SUB 312F 16 AND 3130 33 CALLER 3131 14 EQ 3132 61 PUSH2 0x316d 3135 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @311F stack[0] = 0x00 // @3121 stack[1] = 0x00 // } // Block ends with conditional jump to 0x316d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 label_3136: // Incoming jump from 0x3135, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[3] // { // @3139 memory[0x40:0x60] // @3163 memory[0x40:0x60] // @316C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3136 60 PUSH1 0x40 3138 80 DUP1 3139 51 MLOAD 313A 60 PUSH1 0x01 313C 60 PUSH1 0xe5 313E 1B SHL 313F 62 PUSH3 0x461bcd 3143 02 MUL 3144 81 DUP2 3145 52 MSTORE 3146 60 PUSH1 0x20 3148 60 PUSH1 0x04 314A 82 DUP3 314B 01 ADD 314C 52 MSTORE 314D 60 PUSH1 0x02 314F 60 PUSH1 0x24 3151 82 DUP3 3152 01 ADD 3153 52 MSTORE 3154 60 PUSH1 0x01 3156 60 PUSH1 0xf0 3158 1B SHL 3159 61 PUSH2 0x4531 315C 02 MUL 315D 60 PUSH1 0x44 315F 82 DUP3 3160 01 ADD 3161 52 MSTORE 3162 90 SWAP1 3163 51 MLOAD 3164 90 SWAP1 3165 81 DUP2 3166 90 SWAP1 3167 03 SUB 3168 60 PUSH1 0x64 316A 01 ADD 316B 90 SWAP1 316C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3145 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @314C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3153 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @3161 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4531 * (0x01 << 0xf0) // @316C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_316D: // Incoming jump from 0x3135, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 316D 5B JUMPDEST 316E 61 PUSH2 0x3175 3171 61 PUSH2 0x23f2 3174 56 *JUMP // Stack delta = +1 // Outputs[1] { @316E stack[0] = 0x3175 } // Block ends with call to 0x23f2, returns to 0x3175 label_3175: // Incoming return from call to 0x23F2 at 0x3174 // Inputs[2] // { // @3178 storage[0x08] // @3179 stack[-1] // } 3175 5B JUMPDEST 3176 60 PUSH1 0x08 3178 54 SLOAD 3179 14 EQ 317A 61 PUSH2 0x31b5 317D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x31b5, if storage[0x08] == stack[-1] label_317E: // Incoming jump from 0x317D, if not storage[0x08] == stack[-1] // Inputs[3] // { // @3181 memory[0x40:0x60] // @31AB memory[0x40:0x60] // @31B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 317E 60 PUSH1 0x40 3180 80 DUP1 3181 51 MLOAD 3182 60 PUSH1 0x01 3184 60 PUSH1 0xe5 3186 1B SHL 3187 62 PUSH3 0x461bcd 318B 02 MUL 318C 81 DUP2 318D 52 MSTORE 318E 60 PUSH1 0x20 3190 60 PUSH1 0x04 3192 82 DUP3 3193 01 ADD 3194 52 MSTORE 3195 60 PUSH1 0x02 3197 60 PUSH1 0x24 3199 82 DUP3 319A 01 ADD 319B 52 MSTORE 319C 60 PUSH1 0x01 319E 60 PUSH1 0xf0 31A0 1B SHL 31A1 61 PUSH2 0x4537 31A4 02 MUL 31A5 60 PUSH1 0x44 31A7 82 DUP3 31A8 01 ADD 31A9 52 MSTORE 31AA 90 SWAP1 31AB 51 MLOAD 31AC 90 SWAP1 31AD 81 DUP2 31AE 90 SWAP1 31AF 03 SUB 31B0 60 PUSH1 0x64 31B2 01 ADD 31B3 90 SWAP1 31B4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @318D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3194 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @319B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @31A9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4537 * (0x01 << 0xf0) // @31B4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_31B5: // Incoming jump from 0x317D, if storage[0x08] == stack[-1] // Inputs[1] { @31B6 stack[-3] } 31B5 5B JUMPDEST 31B6 82 DUP3 31B7 61 PUSH2 0x31be 31BA 61 PUSH2 0x306e 31BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @31B6 stack[0] = stack[-3] // @31B7 stack[1] = 0x31be // } // Block ends with call to 0x306e, returns to 0x31BE label_31BE: // Incoming return from call to 0x306E at 0x31BD // Inputs[2] // { // @31BF stack[-2] // @31BF stack[-1] // } 31BE 5B JUMPDEST 31BF 10 LT 31C0 15 ISZERO 31C1 61 PUSH2 0x31fd 31C4 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x31fd, if !(stack[-1] < stack[-2]) label_31C5: // Incoming jump from 0x31C4, if not !(stack[-1] < stack[-2]) // Inputs[3] // { // @31C8 memory[0x40:0x60] // @31F3 memory[0x40:0x60] // @31FC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 31C5 60 PUSH1 0x40 31C7 80 DUP1 31C8 51 MLOAD 31C9 60 PUSH1 0x01 31CB 60 PUSH1 0xe5 31CD 1B SHL 31CE 62 PUSH3 0x461bcd 31D2 02 MUL 31D3 81 DUP2 31D4 52 MSTORE 31D5 60 PUSH1 0x20 31D7 60 PUSH1 0x04 31D9 82 DUP3 31DA 01 ADD 31DB 52 MSTORE 31DC 60 PUSH1 0x03 31DE 60 PUSH1 0x24 31E0 82 DUP3 31E1 01 ADD 31E2 52 MSTORE 31E3 60 PUSH1 0x01 31E5 60 PUSH1 0xe8 31E7 1B SHL 31E8 62 PUSH3 0x453231 31EC 02 MUL 31ED 60 PUSH1 0x44 31EF 82 DUP3 31F0 01 ADD 31F1 52 MSTORE 31F2 90 SWAP1 31F3 51 MLOAD 31F4 90 SWAP1 31F5 81 DUP2 31F6 90 SWAP1 31F7 03 SUB 31F8 60 PUSH1 0x64 31FA 01 ADD 31FB 90 SWAP1 31FC FD *REVERT // Stack delta = +0 // Outputs[5] // { // @31D4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @31DB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @31E2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @31F1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453231 * (0x01 << 0xe8) // @31FC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_31FD: // Incoming jump from 0x31C4, if !(stack[-1] < stack[-2]) // Inputs[2] // { // @3200 storage[0x0a] // @3201 stack[-3] // } 31FD 5B JUMPDEST 31FE 60 PUSH1 0x0a 3200 54 SLOAD 3201 83 DUP4 3202 11 GT 3203 15 ISZERO 3204 61 PUSH2 0x3240 3207 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3240, if !(stack[-3] > storage[0x0a]) label_3208: // Incoming jump from 0x3207, if not !(stack[-3] > storage[0x0a]) // Inputs[3] // { // @320B memory[0x40:0x60] // @3236 memory[0x40:0x60] // @323F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3208 60 PUSH1 0x40 320A 80 DUP1 320B 51 MLOAD 320C 60 PUSH1 0x01 320E 60 PUSH1 0xe5 3210 1B SHL 3211 62 PUSH3 0x461bcd 3215 02 MUL 3216 81 DUP2 3217 52 MSTORE 3218 60 PUSH1 0x20 321A 60 PUSH1 0x04 321C 82 DUP3 321D 01 ADD 321E 52 MSTORE 321F 60 PUSH1 0x03 3221 60 PUSH1 0x24 3223 82 DUP3 3224 01 ADD 3225 52 MSTORE 3226 60 PUSH1 0x01 3228 60 PUSH1 0xe8 322A 1B SHL 322B 62 PUSH3 0x453437 322F 02 MUL 3230 60 PUSH1 0x44 3232 82 DUP3 3233 01 ADD 3234 52 MSTORE 3235 90 SWAP1 3236 51 MLOAD 3237 90 SWAP1 3238 81 DUP2 3239 90 SWAP1 323A 03 SUB 323B 60 PUSH1 0x64 323D 01 ADD 323E 90 SWAP1 323F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3217 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @321E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3225 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @3234 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453437 * (0x01 << 0xe8) // @323F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3240: // Incoming jump from 0x3207, if !(stack[-3] > storage[0x0a]) // Inputs[2] // { // @3244 storage[0x0a] // @3245 stack[-3] // } 3240 5B JUMPDEST 3241 50 POP 3242 60 PUSH1 0x0a 3244 54 SLOAD 3245 82 DUP3 3246 81 DUP2 3247 03 SUB 3248 90 SWAP1 3249 81 DUP2 324A 11 GT 324B 15 ISZERO 324C 61 PUSH2 0x3288 324F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3248 stack[-1] = storage[0x0a] - stack[-3] } // Block ends with conditional jump to 0x3288, if !(storage[0x0a] - stack[-3] > storage[0x0a]) label_3250: // Incoming jump from 0x324F, if not !(storage[0x0a] - stack[-3] > storage[0x0a]) // Inputs[3] // { // @3253 memory[0x40:0x60] // @327E memory[0x40:0x60] // @3287 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3250 60 PUSH1 0x40 3252 80 DUP1 3253 51 MLOAD 3254 60 PUSH1 0x01 3256 60 PUSH1 0xe5 3258 1B SHL 3259 62 PUSH3 0x461bcd 325D 02 MUL 325E 81 DUP2 325F 52 MSTORE 3260 60 PUSH1 0x20 3262 60 PUSH1 0x04 3264 82 DUP3 3265 01 ADD 3266 52 MSTORE 3267 60 PUSH1 0x03 3269 60 PUSH1 0x24 326B 82 DUP3 326C 01 ADD 326D 52 MSTORE 326E 60 PUSH1 0x01 3270 60 PUSH1 0xeb 3272 1B SHL 3273 62 PUSH3 0x08a687 3277 02 MUL 3278 60 PUSH1 0x44 327A 82 DUP3 327B 01 ADD 327C 52 MSTORE 327D 90 SWAP1 327E 51 MLOAD 327F 90 SWAP1 3280 81 DUP2 3281 90 SWAP1 3282 03 SUB 3283 60 PUSH1 0x64 3285 01 ADD 3286 90 SWAP1 3287 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @325F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3266 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @326D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @327C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x08a687 * (0x01 << 0xeb) // @3287 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3288: // Incoming jump from 0x324F, if !(storage[0x0a] - stack[-3] > storage[0x0a]) // Inputs[3] // { // @328B stack[-1] // @3290 storage[0x05] // @32A6 stack[-3] // } 3288 5B JUMPDEST 3289 60 PUSH1 0x0a 328B 81 DUP2 328C 90 SWAP1 328D 55 SSTORE 328E 60 PUSH1 0x05 3290 54 SLOAD 3291 60 PUSH1 0x00 3293 90 SWAP1 3294 61 PUSH2 0x32ab 3297 90 SWAP1 3298 61 PUSH2 0x0100 329B 90 SWAP1 329C 04 DIV 329D 60 PUSH1 0x01 329F 60 PUSH1 0x01 32A1 60 PUSH1 0xa0 32A3 1B SHL 32A4 03 SUB 32A5 16 AND 32A6 85 DUP6 32A7 61 PUSH2 0x43ee 32AA 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @328D storage[0x0a] = stack[-1] // @3293 stack[0] = 0x00 // @3297 stack[1] = 0x32ab // @32A5 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // @32A6 stack[3] = stack[-3] // } // Block ends with call to 0x43ee, returns to 0x32AB label_32AB: // Incoming return from call to 0x43EE at 0x32AA // Inputs[9] // { // @32AE storage[0x05] // @32B2 memory[0x40:0x60] // @32CB stack[-1] // @32D1 stack[-3] // @32D4 memory[0x40:0x60] // @32D6 stack[-2] // @3302 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // @3305 stack[-6] // @3306 stack[-5] // } 32AB 5B JUMPDEST 32AC 60 PUSH1 0x05 32AE 54 SLOAD 32AF 60 PUSH1 0x40 32B1 80 DUP1 32B2 51 MLOAD 32B3 60 PUSH1 0x01 32B5 60 PUSH1 0x01 32B7 60 PUSH1 0xa0 32B9 1B SHL 32BA 03 SUB 32BB 61 PUSH2 0x0100 32BE 90 SWAP1 32BF 93 SWAP4 32C0 04 DIV 32C1 92 SWAP3 32C2 90 SWAP1 32C3 92 SWAP3 32C4 16 AND 32C5 82 DUP3 32C6 52 MSTORE 32C7 60 PUSH1 0x20 32C9 82 DUP3 32CA 01 ADD 32CB 83 DUP4 32CC 90 SWAP1 32CD 52 MSTORE 32CE 81 DUP2 32CF 81 DUP2 32D0 01 ADD 32D1 85 DUP6 32D2 90 SWAP1 32D3 52 MSTORE 32D4 51 MLOAD 32D5 91 SWAP2 32D6 92 SWAP3 32D7 50 POP 32D8 7F PUSH32 0x3bad0c59cf2f06e7314077049f48a93578cd16f5ef92329f1dab1420a99c177e 32F9 91 SWAP2 32FA 90 SWAP1 32FB 81 DUP2 32FC 90 SWAP1 32FD 03 SUB 32FE 60 PUSH1 0x60 3300 01 ADD 3301 90 SWAP1 3302 A1 LOG1 3303 60 PUSH1 0x00 3305 94 SWAP5 3306 93 SWAP4 3307 50 POP 3308 50 POP 3309 50 POP 330A 50 POP 330B 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @32C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x05] / 0x0100 & (0x01 << 0xa0) - 0x01 // @32CD memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @32D3 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-3] // @3302 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x3bad0c59cf2f06e7314077049f48a93578cd16f5ef92329f1dab1420a99c177e]); // @3305 stack[-6] = 0x00 // } // Block ends with unconditional jump to stack[-6] label_330C: // Incoming call from 0x4FB3, returns to 0x4FB4 // Incoming call from 0x19E6, returns to 0x19E7 // Incoming call from 0x2082, returns to 0x2083 // Incoming call from 0x4576, returns to 0x4577 // Inputs[3] // { // @3315 stack[-1] // @3324 memory[0x00:0x40] // @3326 storage[keccak256(memory[0x00:0x40])] // } 330C 5B JUMPDEST 330D 60 PUSH1 0x01 330F 60 PUSH1 0x01 3311 60 PUSH1 0xa0 3313 1B SHL 3314 03 SUB 3315 81 DUP2 3316 16 AND 3317 60 PUSH1 0x00 3319 90 SWAP1 331A 81 DUP2 331B 52 MSTORE 331C 60 PUSH1 0x11 331E 60 PUSH1 0x20 3320 52 MSTORE 3321 60 PUSH1 0x40 3323 81 DUP2 3324 20 SHA3 3325 80 DUP1 3326 54 SLOAD 3327 82 DUP3 3328 91 SWAP2 3329 82 DUP3 332A 91 SWAP2 332B 82 DUP3 332C 91 SWAP2 332D 82 DUP3 332E 91 SWAP2 332F 61 PUSH2 0x3343 3332 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @3319 stack[0] = 0x00 // @331B memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @3320 memory[0x20:0x40] = 0x11 // @3328 stack[1] = 0x00 // @332A stack[2] = 0x00 // @332C stack[3] = 0x00 // @332C stack[5] = keccak256(memory[0x00:0x40]) // @332E stack[4] = 0x00 // } // Block ends with conditional jump to 0x3343, if storage[keccak256(memory[0x00:0x40])] label_3333: // Incoming jump from 0x3332, if not storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @3336 stack[-6] // @3339 stack[-5] // @333E stack[-4] // } 3333 50 POP 3334 60 PUSH1 0x00 3336 94 SWAP5 3337 50 POP 3338 84 DUP5 3339 93 SWAP4 333A 50 POP 333B 61 PUSH2 0x33bb 333E 92 SWAP3 333F 50 POP 3340 50 POP 3341 50 POP 3342 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @3336 stack[-6] = 0x00 // @3339 stack[-5] = 0x00 // } // Block ends with unconditional jump to 0x33bb label_3343: // Incoming jump from 0x3332, if storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @3347 stack[-1] // @334B storage[0x00 + stack[-1]] // @334E storage[0x09] // } 3343 5B JUMPDEST 3344 61 PUSH2 0x3353 3347 81 DUP2 3348 60 PUSH1 0x00 334A 01 ADD 334B 54 SLOAD 334C 60 PUSH1 0x09 334E 54 SLOAD 334F 61 PUSH2 0x47e4 3352 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3344 stack[0] = 0x3353 // @334B stack[1] = storage[0x00 + stack[-1]] // @334E stack[2] = storage[0x09] // } // Block ends with call to 0x47e4, returns to 0x3353 label_3353: // Incoming return from call to 0x47E4 at 0x3352 // Inputs[4] // { // @3354 stack[-1] // @3354 stack[-2] // @3355 stack[-6] // @3357 stack[-5] // } 3353 5B JUMPDEST 3354 90 SWAP1 3355 94 SWAP5 3356 50 POP 3357 92 SWAP3 3358 50 POP 3359 60 PUSH1 0x00 335B 84 DUP5 335C 60 PUSH1 0x03 335E 81 DUP2 335F 11 GT 3360 15 ISZERO 3361 61 PUSH2 0x3366 3364 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @3355 stack[-6] = stack[-2] // @3357 stack[-5] = stack[-1] // @3359 stack[-2] = 0x00 // @335B stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x3366, if !(stack[-2] > 0x03) label_3365: // Incoming jump from 0x3364, if not !(stack[-2] > 0x03) 3365 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3365 assert(); } // Block terminates label_3366: // Incoming jump from 0x3364, if !(stack[-2] > 0x03) // Inputs[2] // { // @3367 stack[-2] // @3367 stack[-1] // } 3366 5B JUMPDEST 3367 14 EQ 3368 61 PUSH2 0x337b 336B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x337b, if stack[-1] == stack[-2] label_336C: // Incoming jump from 0x336B, if not stack[-1] == stack[-2] // Inputs[4] // { // @336D stack[-4] // @336D stack[-2] // @336E stack[-6] // @3372 stack[-5] // } 336C 50 POP 336D 91 SWAP2 336E 93 SWAP4 336F 50 POP 3370 60 PUSH1 0x00 3372 92 SWAP3 3373 50 POP 3374 61 PUSH2 0x33bb 3377 91 SWAP2 3378 50 POP 3379 50 POP 337A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @336E stack[-6] = stack[-4] // @3372 stack[-5] = 0x00 // } // Block ends with unconditional jump to 0x33bb label_337B: // Incoming jump from 0x336B, if stack[-1] == stack[-2] // Inputs[3] // { // @337F stack[-3] // @3380 stack[-1] // @3384 storage[0x01 + stack[-1]] // } 337B 5B JUMPDEST 337C 61 PUSH2 0x3389 337F 83 DUP4 3380 82 DUP3 3381 60 PUSH1 0x01 3383 01 ADD 3384 54 SLOAD 3385 61 PUSH2 0x4823 3388 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @337C stack[0] = 0x3389 // @337F stack[1] = stack[-3] // @3384 stack[2] = storage[0x01 + stack[-1]] // } // Block ends with call to 0x4823, returns to 0x3389 label_3389: // Incoming return from call to 0x4823 at 0x3388 // Inputs[4] // { // @338A stack[-2] // @338A stack[-1] // @338B stack[-6] // @338D stack[-4] // } 3389 5B JUMPDEST 338A 90 SWAP1 338B 94 SWAP5 338C 50 POP 338D 91 SWAP2 338E 50 POP 338F 60 PUSH1 0x00 3391 84 DUP5 3392 60 PUSH1 0x03 3394 81 DUP2 3395 11 GT 3396 15 ISZERO 3397 61 PUSH2 0x339c 339A 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @338B stack[-6] = stack[-2] // @338D stack[-4] = stack[-1] // @338F stack[-2] = 0x00 // @3391 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x339c, if !(stack[-2] > 0x03) label_339B: // Incoming jump from 0x339A, if not !(stack[-2] > 0x03) 339B FE *ASSERT // Stack delta = +0 // Outputs[1] { @339B assert(); } // Block terminates label_339C: // Incoming jump from 0x339A, if !(stack[-2] > 0x03) // Inputs[2] // { // @339D stack[-1] // @339D stack[-2] // } 339C 5B JUMPDEST 339D 14 EQ 339E 61 PUSH2 0x33b1 33A1 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x33b1, if stack[-1] == stack[-2] label_33A2: // Incoming jump from 0x33A1, if not stack[-1] == stack[-2] // Inputs[4] // { // @33A3 stack[-4] // @33A3 stack[-2] // @33A4 stack[-6] // @33A8 stack[-5] // } 33A2 50 POP 33A3 91 SWAP2 33A4 93 SWAP4 33A5 50 POP 33A6 60 PUSH1 0x00 33A8 92 SWAP3 33A9 50 POP 33AA 61 PUSH2 0x33bb 33AD 91 SWAP2 33AE 50 POP 33AF 50 POP 33B0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @33A4 stack[-6] = stack[-4] // @33A8 stack[-5] = 0x00 // } // Block ends with unconditional jump to 0x33bb label_33B1: // Incoming jump from 0x33A1, if stack[-1] == stack[-2] // Inputs[3] // { // @33B5 stack[-6] // @33B7 stack[-2] // @33B7 stack[-5] // } 33B1 5B JUMPDEST 33B2 50 POP 33B3 60 PUSH1 0x00 33B5 94 SWAP5 33B6 50 POP 33B7 92 SWAP3 33B8 50 POP 33B9 50 POP 33BA 50 POP // Stack delta = -4 // Outputs[2] // { // @33B5 stack[-6] = 0x00 // @33B7 stack[-5] = stack[-2] // } // Block continues label_33BB: // Incoming jump from 0x3342 // Incoming jump from 0x33BA // Incoming jump from 0x337A // Incoming jump from 0x33B0 // Inputs[4] // { // @33BC stack[-1] // @33BC stack[-3] // @33BE stack[-4] // @33BE stack[-2] // } 33BB 5B JUMPDEST 33BC 91 SWAP2 33BD 50 POP 33BE 91 SWAP2 33BF 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @33BC stack[-3] = stack[-1] // @33BE stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_33C0: // Incoming call from 0x307C, returns to 0x307D // Incoming call from 0x26E1, returns to 0x26E2 // Incoming call from 0x1B58, returns to 0x1B59 // Incoming call from 0x26E1, returns to 0x26E2 // Incoming call from 0x4203, returns to 0x3498 // Incoming call from 0x2755, returns to 0x2756 // Incoming call from 0x3973, returns to 0x3974 // Incoming call from 0x46B8, returns to 0x46B9 // Incoming call from 0x2E8C, returns to 0x2E8D // Incoming call from 0x4631, returns to 0x4632 // Incoming call from 0x2C16, returns to 0x2C17 // Incoming call from 0x2DED, returns to 0x2DEE // Incoming call from 0x2B6D, returns to 0x2B6E // Incoming call from 0x2C66, returns to 0x2C67 // Inputs[2] // { // @33C4 stack[-2] // @33C5 stack[-1] // } 33C0 5B JUMPDEST 33C1 60 PUSH1 0x00 33C3 80 DUP1 33C4 83 DUP4 33C5 83 DUP4 33C6 11 GT 33C7 61 PUSH2 0x33d7 33CA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @33C1 stack[0] = 0x00 // @33C3 stack[1] = 0x00 // } // Block ends with conditional jump to 0x33d7, if stack[-1] > stack[-2] label_33CB: // Incoming jump from 0x33CA, if not stack[-1] > stack[-2] // Inputs[3] // { // @33CE stack[-2] // @33D0 stack[-3] // @33D1 stack[-4] // } 33CB 50 POP 33CC 60 PUSH1 0x00 33CE 90 SWAP1 33CF 50 POP 33D0 81 DUP2 33D1 83 DUP4 33D2 03 SUB 33D3 61 PUSH2 0x257f 33D6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @33CE stack[-2] = 0x00 // @33D2 stack[-1] = stack[-4] - stack[-3] // } // Block ends with unconditional jump to 0x257f label_33D7: // Incoming jump from 0x33CA, if stack[-1] > stack[-2] // Inputs[1] { @33DB stack[-2] } 33D7 5B JUMPDEST 33D8 50 POP 33D9 60 PUSH1 0x03 33DB 90 SWAP1 33DC 50 POP 33DD 60 PUSH1 0x00 33DF 61 PUSH2 0x257f 33E2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @33DB stack[-2] = 0x03 // @33DD stack[-1] = 0x00 // } // Block ends with unconditional jump to 0x257f label_33E3: // Incoming call from 0x306D, returns to 0x2549 // Incoming call from 0x3461, returns to 0x3462 // Incoming call from 0x1BCF, returns to 0x1BD0 33E3 5B JUMPDEST 33E4 60 PUSH1 0x00 33E6 61 PUSH2 0x33ed 33E9 61 PUSH2 0x5357 33EC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @33E4 stack[0] = 0x00 // @33E6 stack[1] = 0x33ed // } // Block ends with call to 0x5357, returns to 0x33ED label_33ED: // Incoming return from call to 0x5357 at 0x33EC // Inputs[3] // { // @33F4 stack[-4] // @33F8 memory[0x00 + stack[-4]:0x00 + stack[-4] + 0x20] // @33F9 stack[-3] // } 33ED 5B JUMPDEST 33EE 60 PUSH1 0x00 33F0 80 DUP1 33F1 61 PUSH2 0x33fe 33F4 86 DUP7 33F5 60 PUSH1 0x00 33F7 01 ADD 33F8 51 MLOAD 33F9 86 DUP7 33FA 61 PUSH2 0x47e4 33FD 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @33EE stack[0] = 0x00 // @33F0 stack[1] = 0x00 // @33F1 stack[2] = 0x33fe // @33F8 stack[3] = memory[0x00 + stack[-4]:0x00 + stack[-4] + 0x20] // @33F9 stack[4] = stack[-3] // } // Block ends with call to 0x47e4, returns to 0x33FE label_33FE: // Incoming return from call to 0x47E4 at 0x33FD // Inputs[4] // { // @33FF stack[-2] // @33FF stack[-1] // @3400 stack[-4] // @3402 stack[-3] // } 33FE 5B JUMPDEST 33FF 90 SWAP1 3400 92 SWAP3 3401 50 POP 3402 90 SWAP1 3403 50 POP 3404 60 PUSH1 0x00 3406 82 DUP3 3407 60 PUSH1 0x03 3409 81 DUP2 340A 11 GT 340B 15 ISZERO 340C 61 PUSH2 0x3411 340F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @3400 stack[-4] = stack[-2] // @3402 stack[-3] = stack[-1] // @3404 stack[-2] = 0x00 // @3406 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x3411, if !(stack[-2] > 0x03) label_3410: // Incoming jump from 0x340F, if not !(stack[-2] > 0x03) 3410 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3410 assert(); } // Block terminates label_3411: // Incoming jump from 0x340F, if !(stack[-2] > 0x03) // Inputs[2] // { // @3412 stack[-2] // @3412 stack[-1] // } 3411 5B JUMPDEST 3412 14 EQ 3413 61 PUSH2 0x3430 3416 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3430, if stack[-1] == stack[-2] label_3417: // Incoming jump from 0x3416, if not stack[-1] == stack[-2] // Inputs[4] // { // @341B memory[0x40:0x60] // @3427 stack[-2] // @3428 stack[-4] // @342A stack[-3] // } 3417 50 POP 3418 60 PUSH1 0x40 341A 80 DUP1 341B 51 MLOAD 341C 60 PUSH1 0x20 341E 81 DUP2 341F 01 ADD 3420 90 SWAP1 3421 91 SWAP2 3422 52 MSTORE 3423 60 PUSH1 0x00 3425 81 DUP2 3426 52 MSTORE 3427 90 SWAP1 3428 92 SWAP3 3429 50 POP 342A 90 SWAP1 342B 50 POP 342C 61 PUSH2 0x257f 342F 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @3422 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @3426 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @3428 stack[-4] = stack[-2] // @342A stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x257f label_3430: // Incoming jump from 0x3416, if stack[-1] == stack[-2] // Inputs[5] // { // @3434 memory[0x40:0x60] // @343C stack[-1] // @3441 stack[-7] // @3443 stack[-6] // @3445 stack[-5] // } 3430 5B JUMPDEST 3431 60 PUSH1 0x40 3433 80 DUP1 3434 51 MLOAD 3435 60 PUSH1 0x20 3437 81 DUP2 3438 01 ADD 3439 90 SWAP1 343A 91 SWAP2 343B 52 MSTORE 343C 90 SWAP1 343D 81 DUP2 343E 52 MSTORE 343F 60 PUSH1 0x00 3441 96 SWAP7 3442 90 SWAP1 3443 95 SWAP6 3444 50 POP 3445 93 SWAP4 3446 50 POP 3447 50 POP 3448 50 POP 3449 50 POP 344A 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @343B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @343E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @3441 stack[-7] = 0x00 // @3443 stack[-6] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-7] label_344B: // Incoming call from 0x1CF1, returns to 0x1CF2 // Incoming call from 0x1D4D, returns to 0x1D4E 344B 5B JUMPDEST 344C 60 PUSH1 0x00 344E 80 DUP1 344F 60 PUSH1 0x00 3451 61 PUSH2 0x3458 3454 61 PUSH2 0x5357 3457 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @344C stack[0] = 0x00 // @344E stack[1] = 0x00 // @344F stack[2] = 0x00 // @3451 stack[3] = 0x3458 // } // Block ends with call to 0x5357, returns to 0x3458 label_3458: // Incoming return from call to 0x5357 at 0x3457 // Inputs[2] // { // @345C stack[-7] // @345D stack[-6] // } 3458 5B JUMPDEST 3459 61 PUSH2 0x3462 345C 87 DUP8 345D 87 DUP8 345E 61 PUSH2 0x33e3 3461 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3459 stack[0] = 0x3462 // @345C stack[1] = stack[-7] // @345D stack[2] = stack[-6] // } // Block ends with call to 0x33e3, returns to 0x3462 label_3462: // Incoming return from call to 0x33E3 at 0x3461 // Inputs[4] // { // @3463 stack[-2] // @3463 stack[-1] // @3464 stack[-4] // @3466 stack[-3] // } 3462 5B JUMPDEST 3463 90 SWAP1 3464 92 SWAP3 3465 50 POP 3466 90 SWAP1 3467 50 POP 3468 60 PUSH1 0x00 346A 82 DUP3 346B 60 PUSH1 0x03 346D 81 DUP2 346E 11 GT 346F 15 ISZERO 3470 61 PUSH2 0x3475 3473 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @3464 stack[-4] = stack[-2] // @3466 stack[-3] = stack[-1] // @3468 stack[-2] = 0x00 // @346A stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x3475, if !(stack[-2] > 0x03) label_3474: // Incoming jump from 0x3473, if not !(stack[-2] > 0x03) 3474 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3474 assert(); } // Block terminates label_3475: // Incoming jump from 0x3473, if !(stack[-2] > 0x03) // Inputs[2] // { // @3476 stack[-1] // @3476 stack[-2] // } 3475 5B JUMPDEST 3476 14 EQ 3477 61 PUSH2 0x3486 347A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3486, if stack[-1] == stack[-2] label_347B: // Incoming jump from 0x347A, if not stack[-1] == stack[-2] // Inputs[3] // { // @347C stack[-4] // @347C stack[-2] // @3480 stack[-3] // } 347B 50 POP 347C 91 SWAP2 347D 50 POP 347E 60 PUSH1 0x00 3480 90 SWAP1 3481 50 POP 3482 61 PUSH2 0x349f 3485 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @347C stack[-4] = stack[-2] // @3480 stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x349f label_3486: // Incoming jump from 0x347A, if stack[-1] == stack[-2] // Inputs[1] { @348D stack[-1] } 3486 5B JUMPDEST 3487 61 PUSH2 0x3498 348A 61 PUSH2 0x3492 348D 82 DUP3 348E 61 PUSH2 0x4313 3491 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3487 stack[0] = 0x3498 // @348A stack[1] = 0x3492 // @348D stack[2] = stack[-1] // } // Block ends with call to 0x4313, returns to 0x3492 label_3492: // Incoming return from call to 0x4313 at 0x3491 // Inputs[1] { @3493 stack[-7] } 3492 5B JUMPDEST 3493 86 DUP7 3494 61 PUSH2 0x2586 3497 56 *JUMP // Stack delta = +1 // Outputs[1] { @3493 stack[0] = stack[-7] } // Block ends with unconditional jump to 0x2586 label_3498: // Incoming return from call to 0x33C0 at 0x4203 // Incoming return from call to 0x3492 at 0x3491 // Inputs[4] // { // @3499 stack[-5] // @3499 stack[-1] // @349B stack[-2] // @349B stack[-6] // } 3498 5B JUMPDEST 3499 93 SWAP4 349A 50 POP 349B 93 SWAP4 349C 50 POP 349D 50 POP 349E 50 POP // Stack delta = -4 // Outputs[2] // { // @3499 stack[-5] = stack[-1] // @349B stack[-6] = stack[-2] // } // Block continues label_349F: // Incoming jump from 0x349E // Incoming jump from 0x41F9 // Incoming jump from 0x3485 // Inputs[5] // { // @34A0 stack[-5] // @34A0 stack[-1] // @34A2 stack[-2] // @34A2 stack[-6] // @34A3 stack[-4] // } 349F 5B JUMPDEST 34A0 93 SWAP4 34A1 50 POP 34A2 93 SWAP4 34A3 91 SWAP2 34A4 50 POP 34A5 50 POP 34A6 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @34A0 stack[-5] = stack[-1] // @34A2 stack[-6] = stack[-2] // } // Block ends with unconditional jump to stack[-6] label_34A7: // Incoming call from 0x1E53, returns to 0x1E54 // Inputs[1] { @34AB storage[0x00] } 34A7 5B JUMPDEST 34A8 60 PUSH1 0x00 34AA 80 DUP1 34AB 54 SLOAD 34AC 81 DUP2 34AD 90 SWAP1 34AE 62 PUSH3 0x010000 34B2 90 SWAP1 34B3 04 DIV 34B4 60 PUSH1 0xff 34B6 16 AND 34B7 61 PUSH2 0x34f3 34BA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @34A8 stack[0] = 0x00 // @34AD stack[1] = 0x00 // } // Block ends with conditional jump to 0x34f3, if 0xff & storage[0x00] / 0x010000 label_34BB: // Incoming jump from 0x34BA, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @34BE memory[0x40:0x60] // @34E9 memory[0x40:0x60] // @34F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 34BB 60 PUSH1 0x40 34BD 80 DUP1 34BE 51 MLOAD 34BF 60 PUSH1 0x01 34C1 60 PUSH1 0xe5 34C3 1B SHL 34C4 62 PUSH3 0x461bcd 34C8 02 MUL 34C9 81 DUP2 34CA 52 MSTORE 34CB 60 PUSH1 0x20 34CD 60 PUSH1 0x04 34CF 82 DUP3 34D0 01 ADD 34D1 52 MSTORE 34D2 60 PUSH1 0x03 34D4 60 PUSH1 0x24 34D6 82 DUP3 34D7 01 ADD 34D8 52 MSTORE 34D9 60 PUSH1 0x01 34DB 60 PUSH1 0xe8 34DD 1B SHL 34DE 62 PUSH3 0x453637 34E2 02 MUL 34E3 60 PUSH1 0x44 34E5 82 DUP3 34E6 01 ADD 34E7 52 MSTORE 34E8 90 SWAP1 34E9 51 MLOAD 34EA 90 SWAP1 34EB 81 DUP2 34EC 90 SWAP1 34ED 03 SUB 34EE 60 PUSH1 0x64 34F0 01 ADD 34F1 90 SWAP1 34F2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @34CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @34D1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @34D8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @34E7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @34F2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_34F3: // Incoming jump from 0x34BA, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @34F7 storage[0x00] } 34F3 5B JUMPDEST 34F4 60 PUSH1 0x00 34F6 80 DUP1 34F7 54 SLOAD 34F8 62 PUSH3 0xff0000 34FC 19 NOT 34FD 16 AND 34FE 81 DUP2 34FF 55 SSTORE 3500 61 PUSH2 0x3507 3503 61 PUSH2 0x1a38 3506 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @34F4 stack[0] = 0x00 // @34FF storage[0x00] = ~0xff0000 & storage[0x00] // @3500 stack[1] = 0x3507 // } // Block ends with call to 0x1a38, returns to 0x3507 label_3507: // Incoming return from call to 0x1A38 at 0x3506 // Incoming return from call to 0x1A38 at 0x3506 // Inputs[2] // { // @3508 stack[-1] // @3508 stack[-2] // } 3507 5B JUMPDEST 3508 90 SWAP1 3509 50 POP 350A 80 DUP1 350B 15 ISZERO 350C 61 PUSH2 0x3547 350F 57 *JUMPI // Stack delta = -1 // Outputs[1] { @3508 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x3547, if !stack[-1] label_3510: // Incoming jump from 0x350F, if not !stack[-1] // Inputs[3] // { // @3513 memory[0x40:0x60] // @353D memory[0x40:0x60] // @3546 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3510 60 PUSH1 0x40 3512 80 DUP1 3513 51 MLOAD 3514 60 PUSH1 0x01 3516 60 PUSH1 0xe5 3518 1B SHL 3519 62 PUSH3 0x461bcd 351D 02 MUL 351E 81 DUP2 351F 52 MSTORE 3520 60 PUSH1 0x20 3522 60 PUSH1 0x04 3524 82 DUP3 3525 01 ADD 3526 52 MSTORE 3527 60 PUSH1 0x02 3529 60 PUSH1 0x24 352B 82 DUP3 352C 01 ADD 352D 52 MSTORE 352E 60 PUSH1 0x01 3530 60 PUSH1 0xf0 3532 1B SHL 3533 61 PUSH2 0x4535 3536 02 MUL 3537 60 PUSH1 0x44 3539 82 DUP3 353A 01 ADD 353B 52 MSTORE 353C 90 SWAP1 353D 51 MLOAD 353E 90 SWAP1 353F 81 DUP2 3540 90 SWAP1 3541 03 SUB 3542 60 PUSH1 0x64 3544 01 ADD 3545 90 SWAP1 3546 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @351F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3526 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @352D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @353B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @3546 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3547: // Incoming jump from 0x350F, if !stack[-1] // Inputs[4] // { // @3548 stack[-4] // @3559 memory[0x40:0x60] // @356D memory[0x40:0x60] // @3576 address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length // } 3547 5B JUMPDEST 3548 83 DUP4 3549 60 PUSH1 0x01 354B 60 PUSH1 0x01 354D 60 PUSH1 0xa0 354F 1B SHL 3550 03 SUB 3551 16 AND 3552 63 PUSH4 0xa6afed95 3557 60 PUSH1 0x40 3559 51 MLOAD 355A 81 DUP2 355B 63 PUSH4 0xffffffff 3560 16 AND 3561 60 PUSH1 0xe0 3563 1B SHL 3564 81 DUP2 3565 52 MSTORE 3566 60 PUSH1 0x04 3568 01 ADD 3569 60 PUSH1 0x20 356B 60 PUSH1 0x40 356D 51 MLOAD 356E 80 DUP1 356F 83 DUP4 3570 03 SUB 3571 81 DUP2 3572 60 PUSH1 0x00 3574 87 DUP8 3575 80 DUP1 3576 3B EXTCODESIZE 3577 15 ISZERO 3578 80 DUP1 3579 15 ISZERO 357A 61 PUSH2 0x3582 357D 57 *JUMPI // Stack delta = +10 // Outputs[11] // { // @3551 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-4] // @3552 stack[1] = 0xa6afed95 // @3565 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0xa6afed95) << 0xe0 // @3568 stack[2] = 0x04 + memory[0x40:0x60] // @3569 stack[3] = 0x20 // @356D stack[4] = memory[0x40:0x60] // @3570 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3571 stack[6] = memory[0x40:0x60] // @3572 stack[7] = 0x00 // @3574 stack[8] = (0x01 << 0xa0) - 0x01 & stack[-4] // @3577 stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length // } // Block ends with conditional jump to 0x3582, if !!address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length label_357E: // Incoming jump from 0x357D, if not !!address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length // Inputs[1] { @3581 memory[0x00:0x00] } 357E 60 PUSH1 0x00 3580 80 DUP1 3581 FD *REVERT // Stack delta = +0 // Outputs[1] { @3581 revert(memory[0x00:0x00]); } // Block terminates label_3582: // Incoming jump from 0x357D, if !!address((0x01 << 0xa0) - 0x01 & stack[-4]).code.length // Inputs[9] // { // @3584 msg.gas // @3585 stack[-4] // @3585 stack[-3] // @3585 stack[-2] // @3585 stack[-5] // @3585 stack[-7] // @3585 stack[-6] // @3585 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3585 memory[stack[-4]:stack[-4] + stack[-5]] // } 3582 5B JUMPDEST 3583 50 POP 3584 5A GAS 3585 F1 CALL 3586 15 ISZERO 3587 80 DUP1 3588 15 ISZERO 3589 61 PUSH2 0x3596 358C 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @3585 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3586 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x3596, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_358D: // Incoming jump from 0x358C, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @358D returndata.length // @3591 returndata[0x00:0x00 + returndata.length] // @3592 returndata.length // @3595 memory[0x00:0x00 + returndata.length] // } 358D 3D RETURNDATASIZE 358E 60 PUSH1 0x00 3590 80 DUP1 3591 3E RETURNDATACOPY 3592 3D RETURNDATASIZE 3593 60 PUSH1 0x00 3595 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3591 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3595 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3596: // Incoming jump from 0x358C, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @359D memory[0x40:0x60] // @359E returndata.length // } 3596 5B JUMPDEST 3597 50 POP 3598 50 POP 3599 50 POP 359A 50 POP 359B 60 PUSH1 0x40 359D 51 MLOAD 359E 3D RETURNDATASIZE 359F 60 PUSH1 0x20 35A1 81 DUP2 35A2 10 LT 35A3 15 ISZERO 35A4 61 PUSH2 0x35ac 35A7 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @359D stack[-4] = memory[0x40:0x60] // @359E stack[-3] = returndata.length // } // Block ends with conditional jump to 0x35ac, if !(returndata.length < 0x20) label_35A8: // Incoming jump from 0x35A7, if not !(returndata.length < 0x20) // Inputs[1] { @35AB memory[0x00:0x00] } 35A8 60 PUSH1 0x00 35AA 80 DUP1 35AB FD *REVERT // Stack delta = +0 // Outputs[1] { @35AB revert(memory[0x00:0x00]); } // Block terminates label_35AC: // Incoming jump from 0x35A7, if !(returndata.length < 0x20) // Inputs[3] // { // @35AE stack[-2] // @35AE memory[stack[-2]:stack[-2] + 0x20] // @35AF stack[-3] // } 35AC 5B JUMPDEST 35AD 50 POP 35AE 51 MLOAD 35AF 90 SWAP1 35B0 50 POP 35B1 80 DUP1 35B2 15 ISZERO 35B3 61 PUSH2 0x35ee 35B6 57 *JUMPI // Stack delta = -2 // Outputs[1] { @35AF stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x35ee, if !memory[stack[-2]:stack[-2] + 0x20] label_35B7: // Incoming jump from 0x35B6, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @35BA memory[0x40:0x60] // @35E4 memory[0x40:0x60] // @35ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 35B7 60 PUSH1 0x40 35B9 80 DUP1 35BA 51 MLOAD 35BB 60 PUSH1 0x01 35BD 60 PUSH1 0xe5 35BF 1B SHL 35C0 62 PUSH3 0x461bcd 35C4 02 MUL 35C5 81 DUP2 35C6 52 MSTORE 35C7 60 PUSH1 0x20 35C9 60 PUSH1 0x04 35CB 82 DUP3 35CC 01 ADD 35CD 52 MSTORE 35CE 60 PUSH1 0x02 35D0 60 PUSH1 0x24 35D2 82 DUP3 35D3 01 ADD 35D4 52 MSTORE 35D5 60 PUSH1 0x01 35D7 60 PUSH1 0xf0 35D9 1B SHL 35DA 61 PUSH2 0x4535 35DD 02 MUL 35DE 60 PUSH1 0x44 35E0 82 DUP3 35E1 01 ADD 35E2 52 MSTORE 35E3 90 SWAP1 35E4 51 MLOAD 35E5 90 SWAP1 35E6 81 DUP2 35E7 90 SWAP1 35E8 03 SUB 35E9 60 PUSH1 0x64 35EB 01 ADD 35EC 90 SWAP1 35ED FD *REVERT // Stack delta = +0 // Outputs[5] // { // @35C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @35CD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @35D4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @35E2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @35ED revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_35EE: // Incoming jump from 0x35B6, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @35F2 msg.sender // @35F3 stack[-6] // @35F4 stack[-5] // @35F5 stack[-4] // } 35EE 5B JUMPDEST 35EF 61 PUSH2 0x35fa 35F2 33 CALLER 35F3 87 DUP8 35F4 87 DUP8 35F5 87 DUP8 35F6 61 PUSH2 0x484e 35F9 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @35EF stack[0] = 0x35fa // @35F2 stack[1] = msg.sender // @35F3 stack[2] = stack[-6] // @35F4 stack[3] = stack[-5] // @35F5 stack[4] = stack[-4] // } // Block ends with call to 0x484e, returns to 0x35FA label_35FA: // Incoming return from call to 0x484E at 0x35F9 // Inputs[8] // { // @35FB stack[-1] // @35FB stack[-4] // @35FD stack[-5] // @35FD stack[-2] // @3603 storage[0x00] // @3612 stack[-9] // @3614 stack[-8] // @3616 stack[-7] // } 35FA 5B JUMPDEST 35FB 92 SWAP3 35FC 50 POP 35FD 92 SWAP3 35FE 50 POP 35FF 50 POP 3600 60 PUSH1 0x00 3602 80 DUP1 3603 54 SLOAD 3604 62 PUSH3 0xff0000 3608 19 NOT 3609 16 AND 360A 62 PUSH3 0x010000 360E 17 OR 360F 90 SWAP1 3610 55 SSTORE 3611 90 SWAP1 3612 94 SWAP5 3613 90 SWAP1 3614 93 SWAP4 3615 50 POP 3616 91 SWAP2 3617 50 POP 3618 50 POP 3619 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @3610 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @3612 stack[-9] = stack[-2] // @3614 stack[-8] = stack[-1] // } // Block ends with unconditional jump to stack[-9] label_361A: // Incoming call from 0x2231, returns to 0x2232 // Incoming call from 0x1E7E, returns to 0x1E7F // Inputs[1] { @361B stack[-2] } 361A 5B JUMPDEST 361B 81 DUP2 361C 61 PUSH2 0x3624 361F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3624, if stack[-2] label_3620: // Incoming jump from 0x361F, if not stack[-2] 3620 61 PUSH2 0x2232 3623 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2232 label_3624: // Incoming jump from 0x361F, if stack[-2] // Inputs[3] // { // @3627 stack[-1] // @3628 memory[stack[-1]:stack[-1] + 0x20] // @362E memory[0x40:0x60] // } 3624 5B JUMPDEST 3625 60 PUSH1 0x60 3627 81 DUP2 3628 51 MLOAD 3629 60 PUSH1 0x05 362B 01 ADD 362C 60 PUSH1 0x40 362E 51 MLOAD 362F 90 SWAP1 3630 80 DUP1 3631 82 DUP3 3632 52 MSTORE 3633 80 DUP1 3634 60 PUSH1 0x1f 3636 01 ADD 3637 60 PUSH1 0x1f 3639 19 NOT 363A 16 AND 363B 60 PUSH1 0x20 363D 01 ADD 363E 82 DUP3 363F 01 ADD 3640 60 PUSH1 0x40 3642 52 MSTORE 3643 80 DUP1 3644 15 ISZERO 3645 61 PUSH2 0x3655 3648 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @3625 stack[0] = 0x60 // @362F stack[1] = memory[0x40:0x60] // @362F stack[2] = 0x05 + memory[stack[-1]:stack[-1] + 0x20] // @3632 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x05 + memory[stack[-1]:stack[-1] + 0x20] // @3642 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + 0x05 + memory[stack[-1]:stack[-1] + 0x20]) // } // Block ends with conditional jump to 0x3655, if !(0x05 + memory[stack[-1]:stack[-1] + 0x20]) label_3649: // Incoming jump from 0x3648, if not !(0x05 + memory[stack[-1]:stack[-1] + 0x20]) // Inputs[6] // { // @364B stack[-2] // @364D stack[-1] // @364F code.length // @3657 stack[-3] // @365C stack[-4] // @365D memory[stack[-4]:stack[-4] + 0x20] // } 3649 60 PUSH1 0x20 364B 82 DUP3 364C 01 ADD 364D 81 DUP2 364E 80 DUP1 364F 38 CODESIZE 3650 83 DUP4 3651 39 CODECOPY 3652 01 ADD 3653 90 SWAP1 3654 50 POP 3655 5B JUMPDEST 3656 50 POP 3657 90 SWAP1 3658 50 POP 3659 60 PUSH1 0x00 365B 5B JUMPDEST 365C 82 DUP3 365D 51 MLOAD 365E 81 DUP2 365F 10 LT 3660 15 ISZERO 3661 61 PUSH2 0x36a6 3664 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @3651 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = code[code.length:code.length + stack[-1]] // @3657 stack[-3] = stack[-2] // @3659 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x36a6, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) label_3665: // Incoming jump from 0x3664, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x3664, if not !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x3664, if not !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @3665 stack[-3] // @3666 stack[-1] // @3668 memory[stack[-3]:stack[-3] + 0x20] // } 3665 82 DUP3 3666 81 DUP2 3667 81 DUP2 3668 51 MLOAD 3669 81 DUP2 366A 10 LT 366B 61 PUSH2 0x3670 366E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3665 stack[0] = stack[-3] // @3666 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x3670, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] label_366F: // Incoming jump from 0x366E, if not stack[-1] < memory[stack[-3]:stack[-3] + 0x20] 366F FE *ASSERT // Stack delta = +0 // Outputs[1] { @366F assert(); } // Block terminates label_3670: // Incoming jump from 0x366E, if stack[-1] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[6] // { // @3673 stack[-1] // @3674 stack[-2] // @3675 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @367C stack[-4] // @367D stack[-3] // @367F memory[stack[-4]:stack[-4] + 0x20] // } 3670 5B JUMPDEST 3671 60 PUSH1 0x20 3673 01 ADD 3674 01 ADD 3675 51 MLOAD 3676 60 PUSH1 0xf8 3678 1C SHR 3679 60 PUSH1 0xf8 367B 1B SHL 367C 82 DUP3 367D 82 DUP3 367E 81 DUP2 367F 51 MLOAD 3680 81 DUP2 3681 10 LT 3682 61 PUSH2 0x3687 3685 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @367B stack[-2] = (memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8) << 0xf8 // @367C stack[-1] = stack[-4] // @367D stack[0] = stack[-3] // } // Block ends with conditional jump to 0x3687, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_3686: // Incoming jump from 0x3685, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 3686 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3686 assert(); } // Block terminates label_3687: // Incoming jump from 0x3685, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @368A stack[-1] // @368B stack[-2] // @368C stack[-3] // @36A1 stack[-4] // } 3687 5B JUMPDEST 3688 60 PUSH1 0x20 368A 01 ADD 368B 01 ADD 368C 90 SWAP1 368D 60 PUSH1 0x01 368F 60 PUSH1 0x01 3691 60 PUSH1 0xf8 3693 1B SHL 3694 03 SUB 3695 19 NOT 3696 16 AND 3697 90 SWAP1 3698 81 DUP2 3699 60 PUSH1 0x00 369B 1A BYTE 369C 90 SWAP1 369D 53 MSTORE8 369E 50 POP 369F 60 PUSH1 0x01 36A1 01 ADD 36A2 61 PUSH2 0x365b 36A5 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @369D memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @36A1 stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x365b label_36A6: // Incoming jump from 0x3664, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x3664, if !(0x00 < memory[stack[-4]:stack[-4] + 0x20]) // Incoming jump from 0x3664, if !(stack[-1] < memory[stack[-3]:stack[-3] + 0x20]) // Inputs[3] // { // @36A7 stack[-2] // @36A8 memory[stack[-2]:stack[-2] + 0x20] // @36B1 stack[-1] // } 36A6 5B JUMPDEST 36A7 81 DUP2 36A8 51 MLOAD 36A9 60 PUSH1 0x01 36AB 60 PUSH1 0xfd 36AD 1B SHL 36AE 90 SWAP1 36AF 83 DUP4 36B0 90 SWAP1 36B1 83 DUP4 36B2 90 SWAP1 36B3 81 DUP2 36B4 10 LT 36B5 61 PUSH2 0x36ba 36B8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @36AE stack[0] = 0x01 << 0xfd // @36B0 stack[1] = stack[-2] // @36B2 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x36ba, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_36B9: // Incoming jump from 0x36B8, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 36B9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @36B9 assert(); } // Block terminates label_36BA: // Incoming jump from 0x36B8, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[6] // { // @36BD stack[-1] // @36BE stack[-2] // @36BF stack[-3] // @36D7 stack[-5] // @36D8 stack[-4] // @36DD memory[stack[-5]:stack[-5] + 0x20] // } 36BA 5B JUMPDEST 36BB 60 PUSH1 0x20 36BD 01 ADD 36BE 01 ADD 36BF 90 SWAP1 36C0 60 PUSH1 0x01 36C2 60 PUSH1 0x01 36C4 60 PUSH1 0xf8 36C6 1B SHL 36C7 03 SUB 36C8 19 NOT 36C9 16 AND 36CA 90 SWAP1 36CB 81 DUP2 36CC 60 PUSH1 0x00 36CE 1A BYTE 36CF 90 SWAP1 36D0 53 MSTORE8 36D1 50 POP 36D2 60 PUSH1 0x28 36D4 60 PUSH1 0xf8 36D6 1B SHL 36D7 82 DUP3 36D8 82 DUP3 36D9 60 PUSH1 0x01 36DB 01 ADD 36DC 81 DUP2 36DD 51 MLOAD 36DE 81 DUP2 36DF 10 LT 36E0 61 PUSH2 0x36e5 36E3 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @36D0 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @36D6 stack[-3] = 0x28 << 0xf8 // @36D7 stack[-2] = stack[-5] // @36DB stack[-1] = 0x01 + stack[-4] // } // Block ends with conditional jump to 0x36e5, if 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_36E4: // Incoming jump from 0x36E3, if not 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] 36E4 FE *ASSERT // Stack delta = +0 // Outputs[1] { @36E4 assert(); } // Block terminates label_36E5: // Incoming jump from 0x36E3, if 0x01 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[7] // { // @36E8 stack[-1] // @36E9 stack[-2] // @36EA stack[-3] // @36FF stack[-7] // @3707 stack[-5] // @3708 stack[-4] // @370D memory[stack[-5]:stack[-5] + 0x20] // } 36E5 5B JUMPDEST 36E6 60 PUSH1 0x20 36E8 01 ADD 36E9 01 ADD 36EA 90 SWAP1 36EB 60 PUSH1 0x01 36ED 60 PUSH1 0x01 36EF 60 PUSH1 0xf8 36F1 1B SHL 36F2 03 SUB 36F3 19 NOT 36F4 16 AND 36F5 90 SWAP1 36F6 81 DUP2 36F7 60 PUSH1 0x00 36F9 1A BYTE 36FA 90 SWAP1 36FB 53 MSTORE8 36FC 50 POP 36FD 60 PUSH1 0x0a 36FF 84 DUP5 3700 04 DIV 3701 60 PUSH1 0x30 3703 01 ADD 3704 60 PUSH1 0xf8 3706 1B SHL 3707 82 DUP3 3708 82 DUP3 3709 60 PUSH1 0x02 370B 01 ADD 370C 81 DUP2 370D 51 MLOAD 370E 81 DUP2 370F 10 LT 3710 61 PUSH2 0x3715 3713 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @36FB memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @3706 stack[-3] = 0x30 + stack[-7] / 0x0a << 0xf8 // @3707 stack[-2] = stack[-5] // @370B stack[-1] = 0x02 + stack[-4] // } // Block ends with conditional jump to 0x3715, if 0x02 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_3714: // Incoming jump from 0x3713, if not 0x02 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] 3714 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3714 assert(); } // Block terminates label_3715: // Incoming jump from 0x3713, if 0x02 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[7] // { // @3718 stack[-1] // @3719 stack[-2] // @371A stack[-3] // @372F stack[-7] // @3737 stack[-5] // @3738 stack[-4] // @373D memory[stack[-5]:stack[-5] + 0x20] // } 3715 5B JUMPDEST 3716 60 PUSH1 0x20 3718 01 ADD 3719 01 ADD 371A 90 SWAP1 371B 60 PUSH1 0x01 371D 60 PUSH1 0x01 371F 60 PUSH1 0xf8 3721 1B SHL 3722 03 SUB 3723 19 NOT 3724 16 AND 3725 90 SWAP1 3726 81 DUP2 3727 60 PUSH1 0x00 3729 1A BYTE 372A 90 SWAP1 372B 53 MSTORE8 372C 50 POP 372D 60 PUSH1 0x0a 372F 84 DUP5 3730 06 MOD 3731 60 PUSH1 0x30 3733 01 ADD 3734 60 PUSH1 0xf8 3736 1B SHL 3737 82 DUP3 3738 82 DUP3 3739 60 PUSH1 0x03 373B 01 ADD 373C 81 DUP2 373D 51 MLOAD 373E 81 DUP2 373F 10 LT 3740 61 PUSH2 0x3745 3743 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @372B memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @3736 stack[-3] = 0x30 + stack[-7] % 0x0a << 0xf8 // @3737 stack[-2] = stack[-5] // @373B stack[-1] = 0x03 + stack[-4] // } // Block ends with conditional jump to 0x3745, if 0x03 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_3744: // Incoming jump from 0x3743, if not 0x03 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] 3744 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3744 assert(); } // Block terminates label_3745: // Incoming jump from 0x3743, if 0x03 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @3748 stack[-1] // @3749 stack[-2] // @374A stack[-3] // @3762 stack[-5] // @3763 stack[-4] // @3768 memory[stack[-5]:stack[-5] + 0x20] // } 3745 5B JUMPDEST 3746 60 PUSH1 0x20 3748 01 ADD 3749 01 ADD 374A 90 SWAP1 374B 60 PUSH1 0x01 374D 60 PUSH1 0x01 374F 60 PUSH1 0xf8 3751 1B SHL 3752 03 SUB 3753 19 NOT 3754 16 AND 3755 90 SWAP1 3756 81 DUP2 3757 60 PUSH1 0x00 3759 1A BYTE 375A 90 SWAP1 375B 53 MSTORE8 375C 50 POP 375D 60 PUSH1 0x29 375F 60 PUSH1 0xf8 3761 1B SHL 3762 82 DUP3 3763 82 DUP3 3764 60 PUSH1 0x04 3766 01 ADD 3767 81 DUP2 3768 51 MLOAD 3769 81 DUP2 376A 10 LT 376B 61 PUSH2 0x3770 376E 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @375B memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @3761 stack[-3] = 0x29 << 0xf8 // @3762 stack[-2] = stack[-5] // @3766 stack[-1] = 0x04 + stack[-4] // } // Block ends with conditional jump to 0x3770, if 0x04 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_376F: // Incoming jump from 0x376E, if not 0x04 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] 376F FE *ASSERT // Stack delta = +0 // Outputs[1] { @376F assert(); } // Block terminates label_3770: // Incoming jump from 0x376E, if 0x04 + stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @3773 stack[-1] // @3774 stack[-2] // @3775 stack[-3] // @3788 stack[-5] // @3789 stack[-7] // } 3770 5B JUMPDEST 3771 60 PUSH1 0x20 3773 01 ADD 3774 01 ADD 3775 90 SWAP1 3776 60 PUSH1 0x01 3778 60 PUSH1 0x01 377A 60 PUSH1 0xf8 377C 1B SHL 377D 03 SUB 377E 19 NOT 377F 16 AND 3780 90 SWAP1 3781 81 DUP2 3782 60 PUSH1 0x00 3784 1A BYTE 3785 90 SWAP1 3786 53 MSTORE8 3787 50 POP 3788 81 DUP2 3789 84 DUP5 378A 15 ISZERO 378B 61 PUSH2 0x3815 378E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3786 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @3788 stack[-3] = stack[-5] // } // Block ends with conditional jump to 0x3815, if !stack[-7] label_378F: // Incoming jump from 0x378E, if not !stack[-7] // Inputs[4] // { // @3791 memory[0x40:0x60] // @37AB stack[-1] // @37AE memory[stack[-1]:stack[-1] + 0x20] // @37B7 memory[stack[-1]:stack[-1] + 0x20] // } 378F 60 PUSH1 0x40 3791 51 MLOAD 3792 60 PUSH1 0x01 3794 60 PUSH1 0xe5 3796 1B SHL 3797 62 PUSH3 0x461bcd 379B 02 MUL 379C 81 DUP2 379D 52 MSTORE 379E 60 PUSH1 0x04 37A0 01 ADD 37A1 80 DUP1 37A2 80 DUP1 37A3 60 PUSH1 0x20 37A5 01 ADD 37A6 82 DUP3 37A7 81 DUP2 37A8 03 SUB 37A9 82 DUP3 37AA 52 MSTORE 37AB 83 DUP4 37AC 81 DUP2 37AD 81 DUP2 37AE 51 MLOAD 37AF 81 DUP2 37B0 52 MSTORE 37B1 60 PUSH1 0x20 37B3 01 ADD 37B4 91 SWAP2 37B5 50 POP 37B6 80 DUP1 37B7 51 MLOAD 37B8 90 SWAP1 37B9 60 PUSH1 0x20 37BB 01 ADD 37BC 90 SWAP1 37BD 80 DUP1 37BE 83 DUP4 37BF 83 DUP4 37C0 60 PUSH1 0x00 37C2 5B JUMPDEST 37C3 83 DUP4 37C4 81 DUP2 37C5 10 LT 37C6 15 ISZERO 37C7 61 PUSH2 0x37da 37CA 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @379D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @37A0 stack[0] = 0x04 + memory[0x40:0x60] // @37A1 stack[1] = 0x04 + memory[0x40:0x60] // @37AA memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @37B0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @37B4 stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @37BC stack[3] = 0x20 + stack[-1] // @37BC stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @37BD stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @37BE stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @37BF stack[7] = 0x20 + stack[-1] // @37C0 stack[8] = 0x00 // } // Block ends with conditional jump to 0x37da, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_37CB: // Incoming jump from 0x37CA, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x37CA, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @37CB stack[-2] // @37CC stack[-1] // @37CE memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @37CF stack[-3] // } 37CB 81 DUP2 37CC 81 DUP2 37CD 01 ADD 37CE 51 MLOAD 37CF 83 DUP4 37D0 82 DUP3 37D1 01 ADD 37D2 52 MSTORE 37D3 60 PUSH1 0x20 37D5 01 ADD 37D6 61 PUSH2 0x37c2 37D9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @37D2 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @37D5 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x37c2 label_37DA: // Incoming jump from 0x37CA, if !(stack[-1] < stack[-4]) // Incoming jump from 0x37CA, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @37DF stack[-5] // @37DF stack[-6] // @37E1 stack[-7] // } 37DA 5B JUMPDEST 37DB 50 POP 37DC 50 POP 37DD 50 POP 37DE 50 POP 37DF 90 SWAP1 37E0 50 POP 37E1 90 SWAP1 37E2 81 DUP2 37E3 01 ADD 37E4 90 SWAP1 37E5 60 PUSH1 0x1f 37E7 16 AND 37E8 80 DUP1 37E9 15 ISZERO 37EA 61 PUSH2 0x3807 37ED 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @37E4 stack[-7] = stack[-5] + stack[-7] // @37E7 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x3807, if !(0x1f & stack[-5]) label_37EE: // Incoming jump from 0x37ED, if not !(0x1f & stack[-5]) // Inputs[6] // { // @37EE stack[-1] // @37EF stack[-2] // @37F2 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3809 stack[-5] // @380F memory[0x40:0x60] // @3814 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 37EE 80 DUP1 37EF 82 DUP3 37F0 03 SUB 37F1 80 DUP1 37F2 51 MLOAD 37F3 60 PUSH1 0x01 37F5 83 DUP4 37F6 60 PUSH1 0x20 37F8 03 SUB 37F9 61 PUSH2 0x0100 37FC 0A EXP 37FD 03 SUB 37FE 19 NOT 37FF 16 AND 3800 81 DUP2 3801 52 MSTORE 3802 60 PUSH1 0x20 3804 01 ADD 3805 91 SWAP2 3806 50 POP 3807 5B JUMPDEST 3808 50 POP 3809 92 SWAP3 380A 50 POP 380B 50 POP 380C 50 POP 380D 60 PUSH1 0x40 380F 51 MLOAD 3810 80 DUP1 3811 91 SWAP2 3812 03 SUB 3813 90 SWAP1 3814 FD *REVERT // Stack delta = -5 // Outputs[2] // { // @3801 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3814 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_3815: // Incoming jump from 0x378E, if !stack[-7] // Inputs[1] { @381B stack[-6] } 3815 5B JUMPDEST 3816 50 POP 3817 50 POP 3818 50 POP 3819 50 POP 381A 50 POP 381B 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_381C: // Incoming call from 0x4CFC, returns to 0x4CFD // Incoming call from 0x1F84, returns to 0x1F85 // Inputs[8] // { // @3820 storage[0x00] // @3824 memory[0x40:0x60] // @3832 address(this) // @3840 stack[-4] // @3848 stack[-3] // @3850 stack[-2] // @3859 memory[0x40:0x60] // @3881 address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } 381C 5B JUMPDEST 381D 60 PUSH1 0x00 381F 80 DUP1 3820 54 SLOAD 3821 60 PUSH1 0x40 3823 80 DUP1 3824 51 MLOAD 3825 60 PUSH1 0x01 3827 60 PUSH1 0xe0 3829 1B SHL 382A 63 PUSH4 0xeafe967b 382F 02 MUL 3830 81 DUP2 3831 52 MSTORE 3832 30 ADDRESS 3833 60 PUSH1 0x04 3835 82 DUP3 3836 01 ADD 3837 52 MSTORE 3838 60 PUSH1 0x01 383A 60 PUSH1 0x01 383C 60 PUSH1 0xa0 383E 1B SHL 383F 03 SUB 3840 88 DUP9 3841 81 DUP2 3842 16 AND 3843 60 PUSH1 0x24 3845 83 DUP4 3846 01 ADD 3847 52 MSTORE 3848 87 DUP8 3849 81 DUP2 384A 16 AND 384B 60 PUSH1 0x44 384D 83 DUP4 384E 01 ADD 384F 52 MSTORE 3850 86 DUP7 3851 81 DUP2 3852 16 AND 3853 60 PUSH1 0x64 3855 83 DUP4 3856 01 ADD 3857 52 MSTORE 3858 91 SWAP2 3859 51 MLOAD 385A 84 DUP5 385B 93 SWAP4 385C 63 PUSH4 0x01000000 3861 90 SWAP1 3862 04 DIV 3863 90 SWAP1 3864 92 SWAP3 3865 16 AND 3866 91 SWAP2 3867 63 PUSH4 0xeafe967b 386C 91 SWAP2 386D 60 PUSH1 0x84 386F 80 DUP1 3870 82 DUP3 3871 01 ADD 3872 92 SWAP3 3873 60 PUSH1 0x20 3875 92 SWAP3 3876 90 SWAP1 3877 91 SWAP2 3878 90 SWAP1 3879 82 DUP3 387A 90 SWAP1 387B 03 SUB 387C 01 ADD 387D 81 DUP2 387E 87 DUP8 387F 87 DUP8 3880 80 DUP1 3881 3B EXTCODESIZE 3882 15 ISZERO 3883 80 DUP1 3884 15 ISZERO 3885 61 PUSH2 0x388d 3888 57 *JUMPI // Stack delta = +12 // Outputs[17] // { // @381D stack[0] = 0x00 // @3831 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xeafe967b * (0x01 << 0xe0) // @3837 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @3847 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @384F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @3857 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @385B stack[1] = 0x00 // @3866 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @386C stack[3] = 0xeafe967b // @3872 stack[4] = memory[0x40:0x60] + 0x84 // @3875 stack[5] = 0x20 // @3877 stack[6] = memory[0x40:0x60] // @387C stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x84 // @387D stack[8] = memory[0x40:0x60] // @387E stack[9] = 0x00 // @387F stack[10] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @3882 stack[11] = !address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } // Block ends with conditional jump to 0x388d, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length label_3889: // Incoming jump from 0x3888, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[1] { @388C memory[0x00:0x00] } 3889 60 PUSH1 0x00 388B 80 DUP1 388C FD *REVERT // Stack delta = +0 // Outputs[1] { @388C revert(memory[0x00:0x00]); } // Block terminates label_388D: // Incoming jump from 0x3888, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[9] // { // @388F msg.gas // @3890 stack[-3] // @3890 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3890 stack[-5] // @3890 stack[-7] // @3890 stack[-2] // @3890 stack[-4] // @3890 stack[-6] // @3890 memory[stack[-4]:stack[-4] + stack[-5]] // } 388D 5B JUMPDEST 388E 50 POP 388F 5A GAS 3890 F1 CALL 3891 15 ISZERO 3892 80 DUP1 3893 15 ISZERO 3894 61 PUSH2 0x38a1 3897 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @3890 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @3891 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x38a1, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_3898: // Incoming jump from 0x3897, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @3898 returndata.length // @389C returndata[0x00:0x00 + returndata.length] // @389D returndata.length // @38A0 memory[0x00:0x00 + returndata.length] // } 3898 3D RETURNDATASIZE 3899 60 PUSH1 0x00 389B 80 DUP1 389C 3E RETURNDATACOPY 389D 3D RETURNDATASIZE 389E 60 PUSH1 0x00 38A0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @389C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @38A0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_38A1: // Incoming jump from 0x3897, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @38A8 memory[0x40:0x60] // @38A9 returndata.length // } 38A1 5B JUMPDEST 38A2 50 POP 38A3 50 POP 38A4 50 POP 38A5 50 POP 38A6 60 PUSH1 0x40 38A8 51 MLOAD 38A9 3D RETURNDATASIZE 38AA 60 PUSH1 0x20 38AC 81 DUP2 38AD 10 LT 38AE 15 ISZERO 38AF 61 PUSH2 0x38b7 38B2 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @38A8 stack[-4] = memory[0x40:0x60] // @38A9 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x38b7, if !(returndata.length < 0x20) label_38B3: // Incoming jump from 0x38B2, if not !(returndata.length < 0x20) // Inputs[1] { @38B6 memory[0x00:0x00] } 38B3 60 PUSH1 0x00 38B5 80 DUP1 38B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @38B6 revert(memory[0x00:0x00]); } // Block terminates label_38B7: // Incoming jump from 0x38B2, if !(returndata.length < 0x20) // Inputs[3] // { // @38B9 memory[stack[-2]:stack[-2] + 0x20] // @38B9 stack[-2] // @38BA stack[-3] // } 38B7 5B JUMPDEST 38B8 50 POP 38B9 51 MLOAD 38BA 90 SWAP1 38BB 50 POP 38BC 80 DUP1 38BD 15 ISZERO 38BE 61 PUSH2 0x38fa 38C1 57 *JUMPI // Stack delta = -2 // Outputs[1] { @38BA stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x38fa, if !memory[stack[-2]:stack[-2] + 0x20] label_38C2: // Incoming jump from 0x38C1, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @38C5 memory[0x40:0x60] // @38F0 memory[0x40:0x60] // @38F9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 38C2 60 PUSH1 0x40 38C4 80 DUP1 38C5 51 MLOAD 38C6 60 PUSH1 0x01 38C8 60 PUSH1 0xe5 38CA 1B SHL 38CB 62 PUSH3 0x461bcd 38CF 02 MUL 38D0 81 DUP2 38D1 52 MSTORE 38D2 60 PUSH1 0x20 38D4 60 PUSH1 0x04 38D6 82 DUP3 38D7 01 ADD 38D8 52 MSTORE 38D9 60 PUSH1 0x03 38DB 60 PUSH1 0x24 38DD 82 DUP3 38DE 01 ADD 38DF 52 MSTORE 38E0 60 PUSH1 0x01 38E2 60 PUSH1 0xe8 38E4 1B SHL 38E5 62 PUSH3 0x453537 38E9 02 MUL 38EA 60 PUSH1 0x44 38EC 82 DUP3 38ED 01 ADD 38EE 52 MSTORE 38EF 90 SWAP1 38F0 51 MLOAD 38F1 90 SWAP1 38F2 81 DUP2 38F3 90 SWAP1 38F4 03 SUB 38F5 60 PUSH1 0x64 38F7 01 ADD 38F8 90 SWAP1 38F9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @38D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @38D8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @38DF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @38EE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453537 * (0x01 << 0xe8) // @38F9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_38FA: // Incoming jump from 0x38C1, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @38FB stack[-5] // @3905 stack[-4] // } 38FA 5B JUMPDEST 38FB 84 DUP5 38FC 60 PUSH1 0x01 38FE 60 PUSH1 0x01 3900 60 PUSH1 0xa0 3902 1B SHL 3903 03 SUB 3904 16 AND 3905 84 DUP5 3906 60 PUSH1 0x01 3908 60 PUSH1 0x01 390A 60 PUSH1 0xa0 390C 1B SHL 390D 03 SUB 390E 16 AND 390F 14 EQ 3910 15 ISZERO 3911 61 PUSH2 0x394d 3914 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x394d, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-5]) label_3915: // Incoming jump from 0x3914, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-5]) // Inputs[3] // { // @3918 memory[0x40:0x60] // @3943 memory[0x40:0x60] // @394C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3915 60 PUSH1 0x40 3917 80 DUP1 3918 51 MLOAD 3919 60 PUSH1 0x01 391B 60 PUSH1 0xe5 391D 1B SHL 391E 62 PUSH3 0x461bcd 3922 02 MUL 3923 81 DUP2 3924 52 MSTORE 3925 60 PUSH1 0x20 3927 60 PUSH1 0x04 3929 82 DUP3 392A 01 ADD 392B 52 MSTORE 392C 60 PUSH1 0x03 392E 60 PUSH1 0x24 3930 82 DUP3 3931 01 ADD 3932 52 MSTORE 3933 60 PUSH1 0x01 3935 60 PUSH1 0xec 3937 1B SHL 3938 62 PUSH3 0x045353 393C 02 MUL 393D 60 PUSH1 0x44 393F 82 DUP3 3940 01 ADD 3941 52 MSTORE 3942 90 SWAP1 3943 51 MLOAD 3944 90 SWAP1 3945 81 DUP2 3946 90 SWAP1 3947 03 SUB 3948 60 PUSH1 0x64 394A 01 ADD 394B 90 SWAP1 394C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3924 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @392B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3932 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @3941 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x045353 * (0x01 << 0xec) // @394C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_394D: // Incoming jump from 0x3914, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-5]) // Inputs[4] // { // @3956 stack[-4] // @3965 memory[0x00:0x40] // @3966 storage[keccak256(memory[0x00:0x40])] // @396F stack[-3] // } 394D 5B JUMPDEST 394E 60 PUSH1 0x01 3950 60 PUSH1 0x01 3952 60 PUSH1 0xa0 3954 1B SHL 3955 03 SUB 3956 84 DUP5 3957 16 AND 3958 60 PUSH1 0x00 395A 90 SWAP1 395B 81 DUP2 395C 52 MSTORE 395D 60 PUSH1 0x0d 395F 60 PUSH1 0x20 3961 52 MSTORE 3962 60 PUSH1 0x40 3964 81 DUP2 3965 20 SHA3 3966 54 SLOAD 3967 81 DUP2 3968 90 SWAP1 3969 81 DUP2 396A 90 SWAP1 396B 61 PUSH2 0x3974 396E 90 SWAP1 396F 87 DUP8 3970 61 PUSH2 0x33c0 3973 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @395A stack[0] = 0x00 // @395C memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @3961 memory[0x20:0x40] = 0x0d // @3968 stack[1] = 0x00 // @396A stack[2] = 0x00 // @396E stack[4] = storage[keccak256(memory[0x00:0x40])] // @396E stack[3] = 0x3974 // @396F stack[5] = stack[-3] // } // Block ends with call to 0x33c0, returns to 0x3974 label_3974: // Incoming return from call to 0x33C0 at 0x3973 // Inputs[4] // { // @3975 stack[-2] // @3975 stack[-1] // @3976 stack[-5] // @3978 stack[-4] // } 3974 5B JUMPDEST 3975 90 SWAP1 3976 93 SWAP4 3977 50 POP 3978 91 SWAP2 3979 50 POP 397A 60 PUSH1 0x00 397C 83 DUP4 397D 60 PUSH1 0x03 397F 81 DUP2 3980 11 GT 3981 15 ISZERO 3982 61 PUSH2 0x3987 3985 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @3976 stack[-5] = stack[-2] // @3978 stack[-4] = stack[-1] // @397A stack[-2] = 0x00 // @397C stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x3987, if !(stack[-2] > 0x03) label_3986: // Incoming jump from 0x3985, if not !(stack[-2] > 0x03) 3986 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3986 assert(); } // Block terminates label_3987: // Incoming jump from 0x3985, if !(stack[-2] > 0x03) // Inputs[2] // { // @3988 stack[-2] // @3988 stack[-1] // } 3987 5B JUMPDEST 3988 14 EQ 3989 61 PUSH2 0x39c5 398C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x39c5, if stack[-1] == stack[-2] label_398D: // Incoming jump from 0x398C, if not stack[-1] == stack[-2] // Inputs[3] // { // @3990 memory[0x40:0x60] // @39BB memory[0x40:0x60] // @39C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 398D 60 PUSH1 0x40 398F 80 DUP1 3990 51 MLOAD 3991 60 PUSH1 0x01 3993 60 PUSH1 0xe5 3995 1B SHL 3996 62 PUSH3 0x461bcd 399A 02 MUL 399B 81 DUP2 399C 52 MSTORE 399D 60 PUSH1 0x20 399F 60 PUSH1 0x04 39A1 82 DUP3 39A2 01 ADD 39A3 52 MSTORE 39A4 60 PUSH1 0x03 39A6 60 PUSH1 0x24 39A8 82 DUP3 39A9 01 ADD 39AA 52 MSTORE 39AB 60 PUSH1 0x01 39AD 60 PUSH1 0xeb 39AF 1B SHL 39B0 62 PUSH3 0x08a6a7 39B4 02 MUL 39B5 60 PUSH1 0x44 39B7 82 DUP3 39B8 01 ADD 39B9 52 MSTORE 39BA 90 SWAP1 39BB 51 MLOAD 39BC 90 SWAP1 39BD 81 DUP2 39BE 90 SWAP1 39BF 03 SUB 39C0 60 PUSH1 0x64 39C2 01 ADD 39C3 90 SWAP1 39C4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @399C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @39A3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @39AA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @39B9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x08a6a7 * (0x01 << 0xeb) // @39C4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_39C5: // Incoming jump from 0x398C, if stack[-1] == stack[-2] // Inputs[4] // { // @39CE stack[-8] // @39DD memory[0x00:0x40] // @39DE storage[keccak256(memory[0x00:0x40])] // @39E3 stack[-6] // } 39C5 5B JUMPDEST 39C6 60 PUSH1 0x01 39C8 60 PUSH1 0x01 39CA 60 PUSH1 0xa0 39CC 1B SHL 39CD 03 SUB 39CE 88 DUP9 39CF 16 AND 39D0 60 PUSH1 0x00 39D2 90 SWAP1 39D3 81 DUP2 39D4 52 MSTORE 39D5 60 PUSH1 0x0d 39D7 60 PUSH1 0x20 39D9 52 MSTORE 39DA 60 PUSH1 0x40 39DC 90 SWAP1 39DD 20 SHA3 39DE 54 SLOAD 39DF 61 PUSH2 0x39e8 39E2 90 SWAP1 39E3 87 DUP8 39E4 61 PUSH2 0x2586 39E7 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @39D4 memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @39D9 memory[0x20:0x40] = 0x0d // @39E2 stack[0] = 0x39e8 // @39E2 stack[1] = storage[keccak256(memory[0x00:0x40])] // @39E3 stack[2] = stack[-6] // } // Block ends with call to 0x2586, returns to 0x39E8 label_39E8: // Incoming return from call to 0x2586 at 0x39E7 // Inputs[4] // { // @39E9 stack[-2] // @39E9 stack[-1] // @39EA stack[-5] // @39EC stack[-3] // } 39E8 5B JUMPDEST 39E9 90 SWAP1 39EA 93 SWAP4 39EB 50 POP 39EC 90 SWAP1 39ED 50 POP 39EE 60 PUSH1 0x00 39F0 83 DUP4 39F1 60 PUSH1 0x03 39F3 81 DUP2 39F4 11 GT 39F5 15 ISZERO 39F6 61 PUSH2 0x39fb 39F9 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @39EA stack[-5] = stack[-2] // @39EC stack[-3] = stack[-1] // @39EE stack[-2] = 0x00 // @39F0 stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x39fb, if !(stack[-2] > 0x03) label_39FA: // Incoming jump from 0x39F9, if not !(stack[-2] > 0x03) 39FA FE *ASSERT // Stack delta = +0 // Outputs[1] { @39FA assert(); } // Block terminates label_39FB: // Incoming jump from 0x39F9, if !(stack[-2] > 0x03) // Inputs[2] // { // @39FC stack[-1] // @39FC stack[-2] // } 39FB 5B JUMPDEST 39FC 14 EQ 39FD 61 PUSH2 0x3a39 3A00 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3a39, if stack[-1] == stack[-2] label_3A01: // Incoming jump from 0x3A00, if not stack[-1] == stack[-2] // Inputs[3] // { // @3A04 memory[0x40:0x60] // @3A2F memory[0x40:0x60] // @3A38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3A01 60 PUSH1 0x40 3A03 80 DUP1 3A04 51 MLOAD 3A05 60 PUSH1 0x01 3A07 60 PUSH1 0xe5 3A09 1B SHL 3A0A 62 PUSH3 0x461bcd 3A0E 02 MUL 3A0F 81 DUP2 3A10 52 MSTORE 3A11 60 PUSH1 0x20 3A13 60 PUSH1 0x04 3A15 82 DUP3 3A16 01 ADD 3A17 52 MSTORE 3A18 60 PUSH1 0x03 3A1A 60 PUSH1 0x24 3A1C 82 DUP3 3A1D 01 ADD 3A1E 52 MSTORE 3A1F 60 PUSH1 0x01 3A21 60 PUSH1 0xe8 3A23 1B SHL 3A24 62 PUSH3 0x453539 3A28 02 MUL 3A29 60 PUSH1 0x44 3A2B 82 DUP3 3A2C 01 ADD 3A2D 52 MSTORE 3A2E 90 SWAP1 3A2F 51 MLOAD 3A30 90 SWAP1 3A31 81 DUP2 3A32 90 SWAP1 3A33 03 SUB 3A34 60 PUSH1 0x64 3A36 01 ADD 3A37 90 SWAP1 3A38 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3A10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3A17 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3A1E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @3A2D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453539 * (0x01 << 0xe8) // @3A38 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3A39: // Incoming jump from 0x3A00, if stack[-1] == stack[-2] // Inputs[14] // { // @3A43 stack[-7] // @3A55 memory[0x00:0x40] // @3A56 stack[-2] // @3A5A stack[-8] // @3A62 memory[0x00:0x40] // @3A63 stack[-1] // @3A67 memory[0x40:0x60] // @3A68 stack[-6] // @3A6C memory[0x40:0x60] // @3A72 memory[0x00:0x20] // @3A7B memory[0x00:0x20] // @3A87 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])] // @3A8A stack[-10] // @3A8B stack[-9] // } 3A39 5B JUMPDEST 3A3A 60 PUSH1 0x01 3A3C 60 PUSH1 0x01 3A3E 60 PUSH1 0xa0 3A40 1B SHL 3A41 03 SUB 3A42 80 DUP1 3A43 88 DUP9 3A44 16 AND 3A45 60 PUSH1 0x00 3A47 81 DUP2 3A48 81 DUP2 3A49 52 MSTORE 3A4A 60 PUSH1 0x0d 3A4C 60 PUSH1 0x20 3A4E 90 SWAP1 3A4F 81 DUP2 3A50 52 MSTORE 3A51 60 PUSH1 0x40 3A53 80 DUP1 3A54 83 DUP4 3A55 20 SHA3 3A56 87 DUP8 3A57 90 SWAP1 3A58 55 SSTORE 3A59 93 SWAP4 3A5A 8C DUP13 3A5B 16 AND 3A5C 80 DUP1 3A5D 83 DUP4 3A5E 52 MSTORE 3A5F 91 SWAP2 3A60 84 DUP5 3A61 90 SWAP1 3A62 20 SHA3 3A63 85 DUP6 3A64 90 SWAP1 3A65 55 SSTORE 3A66 83 DUP4 3A67 51 MLOAD 3A68 8A DUP11 3A69 81 DUP2 3A6A 52 MSTORE 3A6B 93 SWAP4 3A6C 51 MLOAD 3A6D 91 SWAP2 3A6E 93 SWAP4 3A6F 60 PUSH1 0x00 3A71 80 DUP1 3A72 51 MLOAD 3A73 60 PUSH1 0x20 3A75 61 PUSH2 0x54d1 3A78 83 DUP4 3A79 39 CODECOPY 3A7A 81 DUP2 3A7B 51 MLOAD 3A7C 91 SWAP2 3A7D 52 MSTORE 3A7E 92 SWAP3 3A7F 90 SWAP1 3A80 81 DUP2 3A81 90 SWAP1 3A82 03 SUB 3A83 90 SWAP1 3A84 91 SWAP2 3A85 01 ADD 3A86 90 SWAP1 3A87 A3 LOG3 3A88 60 PUSH1 0x00 3A8A 99 SWAP10 3A8B 98 SWAP9 3A8C 50 POP 3A8D 50 POP 3A8E 50 POP 3A8F 50 POP 3A90 50 POP 3A91 50 POP 3A92 50 POP 3A93 50 POP 3A94 50 POP 3A95 56 *JUMP // Stack delta = -9 // Outputs[10] // { // @3A49 memory[0x00:0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @3A50 memory[0x20:0x40] = 0x0d // @3A58 storage[keccak256(memory[0x00:0x40])] = stack[-2] // @3A5E memory[0x00:0x20] = stack[-8] & (0x01 << 0xa0) - 0x01 // @3A65 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @3A6A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-6] // @3A79 memory[0x00:0x20] = code[0x54d1:0x54f1] // @3A7D memory[0x00:0x20] = memory[0x00:0x20] // @3A87 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20 + (memory[0x40:0x60] - memory[0x40:0x60])], [memory[0x00:0x20], stack[-7] & (0x01 << 0xa0) - 0x01, stack[-8] & (0x01 << 0xa0) - 0x01]); // @3A8A stack[-10] = 0x00 // } // Block ends with unconditional jump to stack[-10] label_3A96: // Incoming jump from 0x20F7 // Inputs[1] { @3A9A storage[0x00] } 3A96 5B JUMPDEST 3A97 60 PUSH1 0x00 3A99 80 DUP1 3A9A 54 SLOAD 3A9B 62 PUSH3 0x010000 3A9F 90 SWAP1 3AA0 04 DIV 3AA1 60 PUSH1 0xff 3AA3 16 AND 3AA4 61 PUSH2 0x3ae0 3AA7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3A97 stack[0] = 0x00 } // Block ends with conditional jump to 0x3ae0, if 0xff & storage[0x00] / 0x010000 label_3AA8: // Incoming jump from 0x3AA7, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @3AAB memory[0x40:0x60] // @3AD6 memory[0x40:0x60] // @3ADF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3AA8 60 PUSH1 0x40 3AAA 80 DUP1 3AAB 51 MLOAD 3AAC 60 PUSH1 0x01 3AAE 60 PUSH1 0xe5 3AB0 1B SHL 3AB1 62 PUSH3 0x461bcd 3AB5 02 MUL 3AB6 81 DUP2 3AB7 52 MSTORE 3AB8 60 PUSH1 0x20 3ABA 60 PUSH1 0x04 3ABC 82 DUP3 3ABD 01 ADD 3ABE 52 MSTORE 3ABF 60 PUSH1 0x03 3AC1 60 PUSH1 0x24 3AC3 82 DUP3 3AC4 01 ADD 3AC5 52 MSTORE 3AC6 60 PUSH1 0x01 3AC8 60 PUSH1 0xe8 3ACA 1B SHL 3ACB 62 PUSH3 0x453637 3ACF 02 MUL 3AD0 60 PUSH1 0x44 3AD2 82 DUP3 3AD3 01 ADD 3AD4 52 MSTORE 3AD5 90 SWAP1 3AD6 51 MLOAD 3AD7 90 SWAP1 3AD8 81 DUP2 3AD9 90 SWAP1 3ADA 03 SUB 3ADB 60 PUSH1 0x64 3ADD 01 ADD 3ADE 90 SWAP1 3ADF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3AB7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3ABE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3AC5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @3AD4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @3ADF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3AE0: // Incoming jump from 0x3AA7, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @3AE4 storage[0x00] } 3AE0 5B JUMPDEST 3AE1 60 PUSH1 0x00 3AE3 80 DUP1 3AE4 54 SLOAD 3AE5 62 PUSH3 0xff0000 3AE9 19 NOT 3AEA 16 AND 3AEB 81 DUP2 3AEC 55 SSTORE 3AED 61 PUSH2 0x3af4 3AF0 61 PUSH2 0x1a38 3AF3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3AE1 stack[0] = 0x00 // @3AEC storage[0x00] = ~0xff0000 & storage[0x00] // @3AED stack[1] = 0x3af4 // } // Block ends with call to 0x1a38, returns to 0x3AF4 label_3AF4: // Incoming return from call to 0x1A38 at 0x3AF3 // Incoming return from call to 0x1A38 at 0x3AF3 // Inputs[2] // { // @3AF5 stack[-1] // @3AF5 stack[-2] // } 3AF4 5B JUMPDEST 3AF5 14 EQ 3AF6 61 PUSH2 0x3b31 3AF9 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3b31, if stack[-1] == stack[-2] label_3AFA: // Incoming jump from 0x3AF9, if not stack[-1] == stack[-2] // Inputs[3] // { // @3AFD memory[0x40:0x60] // @3B27 memory[0x40:0x60] // @3B30 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3AFA 60 PUSH1 0x40 3AFC 80 DUP1 3AFD 51 MLOAD 3AFE 60 PUSH1 0x01 3B00 60 PUSH1 0xe5 3B02 1B SHL 3B03 62 PUSH3 0x461bcd 3B07 02 MUL 3B08 81 DUP2 3B09 52 MSTORE 3B0A 60 PUSH1 0x20 3B0C 60 PUSH1 0x04 3B0E 82 DUP3 3B0F 01 ADD 3B10 52 MSTORE 3B11 60 PUSH1 0x02 3B13 60 PUSH1 0x24 3B15 82 DUP3 3B16 01 ADD 3B17 52 MSTORE 3B18 60 PUSH1 0x01 3B1A 60 PUSH1 0xf0 3B1C 1B SHL 3B1D 61 PUSH2 0x4535 3B20 02 MUL 3B21 60 PUSH1 0x44 3B23 82 DUP3 3B24 01 ADD 3B25 52 MSTORE 3B26 90 SWAP1 3B27 51 MLOAD 3B28 90 SWAP1 3B29 81 DUP2 3B2A 90 SWAP1 3B2B 03 SUB 3B2C 60 PUSH1 0x64 3B2E 01 ADD 3B2F 90 SWAP1 3B30 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3B09 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3B10 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3B17 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @3B25 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @3B30 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3B31: // Incoming jump from 0x3AF9, if stack[-1] == stack[-2] // Inputs[2] // { // @3B35 msg.sender // @3B36 stack[-2] // } 3B31 5B JUMPDEST 3B32 61 PUSH2 0x1253 3B35 33 CALLER 3B36 83 DUP4 3B37 61 PUSH2 0x4e3d 3B3A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3B32 stack[0] = 0x1253 // @3B35 stack[1] = msg.sender // @3B36 stack[2] = stack[-2] // } // Block ends with call to 0x4e3d, returns to 0x1253 label_3B3B: // Incoming call from 0x2110, returns to 0x2111 // Incoming call from 0x3B64, returns to 0x3B65 // Inputs[1] { @3B41 address(this) } 3B3B 5B JUMPDEST 3B3C 60 PUSH1 0x00 3B3E 61 PUSH2 0x3b46 3B41 30 ADDRESS 3B42 61 PUSH2 0x5216 3B45 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3B3C stack[0] = 0x00 // @3B3E stack[1] = 0x3b46 // @3B41 stack[2] = address(this) // } // Block ends with call to 0x5216, returns to 0x3B46 label_3B46: // Incoming return from call to 0x5216 at 0x3B45 // Inputs[3] // { // @3B47 stack[-1] // @3B48 stack[-2] // @3B4A stack[-3] // } 3B46 5B JUMPDEST 3B47 15 ISZERO 3B48 90 SWAP1 3B49 50 POP 3B4A 90 SWAP1 3B4B 56 *JUMP // Stack delta = -2 // Outputs[1] { @3B4A stack[-3] = !stack[-1] } // Block ends with unconditional jump to stack[-3] label_3B4C: // Incoming jump from 0x21AD // Incoming jump from 0x21AD // Inputs[1] { @3B4F storage[0x00] } 3B4C 5B JUMPDEST 3B4D 60 PUSH1 0x00 3B4F 54 SLOAD 3B50 61 PUSH2 0x0100 3B53 90 SWAP1 3B54 04 DIV 3B55 60 PUSH1 0xff 3B57 16 AND 3B58 80 DUP1 3B59 61 PUSH2 0x3b65 3B5C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3B57 stack[0] = 0xff & storage[0x00] / 0x0100 } // Block ends with conditional jump to 0x3b65, if 0xff & storage[0x00] / 0x0100 label_3B5D: // Incoming jump from 0x3B5C, if not 0xff & storage[0x00] / 0x0100 3B5D 50 POP 3B5E 61 PUSH2 0x3b65 3B61 61 PUSH2 0x3b3b 3B64 56 *JUMP // Stack delta = +0 // Outputs[1] { @3B5E stack[-1] = 0x3b65 } // Block ends with call to 0x3b3b, returns to 0x3B65 label_3B65: // Incoming return from call to 0x3B3B at 0x3B64 // Incoming jump from 0x3B5C, if 0xff & storage[0x00] / 0x0100 // Inputs[1] { @3B66 stack[-1] } 3B65 5B JUMPDEST 3B66 80 DUP1 3B67 61 PUSH2 0x3b73 3B6A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3b73, if stack[-1] label_3B6B: // Incoming jump from 0x3B6A, if not stack[-1] // Inputs[1] { @3B6E storage[0x00] } 3B6B 50 POP 3B6C 60 PUSH1 0x00 3B6E 54 SLOAD 3B6F 60 PUSH1 0xff 3B71 16 AND 3B72 15 ISZERO 3B73 5B JUMPDEST 3B74 61 PUSH2 0x3bb1 3B77 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3bb1, if !(0xff & storage[0x00]) label_3B78: // Incoming jump from 0x3B77, if not !(0xff & storage[0x00]) // Incoming jump from 0x3B77, if not stack[-1] // Inputs[3] // { // @3B7A memory[0x40:0x60] // @3BAB memory[0x40:0x60] // @3BB0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3B78 60 PUSH1 0x40 3B7A 51 MLOAD 3B7B 60 PUSH1 0x01 3B7D 60 PUSH1 0xe5 3B7F 1B SHL 3B80 62 PUSH3 0x461bcd 3B84 02 MUL 3B85 81 DUP2 3B86 52 MSTORE 3B87 60 PUSH1 0x04 3B89 01 ADD 3B8A 80 DUP1 3B8B 80 DUP1 3B8C 60 PUSH1 0x20 3B8E 01 ADD 3B8F 82 DUP3 3B90 81 DUP2 3B91 03 SUB 3B92 82 DUP3 3B93 52 MSTORE 3B94 60 PUSH1 0x2e 3B96 81 DUP2 3B97 52 MSTORE 3B98 60 PUSH1 0x20 3B9A 01 ADD 3B9B 80 DUP1 3B9C 61 PUSH2 0x54a3 3B9F 60 PUSH1 0x2e 3BA1 91 SWAP2 3BA2 39 CODECOPY 3BA3 60 PUSH1 0x40 3BA5 01 ADD 3BA6 91 SWAP2 3BA7 50 POP 3BA8 50 POP 3BA9 60 PUSH1 0x40 3BAB 51 MLOAD 3BAC 80 DUP1 3BAD 91 SWAP2 3BAE 03 SUB 3BAF 90 SWAP1 3BB0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3B86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3B93 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3B97 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2e // @3BA2 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2e] = code[0x54a3:0x54d1] // @3BB0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3BB1: // Incoming jump from 0x3B77, if !(0xff & storage[0x00]) // Incoming jump from 0x3B77, if stack[-1] // Inputs[1] { @3BB4 storage[0x00] } 3BB1 5B JUMPDEST 3BB2 60 PUSH1 0x00 3BB4 54 SLOAD 3BB5 61 PUSH2 0x0100 3BB8 90 SWAP1 3BB9 04 DIV 3BBA 60 PUSH1 0xff 3BBC 16 AND 3BBD 15 ISZERO 3BBE 80 DUP1 3BBF 15 ISZERO 3BC0 61 PUSH2 0x3bdc 3BC3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3BBD stack[0] = !(0xff & storage[0x00] / 0x0100) } // Block ends with conditional jump to 0x3bdc, if !!(0xff & storage[0x00] / 0x0100) label_3BC4: // Incoming jump from 0x3BC3, if not !!(0xff & storage[0x00] / 0x0100) // Inputs[3] // { // @3BC7 storage[0x00] // @3BDF storage[0x05] // @3BEE msg.sender // } 3BC4 60 PUSH1 0x00 3BC6 80 DUP1 3BC7 54 SLOAD 3BC8 60 PUSH1 0xff 3BCA 19 NOT 3BCB 61 PUSH2 0xff00 3BCE 19 NOT 3BCF 90 SWAP1 3BD0 91 SWAP2 3BD1 16 AND 3BD2 61 PUSH2 0x0100 3BD5 17 OR 3BD6 16 AND 3BD7 60 PUSH1 0x01 3BD9 17 OR 3BDA 90 SWAP1 3BDB 55 SSTORE 3BDC 5B JUMPDEST 3BDD 60 PUSH1 0x05 3BDF 54 SLOAD 3BE0 61 PUSH2 0x0100 3BE3 90 SWAP1 3BE4 04 DIV 3BE5 60 PUSH1 0x01 3BE7 60 PUSH1 0x01 3BE9 60 PUSH1 0xa0 3BEB 1B SHL 3BEC 03 SUB 3BED 16 AND 3BEE 33 CALLER 3BEF 14 EQ 3BF0 61 PUSH2 0x3c2b 3BF3 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3BDB storage[0x00] = 0x01 | ((0x0100 | (storage[0x00] & ~0xff00)) & ~0xff) } // Block ends with conditional jump to 0x3c2b, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 label_3BF4: // Incoming jump from 0x3BF3, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Incoming jump from 0x3BF3, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[3] // { // @3BF7 memory[0x40:0x60] // @3C21 memory[0x40:0x60] // @3C2A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3BF4 60 PUSH1 0x40 3BF6 80 DUP1 3BF7 51 MLOAD 3BF8 60 PUSH1 0x01 3BFA 60 PUSH1 0xe5 3BFC 1B SHL 3BFD 62 PUSH3 0x461bcd 3C01 02 MUL 3C02 81 DUP2 3C03 52 MSTORE 3C04 60 PUSH1 0x20 3C06 60 PUSH1 0x04 3C08 82 DUP3 3C09 01 ADD 3C0A 52 MSTORE 3C0B 60 PUSH1 0x02 3C0D 60 PUSH1 0x24 3C0F 82 DUP3 3C10 01 ADD 3C11 52 MSTORE 3C12 60 PUSH1 0x01 3C14 60 PUSH1 0xf0 3C16 1B SHL 3C17 61 PUSH2 0x4531 3C1A 02 MUL 3C1B 60 PUSH1 0x44 3C1D 82 DUP3 3C1E 01 ADD 3C1F 52 MSTORE 3C20 90 SWAP1 3C21 51 MLOAD 3C22 90 SWAP1 3C23 81 DUP2 3C24 90 SWAP1 3C25 03 SUB 3C26 60 PUSH1 0x64 3C28 01 ADD 3C29 90 SWAP1 3C2A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3C03 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3C0A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3C11 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @3C1F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4531 * (0x01 << 0xf0) // @3C2A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3C2B: // Incoming jump from 0x3BF3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Incoming jump from 0x3BF3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[1] { @3C2E storage[0x08] } 3C2B 5B JUMPDEST 3C2C 60 PUSH1 0x08 3C2E 54 SLOAD 3C2F 15 ISZERO 3C30 80 DUP1 3C31 15 ISZERO 3C32 61 PUSH2 0x3c3b 3C35 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3C2F stack[0] = !storage[0x08] } // Block ends with conditional jump to 0x3c3b, if !!storage[0x08] label_3C36: // Incoming jump from 0x3C35, if not !!storage[0x08] // Inputs[1] { @3C39 storage[0x09] } 3C36 50 POP 3C37 60 PUSH1 0x09 3C39 54 SLOAD 3C3A 15 ISZERO 3C3B 5B JUMPDEST 3C3C 61 PUSH2 0x3c77 3C3F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3c77, if !storage[0x09] label_3C40: // Incoming jump from 0x3C3F, if not stack[-1] // Incoming jump from 0x3C3F, if not !storage[0x09] // Inputs[3] // { // @3C43 memory[0x40:0x60] // @3C6D memory[0x40:0x60] // @3C76 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3C40 60 PUSH1 0x40 3C42 80 DUP1 3C43 51 MLOAD 3C44 60 PUSH1 0x01 3C46 60 PUSH1 0xe5 3C48 1B SHL 3C49 62 PUSH3 0x461bcd 3C4D 02 MUL 3C4E 81 DUP2 3C4F 52 MSTORE 3C50 60 PUSH1 0x20 3C52 60 PUSH1 0x04 3C54 82 DUP3 3C55 01 ADD 3C56 52 MSTORE 3C57 60 PUSH1 0x02 3C59 60 PUSH1 0x24 3C5B 82 DUP3 3C5C 01 ADD 3C5D 52 MSTORE 3C5E 60 PUSH1 0x01 3C60 60 PUSH1 0xf1 3C62 1B SHL 3C63 61 PUSH2 0x2299 3C66 02 MUL 3C67 60 PUSH1 0x44 3C69 82 DUP3 3C6A 01 ADD 3C6B 52 MSTORE 3C6C 90 SWAP1 3C6D 51 MLOAD 3C6E 90 SWAP1 3C6F 81 DUP2 3C70 90 SWAP1 3C71 03 SUB 3C72 60 PUSH1 0x64 3C74 01 ADD 3C75 90 SWAP1 3C76 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3C4F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3C56 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3C5D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @3C6B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x2299 * (0x01 << 0xf1) // @3C76 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3C77: // Incoming jump from 0x3C3F, if stack[-1] // Incoming jump from 0x3C3F, if !storage[0x09] // Inputs[1] { @3C7A stack[-6] } 3C77 5B JUMPDEST 3C78 60 PUSH1 0x0c 3C7A 86 DUP7 3C7B 90 SWAP1 3C7C 55 SSTORE 3C7D 85 DUP6 3C7E 61 PUSH2 0x3cb9 3C81 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3C7C storage[0x0c] = stack[-6] } // Block ends with conditional jump to 0x3cb9, if stack[-6] label_3C82: // Incoming jump from 0x3C81, if not stack[-6] // Inputs[3] // { // @3C85 memory[0x40:0x60] // @3CAF memory[0x40:0x60] // @3CB8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3C82 60 PUSH1 0x40 3C84 80 DUP1 3C85 51 MLOAD 3C86 60 PUSH1 0x01 3C88 60 PUSH1 0xe5 3C8A 1B SHL 3C8B 62 PUSH3 0x461bcd 3C8F 02 MUL 3C90 81 DUP2 3C91 52 MSTORE 3C92 60 PUSH1 0x20 3C94 60 PUSH1 0x04 3C96 82 DUP3 3C97 01 ADD 3C98 52 MSTORE 3C99 60 PUSH1 0x02 3C9B 60 PUSH1 0x24 3C9D 82 DUP3 3C9E 01 ADD 3C9F 52 MSTORE 3CA0 60 PUSH1 0x01 3CA2 60 PUSH1 0xf0 3CA4 1B SHL 3CA5 61 PUSH2 0x4533 3CA8 02 MUL 3CA9 60 PUSH1 0x44 3CAB 82 DUP3 3CAC 01 ADD 3CAD 52 MSTORE 3CAE 90 SWAP1 3CAF 51 MLOAD 3CB0 90 SWAP1 3CB1 81 DUP2 3CB2 90 SWAP1 3CB3 03 SUB 3CB4 60 PUSH1 0x64 3CB6 01 ADD 3CB7 90 SWAP1 3CB8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3C91 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3C98 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3C9F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @3CAD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4533 * (0x01 << 0xf0) // @3CB8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3CB9: // Incoming jump from 0x3C81, if stack[-6] // Inputs[2] // { // @3CBD storage[0x00] // @3CD8 stack[-8] // } 3CB9 5B JUMPDEST 3CBA 60 PUSH1 0x00 3CBC 80 DUP1 3CBD 54 SLOAD 3CBE 63 PUSH4 0x01000000 3CC3 60 PUSH1 0x01 3CC5 60 PUSH1 0xb8 3CC7 1B SHL 3CC8 03 SUB 3CC9 19 NOT 3CCA 16 AND 3CCB 63 PUSH4 0x01000000 3CD0 60 PUSH1 0x01 3CD2 60 PUSH1 0x01 3CD4 60 PUSH1 0xa0 3CD6 1B SHL 3CD7 03 SUB 3CD8 8B DUP12 3CD9 16 AND 3CDA 02 MUL 3CDB 17 OR 3CDC 90 SWAP1 3CDD 55 SSTORE 3CDE 61 PUSH2 0x3ce5 3CE1 61 PUSH2 0x23f2 3CE4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @3CDD storage[0x00] = (stack[-8] & (0x01 << 0xa0) - 0x01) * 0x01000000 | (~((0x01 << 0xb8) - 0x01000000) & storage[0x00]) // @3CDE stack[0] = 0x3ce5 // } // Block ends with call to 0x23f2, returns to 0x3CE5 label_3CE5: // Incoming return from call to 0x23F2 at 0x3CE4 // Inputs[2] // { // @3CE8 stack[-1] // @3CFA stack[-8] // } 3CE5 5B JUMPDEST 3CE6 60 PUSH1 0x08 3CE8 55 SSTORE 3CE9 67 PUSH8 0x0de0b6b3a7640000 3CF2 60 PUSH1 0x09 3CF4 55 SSTORE 3CF5 60 PUSH1 0x00 3CF7 61 PUSH2 0x3cff 3CFA 88 DUP9 3CFB 61 PUSH2 0x3e60 3CFE 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @3CE8 storage[0x08] = stack[-1] // @3CF4 storage[0x09] = 0x0de0b6b3a7640000 // @3CF5 stack[-1] = 0x00 // @3CF7 stack[0] = 0x3cff // @3CFA stack[1] = stack[-8] // } // Block ends with call to 0x3e60, returns to 0x3CFF label_3CFF: // Incoming return from call to 0x3E60 at 0x3CFE // Inputs[2] // { // @3D00 stack[-2] // @3D00 stack[-1] // } 3CFF 5B JUMPDEST 3D00 90 SWAP1 3D01 50 POP 3D02 80 DUP1 3D03 15 ISZERO 3D04 61 PUSH2 0x3d3f 3D07 57 *JUMPI // Stack delta = -1 // Outputs[1] { @3D00 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x3d3f, if !stack[-1] label_3D08: // Incoming jump from 0x3D07, if not !stack[-1] // Inputs[3] // { // @3D0B memory[0x40:0x60] // @3D35 memory[0x40:0x60] // @3D3E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3D08 60 PUSH1 0x40 3D0A 80 DUP1 3D0B 51 MLOAD 3D0C 60 PUSH1 0x01 3D0E 60 PUSH1 0xe5 3D10 1B SHL 3D11 62 PUSH3 0x461bcd 3D15 02 MUL 3D16 81 DUP2 3D17 52 MSTORE 3D18 60 PUSH1 0x20 3D1A 60 PUSH1 0x04 3D1C 82 DUP3 3D1D 01 ADD 3D1E 52 MSTORE 3D1F 60 PUSH1 0x02 3D21 60 PUSH1 0x24 3D23 82 DUP3 3D24 01 ADD 3D25 52 MSTORE 3D26 60 PUSH1 0x01 3D28 60 PUSH1 0xf2 3D2A 1B SHL 3D2B 61 PUSH2 0x114d 3D2E 02 MUL 3D2F 60 PUSH1 0x44 3D31 82 DUP3 3D32 01 ADD 3D33 52 MSTORE 3D34 90 SWAP1 3D35 51 MLOAD 3D36 90 SWAP1 3D37 81 DUP2 3D38 90 SWAP1 3D39 03 SUB 3D3A 60 PUSH1 0x64 3D3C 01 ADD 3D3D 90 SWAP1 3D3E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3D17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3D1E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3D25 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @3D33 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x114d * (0x01 << 0xf2) // @3D3E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3D3F: // Incoming jump from 0x3D07, if !stack[-1] // Inputs[2] // { // @3D40 stack[-6] // @3D41 memory[stack[-6]:stack[-6] + 0x20] // } 3D3F 5B JUMPDEST 3D40 85 DUP6 3D41 51 MLOAD 3D42 61 PUSH2 0x3d52 3D45 90 SWAP1 3D46 60 PUSH1 0x03 3D48 90 SWAP1 3D49 60 PUSH1 0x20 3D4B 89 DUP10 3D4C 01 ADD 3D4D 90 SWAP1 3D4E 61 PUSH2 0x53d3 3D51 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3D45 stack[0] = 0x3d52 // @3D48 stack[1] = 0x03 // @3D4D stack[2] = stack[-6] + 0x20 // @3D4D stack[3] = memory[stack[-6]:stack[-6] + 0x20] // } // Block ends with unconditional jump to 0x53d3 3D52 5B JUMPDEST 3D53 50 POP 3D54 84 DUP5 3D55 51 MLOAD 3D56 61 PUSH2 0x3d66 3D59 90 SWAP1 3D5A 60 PUSH1 0x04 3D5C 90 SWAP1 3D5D 60 PUSH1 0x20 3D5F 88 DUP9 3D60 01 ADD 3D61 90 SWAP1 3D62 61 PUSH2 0x53d3 3D65 56 *JUMP 3D66 5B JUMPDEST 3D67 50 POP 3D68 50 POP 3D69 60 PUSH1 0x02 3D6B 83 DUP4 3D6C 90 SWAP1 3D6D 55 SSTORE 3D6E 60 PUSH1 0x05 3D70 80 DUP1 3D71 54 SLOAD 3D72 60 PUSH1 0xff 3D74 84 DUP5 3D75 16 AND 3D76 60 PUSH1 0xff 3D78 19 NOT 3D79 90 SWAP1 3D7A 91 SWAP2 3D7B 16 AND 3D7C 17 OR 3D7D 90 SWAP1 3D7E 55 SSTORE 3D7F 60 PUSH1 0x00 3D81 80 DUP1 3D82 54 SLOAD 3D83 62 PUSH3 0xff0000 3D87 19 NOT 3D88 16 AND 3D89 62 PUSH3 0x010000 3D8D 17 OR 3D8E 90 SWAP1 3D8F 55 SSTORE 3D90 80 DUP1 3D91 15 ISZERO 3D92 61 PUSH2 0x21c0 3D95 57 *JUMPI 3D96 60 PUSH1 0x00 3D98 80 DUP1 3D99 54 SLOAD 3D9A 61 PUSH2 0xff00 3D9D 19 NOT 3D9E 16 AND 3D9F 90 SWAP1 3DA0 55 SSTORE 3DA1 50 POP 3DA2 50 POP 3DA3 50 POP 3DA4 50 POP 3DA5 50 POP 3DA6 50 POP 3DA7 50 POP 3DA8 50 POP 3DA9 56 *JUMP label_3DAA: // Incoming call from 0x2206, returns to 0x2207 // Inputs[1] { @3DAE storage[0x00] } 3DAA 5B JUMPDEST 3DAB 60 PUSH1 0x00 3DAD 80 DUP1 3DAE 54 SLOAD 3DAF 81 DUP2 3DB0 90 SWAP1 3DB1 62 PUSH3 0x010000 3DB5 90 SWAP1 3DB6 04 DIV 3DB7 60 PUSH1 0xff 3DB9 16 AND 3DBA 61 PUSH2 0x3df6 3DBD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3DAB stack[0] = 0x00 // @3DB0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3df6, if 0xff & storage[0x00] / 0x010000 label_3DBE: // Incoming jump from 0x3DBD, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @3DC1 memory[0x40:0x60] // @3DEC memory[0x40:0x60] // @3DF5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3DBE 60 PUSH1 0x40 3DC0 80 DUP1 3DC1 51 MLOAD 3DC2 60 PUSH1 0x01 3DC4 60 PUSH1 0xe5 3DC6 1B SHL 3DC7 62 PUSH3 0x461bcd 3DCB 02 MUL 3DCC 81 DUP2 3DCD 52 MSTORE 3DCE 60 PUSH1 0x20 3DD0 60 PUSH1 0x04 3DD2 82 DUP3 3DD3 01 ADD 3DD4 52 MSTORE 3DD5 60 PUSH1 0x03 3DD7 60 PUSH1 0x24 3DD9 82 DUP3 3DDA 01 ADD 3DDB 52 MSTORE 3DDC 60 PUSH1 0x01 3DDE 60 PUSH1 0xe8 3DE0 1B SHL 3DE1 62 PUSH3 0x453637 3DE5 02 MUL 3DE6 60 PUSH1 0x44 3DE8 82 DUP3 3DE9 01 ADD 3DEA 52 MSTORE 3DEB 90 SWAP1 3DEC 51 MLOAD 3DED 90 SWAP1 3DEE 81 DUP2 3DEF 90 SWAP1 3DF0 03 SUB 3DF1 60 PUSH1 0x64 3DF3 01 ADD 3DF4 90 SWAP1 3DF5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3DCD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3DD4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3DDB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @3DEA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @3DF5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3DF6: // Incoming jump from 0x3DBD, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @3DFA storage[0x00] } 3DF6 5B JUMPDEST 3DF7 60 PUSH1 0x00 3DF9 80 DUP1 3DFA 54 SLOAD 3DFB 62 PUSH3 0xff0000 3DFF 19 NOT 3E00 16 AND 3E01 81 DUP2 3E02 55 SSTORE 3E03 61 PUSH2 0x3e0a 3E06 61 PUSH2 0x1a38 3E09 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @3DF7 stack[0] = 0x00 // @3E02 storage[0x00] = ~0xff0000 & storage[0x00] // @3E03 stack[1] = 0x3e0a // } // Block ends with call to 0x1a38, returns to 0x3E0A label_3E0A: // Incoming return from call to 0x1A38 at 0x3E09 // Incoming return from call to 0x1A38 at 0x3E09 // Inputs[2] // { // @3E0B stack[-2] // @3E0B stack[-1] // } 3E0A 5B JUMPDEST 3E0B 90 SWAP1 3E0C 50 POP 3E0D 80 DUP1 3E0E 15 ISZERO 3E0F 61 PUSH2 0x3e35 3E12 57 *JUMPI // Stack delta = -1 // Outputs[1] { @3E0B stack[-2] = stack[-1] } // Block ends with conditional jump to 0x3e35, if !stack[-1] label_3E13: // Incoming jump from 0x3E12, if not !stack[-1] // Inputs[1] { @3E16 stack[-1] } 3E13 61 PUSH2 0x3e28 3E16 81 DUP2 3E17 60 PUSH1 0x10 3E19 81 DUP2 3E1A 11 GT 3E1B 15 ISZERO 3E1C 61 PUSH2 0x3e21 3E1F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3E13 stack[0] = 0x3e28 // @3E16 stack[1] = stack[-1] // } // Block ends with conditional call to 0x3e21, returns to 0x3E28, if !(stack[-1] > 0x10) label_3E20: // Incoming jump from 0x3E1F, if not !(stack[-1] > 0x10) 3E20 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3E20 assert(); } // Block terminates label_3E21: // Incoming call from 0x3E1F, returns to 0x3E28, if !(stack[-1] > 0x10) 3E21 5B JUMPDEST 3E22 60 PUSH1 0x35 3E24 61 PUSH2 0x4388 3E27 56 *JUMP // Stack delta = +1 // Outputs[1] { @3E22 stack[0] = 0x35 } // Block ends with unconditional jump to 0x4388 label_3E28: // Incoming return from call to 0x3E21 at 0x3E1F // Inputs[4] // { // @3E29 stack[-1] // @3E29 stack[-4] // @3E2D stack[-3] // @3E32 stack[-2] // } 3E28 5B JUMPDEST 3E29 92 SWAP3 3E2A 50 POP 3E2B 60 PUSH1 0x00 3E2D 91 SWAP2 3E2E 50 POP 3E2F 61 PUSH2 0x3e46 3E32 90 SWAP1 3E33 50 POP 3E34 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @3E29 stack[-4] = stack[-1] // @3E2D stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x3e46 label_3E35: // Incoming jump from 0x3E12, if !stack[-1] // Inputs[3] // { // @3E39 msg.sender // @3E3A stack[-5] // @3E3B stack[-4] // } 3E35 5B JUMPDEST 3E36 61 PUSH2 0x3e40 3E39 33 CALLER 3E3A 86 DUP7 3E3B 86 DUP7 3E3C 61 PUSH2 0x442e 3E3F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3E36 stack[0] = 0x3e40 // @3E39 stack[1] = msg.sender // @3E3A stack[2] = stack[-5] // @3E3B stack[3] = stack[-4] // } // Block ends with call to 0x442e, returns to 0x3E40 label_3E40: // Incoming return from call to 0x442E at 0x3E3F // Inputs[4] // { // @3E41 stack[-4] // @3E41 stack[-1] // @3E43 stack[-5] // @3E43 stack[-2] // } 3E40 5B JUMPDEST 3E41 92 SWAP3 3E42 50 POP 3E43 92 SWAP3 3E44 50 POP 3E45 50 POP // Stack delta = -3 // Outputs[2] // { // @3E41 stack[-4] = stack[-1] // @3E43 stack[-5] = stack[-2] // } // Block continues label_3E46: // Incoming jump from 0x3E34 // Incoming jump from 0x3E45 // Inputs[6] // { // @3E4A storage[0x00] // @3E58 stack[-1] // @3E58 stack[-2] // @3E59 stack[-5] // @3E5B stack[-4] // @3E5D stack[-3] // } 3E46 5B JUMPDEST 3E47 60 PUSH1 0x00 3E49 80 DUP1 3E4A 54 SLOAD 3E4B 62 PUSH3 0xff0000 3E4F 19 NOT 3E50 16 AND 3E51 62 PUSH3 0x010000 3E55 17 OR 3E56 90 SWAP1 3E57 55 SSTORE 3E58 90 SWAP1 3E59 93 SWAP4 3E5A 90 SWAP1 3E5B 92 SWAP3 3E5C 50 POP 3E5D 90 SWAP1 3E5E 50 POP 3E5F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @3E57 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @3E59 stack[-5] = stack[-2] // @3E5B stack[-4] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_3E60: // Incoming call from 0x3CFE, returns to 0x3CFF // Incoming call from 0x2289, returns to 0x1681 // Inputs[2] // { // @3E63 storage[0x05] // @3E77 msg.sender // } 3E60 5B JUMPDEST 3E61 60 PUSH1 0x05 3E63 54 SLOAD 3E64 60 PUSH1 0x00 3E66 90 SWAP1 3E67 81 DUP2 3E68 90 SWAP1 3E69 61 PUSH2 0x0100 3E6C 90 SWAP1 3E6D 04 DIV 3E6E 60 PUSH1 0x01 3E70 60 PUSH1 0x01 3E72 60 PUSH1 0xa0 3E74 1B SHL 3E75 03 SUB 3E76 16 AND 3E77 33 CALLER 3E78 14 EQ 3E79 61 PUSH2 0x3eb4 3E7C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3E66 stack[0] = 0x00 // @3E68 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3eb4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 label_3E7D: // Incoming jump from 0x3E7C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[3] // { // @3E80 memory[0x40:0x60] // @3EAA memory[0x40:0x60] // @3EB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3E7D 60 PUSH1 0x40 3E7F 80 DUP1 3E80 51 MLOAD 3E81 60 PUSH1 0x01 3E83 60 PUSH1 0xe5 3E85 1B SHL 3E86 62 PUSH3 0x461bcd 3E8A 02 MUL 3E8B 81 DUP2 3E8C 52 MSTORE 3E8D 60 PUSH1 0x20 3E8F 60 PUSH1 0x04 3E91 82 DUP3 3E92 01 ADD 3E93 52 MSTORE 3E94 60 PUSH1 0x02 3E96 60 PUSH1 0x24 3E98 82 DUP3 3E99 01 ADD 3E9A 52 MSTORE 3E9B 60 PUSH1 0x01 3E9D 60 PUSH1 0xf0 3E9F 1B SHL 3EA0 61 PUSH2 0x4531 3EA3 02 MUL 3EA4 60 PUSH1 0x44 3EA6 82 DUP3 3EA7 01 ADD 3EA8 52 MSTORE 3EA9 90 SWAP1 3EAA 51 MLOAD 3EAB 90 SWAP1 3EAC 81 DUP2 3EAD 90 SWAP1 3EAE 03 SUB 3EAF 60 PUSH1 0x64 3EB1 01 ADD 3EB2 90 SWAP1 3EB3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3E8C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3E93 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3E9A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @3EA8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4531 * (0x01 << 0xf0) // @3EB3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3EB4: // Incoming jump from 0x3E7C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 3EB4 5B JUMPDEST 3EB5 61 PUSH2 0x3ebc 3EB8 61 PUSH2 0x23f2 3EBB 56 *JUMP // Stack delta = +1 // Outputs[1] { @3EB5 stack[0] = 0x3ebc } // Block ends with call to 0x23f2, returns to 0x3EBC label_3EBC: // Incoming return from call to 0x23F2 at 0x3EBB // Inputs[2] // { // @3EBF storage[0x08] // @3EC0 stack[-1] // } 3EBC 5B JUMPDEST 3EBD 60 PUSH1 0x08 3EBF 54 SLOAD 3EC0 14 EQ 3EC1 61 PUSH2 0x3efc 3EC4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3efc, if storage[0x08] == stack[-1] label_3EC5: // Incoming jump from 0x3EC4, if not storage[0x08] == stack[-1] // Inputs[3] // { // @3EC8 memory[0x40:0x60] // @3EF2 memory[0x40:0x60] // @3EFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3EC5 60 PUSH1 0x40 3EC7 80 DUP1 3EC8 51 MLOAD 3EC9 60 PUSH1 0x01 3ECB 60 PUSH1 0xe5 3ECD 1B SHL 3ECE 62 PUSH3 0x461bcd 3ED2 02 MUL 3ED3 81 DUP2 3ED4 52 MSTORE 3ED5 60 PUSH1 0x20 3ED7 60 PUSH1 0x04 3ED9 82 DUP3 3EDA 01 ADD 3EDB 52 MSTORE 3EDC 60 PUSH1 0x02 3EDE 60 PUSH1 0x24 3EE0 82 DUP3 3EE1 01 ADD 3EE2 52 MSTORE 3EE3 60 PUSH1 0x01 3EE5 60 PUSH1 0xf0 3EE7 1B SHL 3EE8 61 PUSH2 0x4537 3EEB 02 MUL 3EEC 60 PUSH1 0x44 3EEE 82 DUP3 3EEF 01 ADD 3EF0 52 MSTORE 3EF1 90 SWAP1 3EF2 51 MLOAD 3EF3 90 SWAP1 3EF4 81 DUP2 3EF5 90 SWAP1 3EF6 03 SUB 3EF7 60 PUSH1 0x64 3EF9 01 ADD 3EFA 90 SWAP1 3EFB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3ED4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3EDB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3EE2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @3EF0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4537 * (0x01 << 0xf0) // @3EFB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3EFC: // Incoming jump from 0x3EC4, if storage[0x08] == stack[-1] // Inputs[6] // { // @3F02 storage[0x01] // @3F13 stack[-1] // @3F15 stack[-3] // @3F26 memory[0x40:0x60] // @3F3A memory[0x40:0x60] // @3F41 address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // } 3EFC 5B JUMPDEST 3EFD 60 PUSH1 0x01 3EFF 60 PUSH1 0x00 3F01 90 SWAP1 3F02 54 SLOAD 3F03 90 SWAP1 3F04 61 PUSH2 0x0100 3F07 0A EXP 3F08 90 SWAP1 3F09 04 DIV 3F0A 60 PUSH1 0x01 3F0C 60 PUSH1 0x01 3F0E 60 PUSH1 0xa0 3F10 1B SHL 3F11 03 SUB 3F12 16 AND 3F13 90 SWAP1 3F14 50 POP 3F15 82 DUP3 3F16 60 PUSH1 0x01 3F18 60 PUSH1 0x01 3F1A 60 PUSH1 0xa0 3F1C 1B SHL 3F1D 03 SUB 3F1E 16 AND 3F1F 63 PUSH4 0x2191f92a 3F24 60 PUSH1 0x40 3F26 51 MLOAD 3F27 81 DUP2 3F28 63 PUSH4 0xffffffff 3F2D 16 AND 3F2E 60 PUSH1 0xe0 3F30 1B SHL 3F31 81 DUP2 3F32 52 MSTORE 3F33 60 PUSH1 0x04 3F35 01 ADD 3F36 60 PUSH1 0x20 3F38 60 PUSH1 0x40 3F3A 51 MLOAD 3F3B 80 DUP1 3F3C 83 DUP4 3F3D 03 SUB 3F3E 81 DUP2 3F3F 86 DUP7 3F40 80 DUP1 3F41 3B EXTCODESIZE 3F42 15 ISZERO 3F43 80 DUP1 3F44 15 ISZERO 3F45 61 PUSH2 0x3f4d 3F48 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @3F13 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x01] / 0x0100 ** 0x00 // @3F1E stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @3F1F stack[1] = 0x2191f92a // @3F32 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2191f92a) << 0xe0 // @3F35 stack[2] = 0x04 + memory[0x40:0x60] // @3F36 stack[3] = 0x20 // @3F3A stack[4] = memory[0x40:0x60] // @3F3D stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @3F3E stack[6] = memory[0x40:0x60] // @3F3F stack[7] = (0x01 << 0xa0) - 0x01 & stack[-3] // @3F42 stack[8] = !address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // } // Block ends with conditional jump to 0x3f4d, if !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length label_3F49: // Incoming jump from 0x3F48, if not !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // Inputs[1] { @3F4C memory[0x00:0x00] } 3F49 60 PUSH1 0x00 3F4B 80 DUP1 3F4C FD *REVERT // Stack delta = +0 // Outputs[1] { @3F4C revert(memory[0x00:0x00]); } // Block terminates label_3F4D: // Incoming jump from 0x3F48, if !!address((0x01 << 0xa0) - 0x01 & stack[-3]).code.length // Inputs[8] // { // @3F4F msg.gas // @3F50 memory[stack[-3]:stack[-3] + stack[-4]] // @3F50 stack[-4] // @3F50 stack[-6] // @3F50 stack[-3] // @3F50 stack[-5] // @3F50 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3F50 stack[-2] // } 3F4D 5B JUMPDEST 3F4E 50 POP 3F4F 5A GAS 3F50 FA STATICCALL 3F51 15 ISZERO 3F52 80 DUP1 3F53 15 ISZERO 3F54 61 PUSH2 0x3f61 3F57 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3F50 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @3F51 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x3f61, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_3F58: // Incoming jump from 0x3F57, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @3F58 returndata.length // @3F5C returndata[0x00:0x00 + returndata.length] // @3F5D returndata.length // @3F60 memory[0x00:0x00 + returndata.length] // } 3F58 3D RETURNDATASIZE 3F59 60 PUSH1 0x00 3F5B 80 DUP1 3F5C 3E RETURNDATACOPY 3F5D 3D RETURNDATASIZE 3F5E 60 PUSH1 0x00 3F60 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @3F5C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @3F60 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_3F61: // Incoming jump from 0x3F57, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @3F68 memory[0x40:0x60] // @3F69 returndata.length // } 3F61 5B JUMPDEST 3F62 50 POP 3F63 50 POP 3F64 50 POP 3F65 50 POP 3F66 60 PUSH1 0x40 3F68 51 MLOAD 3F69 3D RETURNDATASIZE 3F6A 60 PUSH1 0x20 3F6C 81 DUP2 3F6D 10 LT 3F6E 15 ISZERO 3F6F 61 PUSH2 0x3f77 3F72 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @3F68 stack[-4] = memory[0x40:0x60] // @3F69 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x3f77, if !(returndata.length < 0x20) label_3F73: // Incoming jump from 0x3F72, if not !(returndata.length < 0x20) // Inputs[1] { @3F76 memory[0x00:0x00] } 3F73 60 PUSH1 0x00 3F75 80 DUP1 3F76 FD *REVERT // Stack delta = +0 // Outputs[1] { @3F76 revert(memory[0x00:0x00]); } // Block terminates label_3F77: // Incoming jump from 0x3F72, if !(returndata.length < 0x20) // Inputs[2] // { // @3F79 memory[stack[-2]:stack[-2] + 0x20] // @3F79 stack[-2] // } 3F77 5B JUMPDEST 3F78 50 POP 3F79 51 MLOAD 3F7A 61 PUSH2 0x3fb6 3F7D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x3fb6, if memory[stack[-2]:stack[-2] + 0x20] label_3F7E: // Incoming jump from 0x3F7D, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @3F81 memory[0x40:0x60] // @3FAC memory[0x40:0x60] // @3FB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3F7E 60 PUSH1 0x40 3F80 80 DUP1 3F81 51 MLOAD 3F82 60 PUSH1 0x01 3F84 60 PUSH1 0xe5 3F86 1B SHL 3F87 62 PUSH3 0x461bcd 3F8B 02 MUL 3F8C 81 DUP2 3F8D 52 MSTORE 3F8E 60 PUSH1 0x20 3F90 60 PUSH1 0x04 3F92 82 DUP3 3F93 01 ADD 3F94 52 MSTORE 3F95 60 PUSH1 0x03 3F97 60 PUSH1 0x24 3F99 82 DUP3 3F9A 01 ADD 3F9B 52 MSTORE 3F9C 60 PUSH1 0x01 3F9E 60 PUSH1 0xe8 3FA0 1B SHL 3FA1 62 PUSH3 0x453435 3FA5 02 MUL 3FA6 60 PUSH1 0x44 3FA8 82 DUP3 3FA9 01 ADD 3FAA 52 MSTORE 3FAB 90 SWAP1 3FAC 51 MLOAD 3FAD 90 SWAP1 3FAE 81 DUP2 3FAF 90 SWAP1 3FB0 03 SUB 3FB1 60 PUSH1 0x64 3FB3 01 ADD 3FB4 90 SWAP1 3FB5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3F8D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @3F94 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @3F9B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @3FAA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453435 * (0x01 << 0xe8) // @3FB5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_3FB6: // Incoming jump from 0x3F7D, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @3FBA storage[0x01] // @3FCD stack[-3] // } 3FB6 5B JUMPDEST 3FB7 60 PUSH1 0x01 3FB9 80 DUP1 3FBA 54 SLOAD 3FBB 60 PUSH1 0x01 3FBD 60 PUSH1 0x01 3FBF 60 PUSH1 0xa0 3FC1 1B SHL 3FC2 03 SUB 3FC3 19 NOT 3FC4 16 AND 3FC5 60 PUSH1 0x01 3FC7 60 PUSH1 0x01 3FC9 60 PUSH1 0xa0 3FCB 1B SHL 3FCC 03 SUB 3FCD 85 DUP6 3FCE 16 AND 3FCF 17 OR 3FD0 90 SWAP1 3FD1 55 SSTORE 3FD2 60 PUSH1 0x00 3FD4 61 PUSH2 0x1681 3FD7 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @3FD1 storage[0x01] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[0x01]) // @3FD2 stack[0] = 0x00 // } // Block ends with unconditional jump to 0x1681 label_3FD8: // Incoming call from 0x23CD, returns to 0x23CE // Inputs[2] // { // @3FDB storage[0x05] // @3FED msg.sender // } 3FD8 5B JUMPDEST 3FD9 60 PUSH1 0x05 3FDB 54 SLOAD 3FDC 60 PUSH1 0x00 3FDE 90 SWAP1 3FDF 61 PUSH2 0x0100 3FE2 90 SWAP1 3FE3 04 DIV 3FE4 60 PUSH1 0x01 3FE6 60 PUSH1 0x01 3FE8 60 PUSH1 0xa0 3FEA 1B SHL 3FEB 03 SUB 3FEC 16 AND 3FED 33 CALLER 3FEE 14 EQ 3FEF 61 PUSH2 0x402a 3FF2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3FDE stack[0] = 0x00 } // Block ends with conditional jump to 0x402a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 label_3FF3: // Incoming jump from 0x3FF2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 // Inputs[3] // { // @3FF6 memory[0x40:0x60] // @4020 memory[0x40:0x60] // @4029 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 3FF3 60 PUSH1 0x40 3FF5 80 DUP1 3FF6 51 MLOAD 3FF7 60 PUSH1 0x01 3FF9 60 PUSH1 0xe5 3FFB 1B SHL 3FFC 62 PUSH3 0x461bcd 4000 02 MUL 4001 81 DUP2 4002 52 MSTORE 4003 60 PUSH1 0x20 4005 60 PUSH1 0x04 4007 82 DUP3 4008 01 ADD 4009 52 MSTORE 400A 60 PUSH1 0x02 400C 60 PUSH1 0x24 400E 82 DUP3 400F 01 ADD 4010 52 MSTORE 4011 60 PUSH1 0x01 4013 60 PUSH1 0xf0 4015 1B SHL 4016 61 PUSH2 0x4531 4019 02 MUL 401A 60 PUSH1 0x44 401C 82 DUP3 401D 01 ADD 401E 52 MSTORE 401F 90 SWAP1 4020 51 MLOAD 4021 90 SWAP1 4022 81 DUP2 4023 90 SWAP1 4024 03 SUB 4025 60 PUSH1 0x64 4027 01 ADD 4028 90 SWAP1 4029 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4002 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4009 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4010 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @401E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4531 * (0x01 << 0xf0) // @4029 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_402A: // Incoming jump from 0x3FF2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] / 0x0100 402A 5B JUMPDEST 402B 61 PUSH2 0x4032 402E 61 PUSH2 0x23f2 4031 56 *JUMP // Stack delta = +1 // Outputs[1] { @402B stack[0] = 0x4032 } // Block ends with call to 0x23f2, returns to 0x4032 label_4032: // Incoming return from call to 0x23F2 at 0x4031 // Inputs[2] // { // @4035 storage[0x08] // @4036 stack[-1] // } 4032 5B JUMPDEST 4033 60 PUSH1 0x08 4035 54 SLOAD 4036 14 EQ 4037 61 PUSH2 0x4072 403A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4072, if storage[0x08] == stack[-1] label_403B: // Incoming jump from 0x403A, if not storage[0x08] == stack[-1] // Inputs[3] // { // @403E memory[0x40:0x60] // @4068 memory[0x40:0x60] // @4071 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 403B 60 PUSH1 0x40 403D 80 DUP1 403E 51 MLOAD 403F 60 PUSH1 0x01 4041 60 PUSH1 0xe5 4043 1B SHL 4044 62 PUSH3 0x461bcd 4048 02 MUL 4049 81 DUP2 404A 52 MSTORE 404B 60 PUSH1 0x20 404D 60 PUSH1 0x04 404F 82 DUP3 4050 01 ADD 4051 52 MSTORE 4052 60 PUSH1 0x02 4054 60 PUSH1 0x24 4056 82 DUP3 4057 01 ADD 4058 52 MSTORE 4059 60 PUSH1 0x01 405B 60 PUSH1 0xf0 405D 1B SHL 405E 61 PUSH2 0x4537 4061 02 MUL 4062 60 PUSH1 0x44 4064 82 DUP3 4065 01 ADD 4066 52 MSTORE 4067 90 SWAP1 4068 51 MLOAD 4069 90 SWAP1 406A 81 DUP2 406B 90 SWAP1 406C 03 SUB 406D 60 PUSH1 0x64 406F 01 ADD 4070 90 SWAP1 4071 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @404A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4051 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4058 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @4066 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4537 * (0x01 << 0xf0) // @4071 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4072: // Incoming jump from 0x403A, if storage[0x08] == stack[-1] // Inputs[1] { @407C stack[-2] } 4072 5B JUMPDEST 4073 67 PUSH8 0x0de0b6b3a7640000 407C 82 DUP3 407D 11 GT 407E 15 ISZERO 407F 61 PUSH2 0x40bb 4082 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x40bb, if !(stack[-2] > 0x0de0b6b3a7640000) label_4083: // Incoming jump from 0x4082, if not !(stack[-2] > 0x0de0b6b3a7640000) // Inputs[3] // { // @4086 memory[0x40:0x60] // @40B1 memory[0x40:0x60] // @40BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4083 60 PUSH1 0x40 4085 80 DUP1 4086 51 MLOAD 4087 60 PUSH1 0x01 4089 60 PUSH1 0xe5 408B 1B SHL 408C 62 PUSH3 0x461bcd 4090 02 MUL 4091 81 DUP2 4092 52 MSTORE 4093 60 PUSH1 0x20 4095 60 PUSH1 0x04 4097 82 DUP3 4098 01 ADD 4099 52 MSTORE 409A 60 PUSH1 0x03 409C 60 PUSH1 0x24 409E 82 DUP3 409F 01 ADD 40A0 52 MSTORE 40A1 60 PUSH1 0x01 40A3 60 PUSH1 0xea 40A5 1B SHL 40A6 62 PUSH3 0x114d0d 40AA 02 MUL 40AB 60 PUSH1 0x44 40AD 82 DUP3 40AE 01 ADD 40AF 52 MSTORE 40B0 90 SWAP1 40B1 51 MLOAD 40B2 90 SWAP1 40B3 81 DUP2 40B4 90 SWAP1 40B5 03 SUB 40B6 60 PUSH1 0x64 40B8 01 ADD 40B9 90 SWAP1 40BA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4092 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4099 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @40A0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @40AF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x114d0d * (0x01 << 0xea) // @40BA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_40BB: // Incoming jump from 0x4082, if !(stack[-2] > 0x0de0b6b3a7640000) // Inputs[5] // { // @40BF storage[0x0b] // @40C1 stack[-2] // @40C7 memory[0x40:0x60] // @40D3 memory[0x40:0x60] // @40FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 40BB 5B JUMPDEST 40BC 60 PUSH1 0x0b 40BE 80 DUP1 40BF 54 SLOAD 40C0 90 SWAP1 40C1 83 DUP4 40C2 90 SWAP1 40C3 55 SSTORE 40C4 60 PUSH1 0x40 40C6 80 DUP1 40C7 51 MLOAD 40C8 82 DUP3 40C9 81 DUP2 40CA 52 MSTORE 40CB 60 PUSH1 0x20 40CD 81 DUP2 40CE 01 ADD 40CF 85 DUP6 40D0 90 SWAP1 40D1 52 MSTORE 40D2 81 DUP2 40D3 51 MLOAD 40D4 7F PUSH32 0xaaa68312e2ea9d50e16af5068410ab56e1a1fd06037b1a35664812c30f821460 40F5 92 SWAP3 40F6 91 SWAP2 40F7 81 DUP2 40F8 90 SWAP1 40F9 03 SUB 40FA 90 SWAP1 40FB 91 SWAP2 40FC 01 ADD 40FD 90 SWAP1 40FE A1 LOG1 40FF 60 PUSH1 0x00 4101 61 PUSH2 0x1681 4104 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @40C0 stack[0] = storage[0x0b] // @40C3 storage[0x0b] = stack[-2] // @40CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x0b] // @40D1 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-2] // @40FE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xaaa68312e2ea9d50e16af5068410ab56e1a1fd06037b1a35664812c30f821460]); // @40FF stack[1] = 0x00 // } // Block ends with unconditional jump to 0x1681 label_4105: // Incoming call from 0x23F1, returns to 0x11A3 // Inputs[1] { @4109 storage[0x00] } 4105 5B JUMPDEST 4106 60 PUSH1 0x00 4108 80 DUP1 4109 54 SLOAD 410A 62 PUSH3 0x010000 410E 90 SWAP1 410F 04 DIV 4110 60 PUSH1 0xff 4112 16 AND 4113 61 PUSH2 0x414f 4116 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4106 stack[0] = 0x00 } // Block ends with conditional jump to 0x414f, if 0xff & storage[0x00] / 0x010000 label_4117: // Incoming jump from 0x4116, if not 0xff & storage[0x00] / 0x010000 // Inputs[3] // { // @411A memory[0x40:0x60] // @4145 memory[0x40:0x60] // @414E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4117 60 PUSH1 0x40 4119 80 DUP1 411A 51 MLOAD 411B 60 PUSH1 0x01 411D 60 PUSH1 0xe5 411F 1B SHL 4120 62 PUSH3 0x461bcd 4124 02 MUL 4125 81 DUP2 4126 52 MSTORE 4127 60 PUSH1 0x20 4129 60 PUSH1 0x04 412B 82 DUP3 412C 01 ADD 412D 52 MSTORE 412E 60 PUSH1 0x03 4130 60 PUSH1 0x24 4132 82 DUP3 4133 01 ADD 4134 52 MSTORE 4135 60 PUSH1 0x01 4137 60 PUSH1 0xe8 4139 1B SHL 413A 62 PUSH3 0x453637 413E 02 MUL 413F 60 PUSH1 0x44 4141 82 DUP3 4142 01 ADD 4143 52 MSTORE 4144 90 SWAP1 4145 51 MLOAD 4146 90 SWAP1 4147 81 DUP2 4148 90 SWAP1 4149 03 SUB 414A 60 PUSH1 0x64 414C 01 ADD 414D 90 SWAP1 414E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4126 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @412D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4134 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4143 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453637 * (0x01 << 0xe8) // @414E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_414F: // Incoming jump from 0x4116, if 0xff & storage[0x00] / 0x010000 // Inputs[1] { @4153 storage[0x00] } 414F 5B JUMPDEST 4150 60 PUSH1 0x00 4152 80 DUP1 4153 54 SLOAD 4154 62 PUSH3 0xff0000 4158 19 NOT 4159 16 AND 415A 81 DUP2 415B 55 SSTORE 415C 61 PUSH2 0x4163 415F 61 PUSH2 0x1a38 4162 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @4150 stack[0] = 0x00 // @415B storage[0x00] = ~0xff0000 & storage[0x00] // @415C stack[1] = 0x4163 // } // Block ends with call to 0x1a38, returns to 0x4163 label_4163: // Incoming return from call to 0x1A38 at 0x4162 // Incoming return from call to 0x1A38 at 0x4162 // Inputs[2] // { // @4164 stack[-2] // @4164 stack[-1] // } 4163 5B JUMPDEST 4164 90 SWAP1 4165 50 POP 4166 80 DUP1 4167 15 ISZERO 4168 61 PUSH2 0x41a3 416B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @4164 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x41a3, if !stack[-1] label_416C: // Incoming jump from 0x416B, if not !stack[-1] // Inputs[3] // { // @416F memory[0x40:0x60] // @4199 memory[0x40:0x60] // @41A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 416C 60 PUSH1 0x40 416E 80 DUP1 416F 51 MLOAD 4170 60 PUSH1 0x01 4172 60 PUSH1 0xe5 4174 1B SHL 4175 62 PUSH3 0x461bcd 4179 02 MUL 417A 81 DUP2 417B 52 MSTORE 417C 60 PUSH1 0x20 417E 60 PUSH1 0x04 4180 82 DUP3 4181 01 ADD 4182 52 MSTORE 4183 60 PUSH1 0x02 4185 60 PUSH1 0x24 4187 82 DUP3 4188 01 ADD 4189 52 MSTORE 418A 60 PUSH1 0x01 418C 60 PUSH1 0xf0 418E 1B SHL 418F 61 PUSH2 0x4535 4192 02 MUL 4193 60 PUSH1 0x44 4195 82 DUP3 4196 01 ADD 4197 52 MSTORE 4198 90 SWAP1 4199 51 MLOAD 419A 90 SWAP1 419B 81 DUP2 419C 90 SWAP1 419D 03 SUB 419E 60 PUSH1 0x64 41A0 01 ADD 41A1 90 SWAP1 41A2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @417B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4182 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4189 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @4197 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4535 * (0x01 << 0xf0) // @41A2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_41A3: // Incoming jump from 0x416B, if !stack[-1] // Inputs[1] { @41A7 stack[-3] } 41A3 5B JUMPDEST 41A4 61 PUSH2 0x41ac 41A7 83 DUP4 41A8 61 PUSH2 0x521c 41AB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @41A4 stack[0] = 0x41ac // @41A7 stack[1] = stack[-3] // } // Block ends with call to 0x521c, returns to 0x41AC label_41AC: // Incoming return from call to 0x521C at 0x41AB // Inputs[5] // { // @41AE stack[-2] // @41AE stack[-4] // @41B4 storage[0x00] // @41C2 stack[-6] // @41C3 stack[-5] // } 41AC 5B JUMPDEST 41AD 50 POP 41AE 91 SWAP2 41AF 50 POP 41B0 50 POP 41B1 60 PUSH1 0x00 41B3 80 DUP1 41B4 54 SLOAD 41B5 62 PUSH3 0xff0000 41B9 19 NOT 41BA 16 AND 41BB 62 PUSH3 0x010000 41BF 17 OR 41C0 90 SWAP1 41C1 55 SSTORE 41C2 91 SWAP2 41C3 90 SWAP1 41C4 50 POP 41C5 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @41C1 storage[0x00] = 0x010000 | (~0xff0000 & storage[0x00]) // @41C2 stack[-6] = stack[-2] // } // Block ends with unconditional jump to stack[-6] label_41C6: // Incoming call from 0x2437, returns to 0x2438 // Inputs[2] // { // @41D0 stack[-3] // @41D1 stack[-2] // } 41C6 5B JUMPDEST 41C7 60 PUSH1 0x00 41C9 80 DUP1 41CA 60 PUSH1 0x00 41CC 80 DUP1 41CD 61 PUSH2 0x41d6 41D0 87 DUP8 41D1 87 DUP8 41D2 61 PUSH2 0x2586 41D5 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @41C7 stack[0] = 0x00 // @41C9 stack[1] = 0x00 // @41CA stack[2] = 0x00 // @41CC stack[3] = 0x00 // @41CD stack[4] = 0x41d6 // @41D0 stack[5] = stack[-3] // @41D1 stack[6] = stack[-2] // } // Block ends with call to 0x2586, returns to 0x41D6 label_41D6: // Incoming return from call to 0x2586 at 0x41D5 // Inputs[4] // { // @41D7 stack[-2] // @41D7 stack[-1] // @41D8 stack[-4] // @41DA stack[-3] // } 41D6 5B JUMPDEST 41D7 90 SWAP1 41D8 92 SWAP3 41D9 50 POP 41DA 90 SWAP1 41DB 50 POP 41DC 60 PUSH1 0x00 41DE 82 DUP3 41DF 60 PUSH1 0x03 41E1 81 DUP2 41E2 11 GT 41E3 15 ISZERO 41E4 61 PUSH2 0x41e9 41E7 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @41D8 stack[-4] = stack[-2] // @41DA stack[-3] = stack[-1] // @41DC stack[-2] = 0x00 // @41DE stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x41e9, if !(stack[-2] > 0x03) label_41E8: // Incoming jump from 0x41E7, if not !(stack[-2] > 0x03) 41E8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @41E8 assert(); } // Block terminates label_41E9: // Incoming jump from 0x41E7, if !(stack[-2] > 0x03) // Inputs[2] // { // @41EA stack[-1] // @41EA stack[-2] // } 41E9 5B JUMPDEST 41EA 14 EQ 41EB 61 PUSH2 0x41fa 41EE 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x41fa, if stack[-1] == stack[-2] label_41EF: // Incoming jump from 0x41EE, if not stack[-1] == stack[-2] // Inputs[3] // { // @41F0 stack[-4] // @41F0 stack[-2] // @41F4 stack[-3] // } 41EF 50 POP 41F0 91 SWAP2 41F1 50 POP 41F2 60 PUSH1 0x00 41F4 90 SWAP1 41F5 50 POP 41F6 61 PUSH2 0x349f 41F9 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @41F0 stack[-4] = stack[-2] // @41F4 stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x349f label_41FA: // Incoming jump from 0x41EE, if stack[-1] == stack[-2] // Inputs[2] // { // @41FE stack[-1] // @41FF stack[-5] // } 41FA 5B JUMPDEST 41FB 61 PUSH2 0x3498 41FE 81 DUP2 41FF 86 DUP7 4200 61 PUSH2 0x33c0 4203 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @41FB stack[0] = 0x3498 // @41FE stack[1] = stack[-1] // @41FF stack[2] = stack[-5] // } // Block ends with call to 0x33c0, returns to 0x3498 label_4204: // Incoming call from 0x2468, returns to 0x2469 // Incoming call from 0x4312, returns to 0x2578 4204 5B JUMPDEST 4205 60 PUSH1 0x00 4207 61 PUSH2 0x420e 420A 61 PUSH2 0x5357 420D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @4205 stack[0] = 0x00 // @4207 stack[1] = 0x420e // } // Block ends with call to 0x5357, returns to 0x420E label_420E: // Incoming return from call to 0x5357 at 0x420D // Inputs[1] { @4215 stack[-4] } 420E 5B JUMPDEST 420F 60 PUSH1 0x00 4211 80 DUP1 4212 61 PUSH2 0x4223 4215 86 DUP7 4216 67 PUSH8 0x0de0b6b3a7640000 421F 61 PUSH2 0x47e4 4222 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @420F stack[0] = 0x00 // @4211 stack[1] = 0x00 // @4212 stack[2] = 0x4223 // @4215 stack[3] = stack[-4] // @4216 stack[4] = 0x0de0b6b3a7640000 // } // Block ends with call to 0x47e4, returns to 0x4223 label_4223: // Incoming return from call to 0x47E4 at 0x4222 // Inputs[4] // { // @4224 stack[-1] // @4224 stack[-2] // @4225 stack[-4] // @4227 stack[-3] // } 4223 5B JUMPDEST 4224 90 SWAP1 4225 92 SWAP3 4226 50 POP 4227 90 SWAP1 4228 50 POP 4229 60 PUSH1 0x00 422B 82 DUP3 422C 60 PUSH1 0x03 422E 81 DUP2 422F 11 GT 4230 15 ISZERO 4231 61 PUSH2 0x4236 4234 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @4225 stack[-4] = stack[-2] // @4227 stack[-3] = stack[-1] // @4229 stack[-2] = 0x00 // @422B stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x4236, if !(stack[-2] > 0x03) label_4235: // Incoming jump from 0x4234, if not !(stack[-2] > 0x03) 4235 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4235 assert(); } // Block terminates label_4236: // Incoming jump from 0x4234, if !(stack[-2] > 0x03) // Inputs[2] // { // @4237 stack[-1] // @4237 stack[-2] // } 4236 5B JUMPDEST 4237 14 EQ 4238 61 PUSH2 0x4255 423B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x4255, if stack[-1] == stack[-2] label_423C: // Incoming jump from 0x423B, if not stack[-1] == stack[-2] // Inputs[4] // { // @4240 memory[0x40:0x60] // @424C stack[-2] // @424D stack[-4] // @424F stack[-3] // } 423C 50 POP 423D 60 PUSH1 0x40 423F 80 DUP1 4240 51 MLOAD 4241 60 PUSH1 0x20 4243 81 DUP2 4244 01 ADD 4245 90 SWAP1 4246 91 SWAP2 4247 52 MSTORE 4248 60 PUSH1 0x00 424A 81 DUP2 424B 52 MSTORE 424C 90 SWAP1 424D 92 SWAP3 424E 50 POP 424F 90 SWAP1 4250 50 POP 4251 61 PUSH2 0x257f 4254 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @4247 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @424B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @424D stack[-4] = stack[-2] // @424F stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x257f label_4255: // Incoming jump from 0x423B, if stack[-1] == stack[-2] // Inputs[2] // { // @425C stack[-1] // @425D stack[-5] // } 4255 5B JUMPDEST 4256 60 PUSH1 0x00 4258 80 DUP1 4259 61 PUSH2 0x4262 425C 83 DUP4 425D 88 DUP9 425E 61 PUSH2 0x4823 4261 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @4256 stack[0] = 0x00 // @4258 stack[1] = 0x00 // @4259 stack[2] = 0x4262 // @425C stack[3] = stack[-1] // @425D stack[4] = stack[-5] // } // Block ends with call to 0x4823, returns to 0x4262 label_4262: // Incoming return from call to 0x4823 at 0x4261 // Inputs[4] // { // @4263 stack[-2] // @4263 stack[-1] // @4264 stack[-4] // @4266 stack[-3] // } 4262 5B JUMPDEST 4263 90 SWAP1 4264 92 SWAP3 4265 50 POP 4266 90 SWAP1 4267 50 POP 4268 60 PUSH1 0x00 426A 82 DUP3 426B 60 PUSH1 0x03 426D 81 DUP2 426E 11 GT 426F 15 ISZERO 4270 61 PUSH2 0x4275 4273 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @4264 stack[-4] = stack[-2] // @4266 stack[-3] = stack[-1] // @4268 stack[-2] = 0x00 // @426A stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x4275, if !(stack[-2] > 0x03) label_4274: // Incoming jump from 0x4273, if not !(stack[-2] > 0x03) 4274 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4274 assert(); } // Block terminates label_4275: // Incoming jump from 0x4273, if !(stack[-2] > 0x03) // Inputs[2] // { // @4276 stack[-2] // @4276 stack[-1] // } 4275 5B JUMPDEST 4276 14 EQ 4277 61 PUSH2 0x4297 427A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x4297, if stack[-1] == stack[-2] label_427B: // Incoming jump from 0x427A, if not stack[-1] == stack[-2] // Inputs[5] // { // @427F memory[0x40:0x60] // @428B stack[-2] // @428C stack[-6] // @428E stack[-5] // @4293 stack[-4] // } 427B 50 POP 427C 60 PUSH1 0x40 427E 80 DUP1 427F 51 MLOAD 4280 60 PUSH1 0x20 4282 81 DUP2 4283 01 ADD 4284 90 SWAP1 4285 91 SWAP2 4286 52 MSTORE 4287 60 PUSH1 0x00 4289 81 DUP2 428A 52 MSTORE 428B 90 SWAP1 428C 94 SWAP5 428D 50 POP 428E 92 SWAP3 428F 50 POP 4290 61 PUSH2 0x257f 4293 91 SWAP2 4294 50 POP 4295 50 POP 4296 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @4286 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @428A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @428C stack[-6] = stack[-2] // @428E stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x257f label_4297: // Incoming jump from 0x427A, if stack[-1] == stack[-2] // Inputs[5] // { // @429B memory[0x40:0x60] // @42A3 stack[-1] // @42A8 stack[-9] // @42AA stack[-8] // @42AC stack[-7] // } 4297 5B JUMPDEST 4298 60 PUSH1 0x40 429A 80 DUP1 429B 51 MLOAD 429C 60 PUSH1 0x20 429E 81 DUP2 429F 01 ADD 42A0 90 SWAP1 42A1 91 SWAP2 42A2 52 MSTORE 42A3 90 SWAP1 42A4 81 DUP2 42A5 52 MSTORE 42A6 60 PUSH1 0x00 42A8 98 SWAP9 42A9 90 SWAP1 42AA 97 SWAP8 42AB 50 POP 42AC 95 SWAP6 42AD 50 POP 42AE 50 POP 42AF 50 POP 42B0 50 POP 42B1 50 POP 42B2 50 POP 42B3 56 *JUMP // Stack delta = -7 // Outputs[4] // { // @42A2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @42A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @42A8 stack[-9] = 0x00 // @42AA stack[-8] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-9] label_42B4: // Incoming call from 0x2548, returns to 0x2549 42B4 5B JUMPDEST 42B5 60 PUSH1 0x00 42B7 61 PUSH2 0x42be 42BA 61 PUSH2 0x5357 42BD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @42B5 stack[0] = 0x00 // @42B7 stack[1] = 0x42be // } // Block ends with call to 0x5357, returns to 0x42BE label_42BE: // Incoming return from call to 0x5357 at 0x42BD // Inputs[1] { @42CE stack[-4] } 42BE 5B JUMPDEST 42BF 60 PUSH1 0x00 42C1 80 DUP1 42C2 61 PUSH2 0x42d3 42C5 67 PUSH8 0x0de0b6b3a7640000 42CE 87 DUP8 42CF 61 PUSH2 0x47e4 42D2 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @42BF stack[0] = 0x00 // @42C1 stack[1] = 0x00 // @42C2 stack[2] = 0x42d3 // @42C5 stack[3] = 0x0de0b6b3a7640000 // @42CE stack[4] = stack[-4] // } // Block ends with call to 0x47e4, returns to 0x42D3 label_42D3: // Incoming return from call to 0x47E4 at 0x42D2 // Inputs[4] // { // @42D4 stack[-2] // @42D4 stack[-1] // @42D5 stack[-4] // @42D7 stack[-3] // } 42D3 5B JUMPDEST 42D4 90 SWAP1 42D5 92 SWAP3 42D6 50 POP 42D7 90 SWAP1 42D8 50 POP 42D9 60 PUSH1 0x00 42DB 82 DUP3 42DC 60 PUSH1 0x03 42DE 81 DUP2 42DF 11 GT 42E0 15 ISZERO 42E1 61 PUSH2 0x42e6 42E4 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @42D5 stack[-4] = stack[-2] // @42D7 stack[-3] = stack[-1] // @42D9 stack[-2] = 0x00 // @42DB stack[-1] = stack[-2] // } // Block ends with conditional jump to 0x42e6, if !(stack[-2] > 0x03) label_42E5: // Incoming jump from 0x42E4, if not !(stack[-2] > 0x03) 42E5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @42E5 assert(); } // Block terminates label_42E6: // Incoming jump from 0x42E4, if !(stack[-2] > 0x03) // Inputs[2] // { // @42E7 stack[-2] // @42E7 stack[-1] // } 42E6 5B JUMPDEST 42E7 14 EQ 42E8 61 PUSH2 0x4305 42EB 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x4305, if stack[-1] == stack[-2] label_42EC: // Incoming jump from 0x42EB, if not stack[-1] == stack[-2] // Inputs[4] // { // @42F0 memory[0x40:0x60] // @42FC stack[-2] // @42FD stack[-4] // @42FF stack[-3] // } 42EC 50 POP 42ED 60 PUSH1 0x40 42EF 80 DUP1 42F0 51 MLOAD 42F1 60 PUSH1 0x20 42F3 81 DUP2 42F4 01 ADD 42F5 90 SWAP1 42F6 91 SWAP2 42F7 52 MSTORE 42F8 60 PUSH1 0x00 42FA 81 DUP2 42FB 52 MSTORE 42FC 90 SWAP1 42FD 92 SWAP3 42FE 50 POP 42FF 90 SWAP1 4300 50 POP 4301 61 PUSH2 0x257f 4304 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @42F7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @42FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @42FD stack[-4] = stack[-2] // @42FF stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x257f label_4305: // Incoming jump from 0x42EB, if stack[-1] == stack[-2] // Inputs[3] // { // @4309 stack[-1] // @430A stack[-5] // @430E memory[0x00 + stack[-5]:0x00 + stack[-5] + 0x20] // } 4305 5B JUMPDEST 4306 61 PUSH2 0x2578 4309 81 DUP2 430A 86 DUP7 430B 60 PUSH1 0x00 430D 01 ADD 430E 51 MLOAD 430F 61 PUSH2 0x4204 4312 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @4306 stack[0] = 0x2578 // @4309 stack[1] = stack[-1] // @430E stack[2] = memory[0x00 + stack[-5]:0x00 + stack[-5] + 0x20] // } // Block ends with call to 0x4204, returns to 0x2578 label_4313: // Incoming call from 0x2577, returns to 0x2578 // Incoming call from 0x3491, returns to 0x3492 // Inputs[3] // { // @4314 memory[stack[-1]:stack[-1] + 0x20] // @4314 stack[-1] // @4320 stack[-2] // } 4313 5B JUMPDEST 4314 51 MLOAD 4315 67 PUSH8 0x0de0b6b3a7640000 431E 90 SWAP1 431F 04 DIV 4320 90 SWAP1 4321 56 *JUMP // Stack delta = -1 // Outputs[1] { @4320 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] / 0x0de0b6b3a7640000 } // Block ends with unconditional jump to stack[-2] label_4322: // Incoming call from 0x265C, returns to 0x265D // Inputs[1] { @4346 stack[-3] } 4322 5B JUMPDEST 4323 60 PUSH1 0x00 4325 7F PUSH32 0x45b96fe442630264581b197e84bbada861235052c5a1aadfff9ea4e40a969aa0 4346 84 DUP5 4347 60 PUSH1 0x10 4349 81 DUP2 434A 11 GT 434B 15 ISZERO 434C 61 PUSH2 0x4351 434F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @4323 stack[0] = 0x00 // @4325 stack[1] = 0x45b96fe442630264581b197e84bbada861235052c5a1aadfff9ea4e40a969aa0 // @4346 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x4351, if !(stack[-3] > 0x10) label_4350: // Incoming jump from 0x434F, if not !(stack[-3] > 0x10) 4350 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4350 assert(); } // Block terminates label_4351: // Incoming jump from 0x434F, if !(stack[-3] > 0x10) // Inputs[1] { @4352 stack[-5] } 4351 5B JUMPDEST 4352 84 DUP5 4353 60 PUSH1 0x50 4355 81 DUP2 4356 11 GT 4357 15 ISZERO 4358 61 PUSH2 0x435d 435B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4352 stack[0] = stack[-5] } // Block ends with conditional jump to 0x435d, if !(stack[-5] > 0x50) label_435C: // Incoming jump from 0x435B, if not !(stack[-5] > 0x50) 435C FE *ASSERT // Stack delta = +0 // Outputs[1] { @435C assert(); } // Block terminates label_435D: // Incoming jump from 0x435B, if !(stack[-5] > 0x50) // Inputs[8] // { // @4361 memory[0x40:0x60] // @4362 stack[-2] // @4369 stack[-1] // @4370 stack[-5] // @4373 memory[0x40:0x60] // @437C stack[-3] // @437C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // @437D stack[-7] // } 435D 5B JUMPDEST 435E 60 PUSH1 0x40 4360 80 DUP1 4361 51 MLOAD 4362 92 SWAP3 4363 83 DUP4 4364 52 MSTORE 4365 60 PUSH1 0x20 4367 83 DUP4 4368 01 ADD 4369 91 SWAP2 436A 90 SWAP1 436B 91 SWAP2 436C 52 MSTORE 436D 81 DUP2 436E 81 DUP2 436F 01 ADD 4370 85 DUP6 4371 90 SWAP1 4372 52 MSTORE 4373 51 MLOAD 4374 90 SWAP1 4375 81 DUP2 4376 90 SWAP1 4377 03 SUB 4378 60 PUSH1 0x60 437A 01 ADD 437B 90 SWAP1 437C A1 LOG1 437D 83 DUP4 437E 60 PUSH1 0x10 4380 81 DUP2 4381 11 GT 4382 15 ISZERO 4383 61 PUSH2 0x1560 4386 57 *JUMPI // Stack delta = -2 // Outputs[5] // { // @4364 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @436C memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @4372 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-5] // @437C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])], [stack[-3]]); // @437D stack[-3] = stack[-7] // } // Block ends with conditional jump to 0x1560, if !(stack[-7] > 0x10) label_4387: // Incoming jump from 0x4386, if not !(stack[-7] > 0x10) 4387 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4387 assert(); } // Block terminates label_4388: // Incoming call from 0x268A, returns to 0x265D // Incoming jump from 0x3E27 // Inputs[1] { @43AC stack[-2] } 4388 5B JUMPDEST 4389 60 PUSH1 0x00 438B 7F PUSH32 0x45b96fe442630264581b197e84bbada861235052c5a1aadfff9ea4e40a969aa0 43AC 83 DUP4 43AD 60 PUSH1 0x10 43AF 81 DUP2 43B0 11 GT 43B1 15 ISZERO 43B2 61 PUSH2 0x43b7 43B5 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @4389 stack[0] = 0x00 // @438B stack[1] = 0x45b96fe442630264581b197e84bbada861235052c5a1aadfff9ea4e40a969aa0 // @43AC stack[2] = stack[-2] // } // Block ends with conditional jump to 0x43b7, if !(stack[-2] > 0x10) label_43B6: // Incoming jump from 0x43B5, if not !(stack[-2] > 0x10) 43B6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @43B6 assert(); } // Block terminates label_43B7: // Incoming jump from 0x43B5, if !(stack[-2] > 0x10) // Inputs[1] { @43B8 stack[-4] } 43B7 5B JUMPDEST 43B8 83 DUP4 43B9 60 PUSH1 0x50 43BB 81 DUP2 43BC 11 GT 43BD 15 ISZERO 43BE 61 PUSH2 0x43c3 43C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @43B8 stack[0] = stack[-4] } // Block ends with conditional jump to 0x43c3, if !(stack[-4] > 0x50) label_43C2: // Incoming jump from 0x43C1, if not !(stack[-4] > 0x50) 43C2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @43C2 assert(); } // Block terminates label_43C3: // Incoming jump from 0x43C1, if !(stack[-4] > 0x50) // Inputs[7] // { // @43C7 memory[0x40:0x60] // @43C8 stack[-2] // @43CF stack[-1] // @43D9 memory[0x40:0x60] // @43E2 stack[-3] // @43E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // @43E3 stack[-6] // } 43C3 5B JUMPDEST 43C4 60 PUSH1 0x40 43C6 80 DUP1 43C7 51 MLOAD 43C8 92 SWAP3 43C9 83 DUP4 43CA 52 MSTORE 43CB 60 PUSH1 0x20 43CD 83 DUP4 43CE 01 ADD 43CF 91 SWAP2 43D0 90 SWAP1 43D1 91 SWAP2 43D2 52 MSTORE 43D3 60 PUSH1 0x00 43D5 82 DUP3 43D6 82 DUP3 43D7 01 ADD 43D8 52 MSTORE 43D9 51 MLOAD 43DA 90 SWAP1 43DB 81 DUP2 43DC 90 SWAP1 43DD 03 SUB 43DE 60 PUSH1 0x60 43E0 01 ADD 43E1 90 SWAP1 43E2 A1 LOG1 43E3 82 DUP3 43E4 60 PUSH1 0x10 43E6 81 DUP2 43E7 11 GT 43E8 15 ISZERO 43E9 61 PUSH2 0x1681 43EC 57 *JUMPI // Stack delta = -2 // Outputs[5] // { // @43CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @43D2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @43D8 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = 0x00 // @43E2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])], [stack[-3]]); // @43E3 stack[-3] = stack[-6] // } // Block ends with conditional jump to 0x1681, if !(stack[-6] > 0x10) label_43ED: // Incoming jump from 0x43EC, if not !(stack[-6] > 0x10) 43ED FE *ASSERT // Stack delta = +0 // Outputs[1] { @43ED assert(); } // Block terminates label_43EE: // Incoming call from 0x512A, returns to 0x512B // Incoming call from 0x2F5D, returns to 0x2F5E // Incoming call from 0x32AA, returns to 0x32AB // Inputs[5] // { // @43F1 memory[0x40:0x60] // @43FD stack[-2] // @4400 stack[-1] // @4410 address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @4410 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 43EE 5B JUMPDEST 43EF 60 PUSH1 0x40 43F1 51 MLOAD 43F2 60 PUSH1 0x00 43F4 90 SWAP1 43F5 60 PUSH1 0x01 43F7 60 PUSH1 0x01 43F9 60 PUSH1 0xa0 43FB 1B SHL 43FC 03 SUB 43FD 84 DUP5 43FE 16 AND 43FF 90 SWAP1 4400 83 DUP4 4401 15 ISZERO 4402 61 PUSH2 0x08fc 4405 02 MUL 4406 90 SWAP1 4407 84 DUP5 4408 90 SWAP1 4409 84 DUP5 440A 81 DUP2 440B 81 DUP2 440C 81 DUP2 440D 85 DUP6 440E 88 DUP9 440F 88 DUP9 4410 F1 CALL 4411 93 SWAP4 4412 50 POP 4413 50 POP 4414 50 POP 4415 50 POP 4416 15 ISZERO 4417 80 DUP1 4418 15 ISZERO 4419 61 PUSH2 0x4426 441C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @43F4 stack[0] = 0x00 // @4410 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @4416 stack[1] = !address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x4426, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_441D: // Incoming jump from 0x441C, if not !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @441D returndata.length // @4421 returndata[0x00:0x00 + returndata.length] // @4422 returndata.length // @4425 memory[0x00:0x00 + returndata.length] // } 441D 3D RETURNDATASIZE 441E 60 PUSH1 0x00 4420 80 DUP1 4421 3E RETURNDATACOPY 4422 3D RETURNDATASIZE 4423 60 PUSH1 0x00 4425 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4421 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4425 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_4426: // Incoming jump from 0x441C, if !!address(stack[-2] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !stack[-1]).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @4428 stack[-2] // @4428 stack[-3] // @4429 stack[-5] // @442A stack[-4] // } 4426 5B JUMPDEST 4427 50 POP 4428 90 SWAP1 4429 92 SWAP3 442A 91 SWAP2 442B 50 POP 442C 50 POP 442D 56 *JUMP // Stack delta = -4 // Outputs[1] { @4429 stack[-5] = stack[-3] } // Block ends with unconditional jump to stack[-5] label_442E: // Incoming call from 0x30FC, returns to 0x30FD // Incoming call from 0x3E3F, returns to 0x3E40 // Incoming call from 0x4AFE, returns to 0x4AFF // Inputs[6] // { // @4432 storage[0x00] // @4436 memory[0x40:0x60] // @4444 address(this) // @4452 stack[-2] // @445B memory[0x40:0x60] // @4483 address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length // } 442E 5B JUMPDEST 442F 60 PUSH1 0x00 4431 80 DUP1 4432 54 SLOAD 4433 60 PUSH1 0x40 4435 80 DUP1 4436 51 MLOAD 4437 60 PUSH1 0x01 4439 60 PUSH1 0xe0 443B 1B SHL 443C 63 PUSH4 0x3205e017 4441 02 MUL 4442 81 DUP2 4443 52 MSTORE 4444 30 ADDRESS 4445 60 PUSH1 0x04 4447 82 DUP3 4448 01 ADD 4449 52 MSTORE 444A 60 PUSH1 0x01 444C 60 PUSH1 0x01 444E 60 PUSH1 0xa0 4450 1B SHL 4451 03 SUB 4452 86 DUP7 4453 81 DUP2 4454 16 AND 4455 60 PUSH1 0x24 4457 83 DUP4 4458 01 ADD 4459 52 MSTORE 445A 91 SWAP2 445B 51 MLOAD 445C 84 DUP5 445D 93 SWAP4 445E 84 DUP5 445F 93 SWAP4 4460 63 PUSH4 0x01000000 4465 90 SWAP1 4466 91 SWAP2 4467 04 DIV 4468 16 AND 4469 91 SWAP2 446A 63 PUSH4 0x3205e017 446F 91 SWAP2 4470 60 PUSH1 0x44 4472 80 DUP1 4473 83 DUP4 4474 01 ADD 4475 92 SWAP3 4476 60 PUSH1 0x20 4478 92 SWAP3 4479 91 SWAP2 447A 90 SWAP1 447B 82 DUP3 447C 90 SWAP1 447D 03 SUB 447E 01 ADD 447F 81 DUP2 4480 87 DUP8 4481 87 DUP8 4482 80 DUP1 4483 3B EXTCODESIZE 4484 15 ISZERO 4485 80 DUP1 4486 15 ISZERO 4487 61 PUSH2 0x448f 448A 57 *JUMPI // Stack delta = +13 // Outputs[16] // { // @442F stack[0] = 0x00 // @4443 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3205e017 * (0x01 << 0xe0) // @4449 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @4459 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @445D stack[1] = 0x00 // @445F stack[2] = 0x00 // @4469 stack[3] = storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01 // @446F stack[4] = 0x3205e017 // @4475 stack[5] = memory[0x40:0x60] + 0x44 // @4478 stack[6] = 0x20 // @4479 stack[7] = memory[0x40:0x60] // @447E stack[8] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @447F stack[9] = memory[0x40:0x60] // @4480 stack[10] = 0x00 // @4481 stack[11] = storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01 // @4484 stack[12] = !address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x448f, if !!address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length label_448B: // Incoming jump from 0x448A, if not !!address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @448E memory[0x00:0x00] } 448B 60 PUSH1 0x00 448D 80 DUP1 448E FD *REVERT // Stack delta = +0 // Outputs[1] { @448E revert(memory[0x00:0x00]); } // Block terminates label_448F: // Incoming jump from 0x448A, if !!address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @4491 msg.gas // @4492 stack[-2] // @4492 stack[-7] // @4492 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4492 stack[-6] // @4492 memory[stack[-4]:stack[-4] + stack[-5]] // @4492 stack[-3] // @4492 stack[-5] // @4492 stack[-4] // } 448F 5B JUMPDEST 4490 50 POP 4491 5A GAS 4492 F1 CALL 4493 15 ISZERO 4494 80 DUP1 4495 15 ISZERO 4496 61 PUSH2 0x44a3 4499 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @4492 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4493 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x44a3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_449A: // Incoming jump from 0x4499, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @449A returndata.length // @449E returndata[0x00:0x00 + returndata.length] // @449F returndata.length // @44A2 memory[0x00:0x00 + returndata.length] // } 449A 3D RETURNDATASIZE 449B 60 PUSH1 0x00 449D 80 DUP1 449E 3E RETURNDATACOPY 449F 3D RETURNDATASIZE 44A0 60 PUSH1 0x00 44A2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @449E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @44A2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_44A3: // Incoming jump from 0x4499, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @44AA memory[0x40:0x60] // @44AB returndata.length // } 44A3 5B JUMPDEST 44A4 50 POP 44A5 50 POP 44A6 50 POP 44A7 50 POP 44A8 60 PUSH1 0x40 44AA 51 MLOAD 44AB 3D RETURNDATASIZE 44AC 60 PUSH1 0x20 44AE 81 DUP2 44AF 10 LT 44B0 15 ISZERO 44B1 61 PUSH2 0x44b9 44B4 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @44AA stack[-4] = memory[0x40:0x60] // @44AB stack[-3] = returndata.length // } // Block ends with conditional jump to 0x44b9, if !(returndata.length < 0x20) label_44B5: // Incoming jump from 0x44B4, if not !(returndata.length < 0x20) // Inputs[1] { @44B8 memory[0x00:0x00] } 44B5 60 PUSH1 0x00 44B7 80 DUP1 44B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @44B8 revert(memory[0x00:0x00]); } // Block terminates label_44B9: // Incoming jump from 0x44B4, if !(returndata.length < 0x20) // Inputs[3] // { // @44BB stack[-2] // @44BB memory[stack[-2]:stack[-2] + 0x20] // @44BC stack[-3] // } 44B9 5B JUMPDEST 44BA 50 POP 44BB 51 MLOAD 44BC 90 SWAP1 44BD 50 POP 44BE 61 PUSH2 0x44c5 44C1 61 PUSH2 0x23f2 44C4 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @44BC stack[-3] = memory[stack[-2]:stack[-2] + 0x20] // @44BE stack[-2] = 0x44c5 // } // Block ends with call to 0x23f2, returns to 0x44C5 label_44C5: // Incoming return from call to 0x23F2 at 0x44C4 // Inputs[2] // { // @44C8 storage[0x08] // @44C9 stack[-1] // } 44C5 5B JUMPDEST 44C6 60 PUSH1 0x08 44C8 54 SLOAD 44C9 14 EQ 44CA 61 PUSH2 0x4506 44CD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4506, if storage[0x08] == stack[-1] label_44CE: // Incoming jump from 0x44CD, if not storage[0x08] == stack[-1] // Inputs[3] // { // @44D1 memory[0x40:0x60] // @44FC memory[0x40:0x60] // @4505 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 44CE 60 PUSH1 0x40 44D0 80 DUP1 44D1 51 MLOAD 44D2 60 PUSH1 0x01 44D4 60 PUSH1 0xe5 44D6 1B SHL 44D7 62 PUSH3 0x461bcd 44DB 02 MUL 44DC 81 DUP2 44DD 52 MSTORE 44DE 60 PUSH1 0x20 44E0 60 PUSH1 0x04 44E2 82 DUP3 44E3 01 ADD 44E4 52 MSTORE 44E5 60 PUSH1 0x03 44E7 60 PUSH1 0x24 44E9 82 DUP3 44EA 01 ADD 44EB 52 MSTORE 44EC 60 PUSH1 0x01 44EE 60 PUSH1 0xeb 44F0 1B SHL 44F1 62 PUSH3 0x08a647 44F5 02 MUL 44F6 60 PUSH1 0x44 44F8 82 DUP3 44F9 01 ADD 44FA 52 MSTORE 44FB 90 SWAP1 44FC 51 MLOAD 44FD 90 SWAP1 44FE 81 DUP2 44FF 90 SWAP1 4500 03 SUB 4501 60 PUSH1 0x64 4503 01 ADD 4504 90 SWAP1 4505 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @44DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @44E4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @44EB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @44FA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x08a647 * (0x01 << 0xeb) // @4505 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4506: // Incoming jump from 0x44CD, if storage[0x08] == stack[-1] // Inputs[1] { @4507 stack[-1] } 4506 5B JUMPDEST 4507 80 DUP1 4508 15 ISZERO 4509 61 PUSH2 0x4545 450C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4545, if !stack[-1] label_450D: // Incoming jump from 0x450C, if not !stack[-1] // Inputs[3] // { // @4510 memory[0x40:0x60] // @453B memory[0x40:0x60] // @4544 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 450D 60 PUSH1 0x40 450F 80 DUP1 4510 51 MLOAD 4511 60 PUSH1 0x01 4513 60 PUSH1 0xe5 4515 1B SHL 4516 62 PUSH3 0x461bcd 451A 02 MUL 451B 81 DUP2 451C 52 MSTORE 451D 60 PUSH1 0x20 451F 60 PUSH1 0x04 4521 82 DUP3 4522 01 ADD 4523 52 MSTORE 4524 60 PUSH1 0x03 4526 60 PUSH1 0x24 4528 82 DUP3 4529 01 ADD 452A 52 MSTORE 452B 60 PUSH1 0x01 452D 60 PUSH1 0xe8 452F 1B SHL 4530 62 PUSH3 0x453239 4534 02 MUL 4535 60 PUSH1 0x44 4537 82 DUP3 4538 01 ADD 4539 52 MSTORE 453A 90 SWAP1 453B 51 MLOAD 453C 90 SWAP1 453D 81 DUP2 453E 90 SWAP1 453F 03 SUB 4540 60 PUSH1 0x64 4542 01 ADD 4543 90 SWAP1 4544 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @451C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4523 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @452A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4539 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453239 * (0x01 << 0xe8) // @4544 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4545: // Incoming jump from 0x450C, if !stack[-1] 4545 5B JUMPDEST 4546 61 PUSH2 0x454d 4549 61 PUSH2 0x5311 454C 56 *JUMP // Stack delta = +1 // Outputs[1] { @4546 stack[0] = 0x454d } // Block ends with call to 0x5311, returns to 0x454D label_454D: // Incoming return from call to 0x5311 at 0x454C // Inputs[4] // { // @4556 stack[-6] // @4565 memory[0x00:0x40] // @4569 storage[0x01 + keccak256(memory[0x00:0x40])] // @456C stack[-1] // } 454D 5B JUMPDEST 454E 60 PUSH1 0x01 4550 60 PUSH1 0x01 4552 60 PUSH1 0xa0 4554 1B SHL 4555 03 SUB 4556 86 DUP7 4557 16 AND 4558 60 PUSH1 0x00 455A 90 SWAP1 455B 81 DUP2 455C 52 MSTORE 455D 60 PUSH1 0x11 455F 60 PUSH1 0x20 4561 52 MSTORE 4562 60 PUSH1 0x40 4564 90 SWAP1 4565 20 SHA3 4566 60 PUSH1 0x01 4568 01 ADD 4569 54 SLOAD 456A 60 PUSH1 0x60 456C 82 DUP3 456D 01 ADD 456E 52 MSTORE 456F 61 PUSH2 0x4577 4572 86 DUP7 4573 61 PUSH2 0x330c 4576 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @455C memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @4561 memory[0x20:0x40] = 0x11 // @456E memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = storage[0x01 + keccak256(memory[0x00:0x40])] // @456F stack[0] = 0x4577 // @4572 stack[1] = stack[-6] // } // Block ends with call to 0x330c, returns to 0x4577 label_4577: // Incoming return from call to 0x330C at 0x4576 // Inputs[3] // { // @457A stack[-3] // @457C stack[-1] // @4583 stack[-2] // } 4577 5B JUMPDEST 4578 60 PUSH1 0x80 457A 83 DUP4 457B 01 ADD 457C 81 DUP2 457D 90 SWAP1 457E 52 MSTORE 457F 60 PUSH1 0x20 4581 83 DUP4 4582 01 ADD 4583 82 DUP3 4584 60 PUSH1 0x03 4586 81 DUP2 4587 11 GT 4588 15 ISZERO 4589 61 PUSH2 0x458e 458C 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @457E memory[stack[-3] + 0x80:stack[-3] + 0x80 + 0x20] = stack[-1] // @4582 stack[0] = stack[-3] + 0x20 // @4583 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x458e, if !(stack[-2] > 0x03) label_458D: // Incoming jump from 0x458C, if not !(stack[-2] > 0x03) 458D FE *ASSERT // Stack delta = +0 // Outputs[1] { @458D assert(); } // Block terminates label_458E: // Incoming jump from 0x458C, if !(stack[-2] > 0x03) // Inputs[1] { @4591 stack[-1] } 458E 5B JUMPDEST 458F 60 PUSH1 0x03 4591 81 DUP2 4592 11 GT 4593 15 ISZERO 4594 61 PUSH2 0x4599 4597 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4599, if !(stack[-1] > 0x03) label_4598: // Incoming jump from 0x4597, if not !(stack[-1] > 0x03) 4598 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4598 assert(); } // Block terminates label_4599: // Incoming jump from 0x4597, if !(stack[-1] > 0x03) // Inputs[5] // { // @459A stack[-2] // @459A stack[-1] // @459F stack[-4] // @45A1 stack[-5] // @45A5 memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } 4599 5B JUMPDEST 459A 90 SWAP1 459B 52 MSTORE 459C 50 POP 459D 60 PUSH1 0x00 459F 90 SWAP1 45A0 50 POP 45A1 81 DUP2 45A2 60 PUSH1 0x20 45A4 01 ADD 45A5 51 MLOAD 45A6 60 PUSH1 0x03 45A8 81 DUP2 45A9 11 GT 45AA 15 ISZERO 45AB 61 PUSH2 0x45b0 45AE 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @459B memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @459F stack[-4] = 0x00 // @45A5 stack[-3] = memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } // Block ends with conditional jump to 0x45b0, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) label_45AF: // Incoming jump from 0x45AE, if not !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) 45AF FE *ASSERT // Stack delta = +0 // Outputs[1] { @45AF assert(); } // Block terminates label_45B0: // Incoming jump from 0x45AE, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @45B1 stack[-1] // @45B1 stack[-2] // } 45B0 5B JUMPDEST 45B1 14 EQ 45B2 61 PUSH2 0x45ee 45B5 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x45ee, if stack[-1] == stack[-2] label_45B6: // Incoming jump from 0x45B5, if not stack[-1] == stack[-2] // Inputs[3] // { // @45B9 memory[0x40:0x60] // @45E4 memory[0x40:0x60] // @45ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 45B6 60 PUSH1 0x40 45B8 80 DUP1 45B9 51 MLOAD 45BA 60 PUSH1 0x01 45BC 60 PUSH1 0xe5 45BE 1B SHL 45BF 62 PUSH3 0x461bcd 45C3 02 MUL 45C4 81 DUP2 45C5 52 MSTORE 45C6 60 PUSH1 0x20 45C8 60 PUSH1 0x04 45CA 82 DUP3 45CB 01 ADD 45CC 52 MSTORE 45CD 60 PUSH1 0x03 45CF 60 PUSH1 0x24 45D1 82 DUP3 45D2 01 ADD 45D3 52 MSTORE 45D4 60 PUSH1 0x01 45D6 60 PUSH1 0xec 45D8 1B SHL 45D9 62 PUSH3 0x045333 45DD 02 MUL 45DE 60 PUSH1 0x44 45E0 82 DUP3 45E1 01 ADD 45E2 52 MSTORE 45E3 90 SWAP1 45E4 51 MLOAD 45E5 90 SWAP1 45E6 81 DUP2 45E7 90 SWAP1 45E8 03 SUB 45E9 60 PUSH1 0x64 45EB 01 ADD 45EC 90 SWAP1 45ED FD *REVERT // Stack delta = +0 // Outputs[5] // { // @45C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @45CC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @45D3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @45E2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x045333 * (0x01 << 0xec) // @45ED revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_45EE: // Incoming jump from 0x45B5, if stack[-1] == stack[-2] // Inputs[1] { @45F2 stack[-5] } 45EE 5B JUMPDEST 45EF 60 PUSH1 0x00 45F1 19 NOT 45F2 85 DUP6 45F3 14 EQ 45F4 15 ISZERO 45F5 61 PUSH2 0x4607 45F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4607, if !(stack[-5] == ~0x00) label_45F9: // Incoming jump from 0x45F8, if not !(stack[-5] == ~0x00) // Inputs[2] // { // @45FB stack[-1] // @45FD memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] // } 45F9 60 PUSH1 0x80 45FB 81 DUP2 45FC 01 ADD 45FD 51 MLOAD 45FE 60 PUSH1 0x40 4600 82 DUP3 4601 01 ADD 4602 52 MSTORE 4603 61 PUSH2 0x460f 4606 56 *JUMP // Stack delta = +0 // Outputs[1] { @4602 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] } // Block ends with unconditional jump to 0x460f label_4607: // Incoming jump from 0x45F8, if !(stack[-5] == ~0x00) // Inputs[4] // { // @460A stack[-1] // @460C stack[-5] // @4613 stack[-7] // @4618 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 4607 5B JUMPDEST 4608 60 PUSH1 0x40 460A 81 DUP2 460B 01 ADD 460C 85 DUP6 460D 90 SWAP1 460E 52 MSTORE 460F 5B JUMPDEST 4610 61 PUSH2 0x461d 4613 87 DUP8 4614 82 DUP3 4615 60 PUSH1 0x40 4617 01 ADD 4618 51 MLOAD 4619 61 PUSH2 0x24a1 461C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @460E memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-5] // @4610 stack[0] = 0x461d // @4613 stack[1] = stack[-7] // @4618 stack[2] = memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } // Block ends with call to 0x24a1, returns to 0x461D label_461D: // Incoming return from call to 0x24A1 at 0x461C // Incoming return from call to 0x24A1 at 0x461C // Inputs[3] // { // @4620 stack[-2] // @4622 stack[-1] // @4629 memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // } 461D 5B JUMPDEST 461E 60 PUSH1 0xe0 4620 82 DUP3 4621 01 ADD 4622 81 DUP2 4623 90 SWAP1 4624 52 MSTORE 4625 60 PUSH1 0x80 4627 82 DUP3 4628 01 ADD 4629 51 MLOAD 462A 61 PUSH2 0x4632 462D 91 SWAP2 462E 61 PUSH2 0x33c0 4631 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @4624 memory[stack[-2] + 0xe0:stack[-2] + 0xe0 + 0x20] = stack[-1] // @4629 stack[0] = memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @462D stack[1] = stack[-1] // @462D stack[-1] = 0x4632 // } // Block ends with call to 0x33c0, returns to 0x4632 label_4632: // Incoming return from call to 0x33C0 at 0x4631 // Inputs[3] // { // @4635 stack[-3] // @4637 stack[-1] // @463E stack[-2] // } 4632 5B JUMPDEST 4633 60 PUSH1 0xa0 4635 83 DUP4 4636 01 ADD 4637 81 DUP2 4638 90 SWAP1 4639 52 MSTORE 463A 60 PUSH1 0x20 463C 83 DUP4 463D 01 ADD 463E 82 DUP3 463F 60 PUSH1 0x03 4641 81 DUP2 4642 11 GT 4643 15 ISZERO 4644 61 PUSH2 0x4649 4647 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @4639 memory[stack[-3] + 0xa0:stack[-3] + 0xa0 + 0x20] = stack[-1] // @463D stack[0] = stack[-3] + 0x20 // @463E stack[1] = stack[-2] // } // Block ends with conditional jump to 0x4649, if !(stack[-2] > 0x03) label_4648: // Incoming jump from 0x4647, if not !(stack[-2] > 0x03) 4648 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4648 assert(); } // Block terminates label_4649: // Incoming jump from 0x4647, if !(stack[-2] > 0x03) // Inputs[1] { @464C stack[-1] } 4649 5B JUMPDEST 464A 60 PUSH1 0x03 464C 81 DUP2 464D 11 GT 464E 15 ISZERO 464F 61 PUSH2 0x4654 4652 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4654, if !(stack[-1] > 0x03) label_4653: // Incoming jump from 0x4652, if not !(stack[-1] > 0x03) 4653 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4653 assert(); } // Block terminates label_4654: // Incoming jump from 0x4652, if !(stack[-1] > 0x03) // Inputs[5] // { // @4655 stack[-1] // @4655 stack[-2] // @465A stack[-4] // @465C stack[-5] // @4660 memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } 4654 5B JUMPDEST 4655 90 SWAP1 4656 52 MSTORE 4657 50 POP 4658 60 PUSH1 0x00 465A 90 SWAP1 465B 50 POP 465C 81 DUP2 465D 60 PUSH1 0x20 465F 01 ADD 4660 51 MLOAD 4661 60 PUSH1 0x03 4663 81 DUP2 4664 11 GT 4665 15 ISZERO 4666 61 PUSH2 0x466b 4669 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @4656 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @465A stack[-4] = 0x00 // @4660 stack[-3] = memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } // Block ends with conditional jump to 0x466b, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) label_466A: // Incoming jump from 0x4669, if not !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) 466A FE *ASSERT // Stack delta = +0 // Outputs[1] { @466A assert(); } // Block terminates label_466B: // Incoming jump from 0x4669, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @466C stack[-1] // @466C stack[-2] // } 466B 5B JUMPDEST 466C 14 EQ 466D 61 PUSH2 0x46a9 4670 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x46a9, if stack[-1] == stack[-2] label_4671: // Incoming jump from 0x4670, if not stack[-1] == stack[-2] // Inputs[3] // { // @4674 memory[0x40:0x60] // @469F memory[0x40:0x60] // @46A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4671 60 PUSH1 0x40 4673 80 DUP1 4674 51 MLOAD 4675 60 PUSH1 0x01 4677 60 PUSH1 0xe5 4679 1B SHL 467A 62 PUSH3 0x461bcd 467E 02 MUL 467F 81 DUP2 4680 52 MSTORE 4681 60 PUSH1 0x20 4683 60 PUSH1 0x04 4685 82 DUP3 4686 01 ADD 4687 52 MSTORE 4688 60 PUSH1 0x03 468A 60 PUSH1 0x24 468C 82 DUP3 468D 01 ADD 468E 52 MSTORE 468F 60 PUSH1 0x01 4691 60 PUSH1 0xe8 4693 1B SHL 4694 62 PUSH3 0x453331 4698 02 MUL 4699 60 PUSH1 0x44 469B 82 DUP3 469C 01 ADD 469D 52 MSTORE 469E 90 SWAP1 469F 51 MLOAD 46A0 90 SWAP1 46A1 81 DUP2 46A2 90 SWAP1 46A3 03 SUB 46A4 60 PUSH1 0x64 46A6 01 ADD 46A7 90 SWAP1 46A8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4680 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4687 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @468E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @469D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453331 * (0x01 << 0xe8) // @46A8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_46A9: // Incoming jump from 0x4670, if stack[-1] == stack[-2] // Inputs[3] // { // @46AF storage[0x06] // @46B0 stack[-1] // @46B4 memory[0xe0 + stack[-1]:0xe0 + stack[-1] + 0x20] // } 46A9 5B JUMPDEST 46AA 61 PUSH2 0x46b9 46AD 60 PUSH1 0x06 46AF 54 SLOAD 46B0 82 DUP3 46B1 60 PUSH1 0xe0 46B3 01 ADD 46B4 51 MLOAD 46B5 61 PUSH2 0x33c0 46B8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @46AA stack[0] = 0x46b9 // @46AF stack[1] = storage[0x06] // @46B4 stack[2] = memory[0xe0 + stack[-1]:0xe0 + stack[-1] + 0x20] // } // Block ends with call to 0x33c0, returns to 0x46B9 label_46B9: // Incoming return from call to 0x33C0 at 0x46B8 // Inputs[3] // { // @46BC stack[-3] // @46BE stack[-1] // @46C5 stack[-2] // } 46B9 5B JUMPDEST 46BA 60 PUSH1 0xc0 46BC 83 DUP4 46BD 01 ADD 46BE 81 DUP2 46BF 90 SWAP1 46C0 52 MSTORE 46C1 60 PUSH1 0x20 46C3 83 DUP4 46C4 01 ADD 46C5 82 DUP3 46C6 60 PUSH1 0x03 46C8 81 DUP2 46C9 11 GT 46CA 15 ISZERO 46CB 61 PUSH2 0x46d0 46CE 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @46C0 memory[stack[-3] + 0xc0:stack[-3] + 0xc0 + 0x20] = stack[-1] // @46C4 stack[0] = stack[-3] + 0x20 // @46C5 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x46d0, if !(stack[-2] > 0x03) label_46CF: // Incoming jump from 0x46CE, if not !(stack[-2] > 0x03) 46CF FE *ASSERT // Stack delta = +0 // Outputs[1] { @46CF assert(); } // Block terminates label_46D0: // Incoming jump from 0x46CE, if !(stack[-2] > 0x03) // Inputs[1] { @46D3 stack[-1] } 46D0 5B JUMPDEST 46D1 60 PUSH1 0x03 46D3 81 DUP2 46D4 11 GT 46D5 15 ISZERO 46D6 61 PUSH2 0x46db 46D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x46db, if !(stack[-1] > 0x03) label_46DA: // Incoming jump from 0x46D9, if not !(stack[-1] > 0x03) 46DA FE *ASSERT // Stack delta = +0 // Outputs[1] { @46DA assert(); } // Block terminates label_46DB: // Incoming jump from 0x46D9, if !(stack[-1] > 0x03) // Inputs[5] // { // @46DC stack[-1] // @46DC stack[-2] // @46E1 stack[-4] // @46E3 stack[-5] // @46E7 memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } 46DB 5B JUMPDEST 46DC 90 SWAP1 46DD 52 MSTORE 46DE 50 POP 46DF 60 PUSH1 0x00 46E1 90 SWAP1 46E2 50 POP 46E3 81 DUP2 46E4 60 PUSH1 0x20 46E6 01 ADD 46E7 51 MLOAD 46E8 60 PUSH1 0x03 46EA 81 DUP2 46EB 11 GT 46EC 15 ISZERO 46ED 61 PUSH2 0x46f2 46F0 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @46DD memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @46E1 stack[-4] = 0x00 // @46E7 stack[-3] = memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] // } // Block ends with conditional jump to 0x46f2, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) label_46F1: // Incoming jump from 0x46F0, if not !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) 46F1 FE *ASSERT // Stack delta = +0 // Outputs[1] { @46F1 assert(); } // Block terminates label_46F2: // Incoming jump from 0x46F0, if !(memory[0x20 + stack[-5]:0x20 + stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @46F3 stack[-2] // @46F3 stack[-1] // } 46F2 5B JUMPDEST 46F3 14 EQ 46F4 61 PUSH2 0x4730 46F7 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x4730, if stack[-1] == stack[-2] label_46F8: // Incoming jump from 0x46F7, if not stack[-1] == stack[-2] // Inputs[3] // { // @46FB memory[0x40:0x60] // @4726 memory[0x40:0x60] // @472F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 46F8 60 PUSH1 0x40 46FA 80 DUP1 46FB 51 MLOAD 46FC 60 PUSH1 0x01 46FE 60 PUSH1 0xe5 4700 1B SHL 4701 62 PUSH3 0x461bcd 4705 02 MUL 4706 81 DUP2 4707 52 MSTORE 4708 60 PUSH1 0x20 470A 60 PUSH1 0x04 470C 82 DUP3 470D 01 ADD 470E 52 MSTORE 470F 60 PUSH1 0x03 4711 60 PUSH1 0x24 4713 82 DUP3 4714 01 ADD 4715 52 MSTORE 4716 60 PUSH1 0x01 4718 60 PUSH1 0xe9 471A 1B SHL 471B 62 PUSH3 0x229999 471F 02 MUL 4720 60 PUSH1 0x44 4722 82 DUP3 4723 01 ADD 4724 52 MSTORE 4725 90 SWAP1 4726 51 MLOAD 4727 90 SWAP1 4728 81 DUP2 4729 90 SWAP1 472A 03 SUB 472B 60 PUSH1 0x64 472D 01 ADD 472E 90 SWAP1 472F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4707 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @470E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4715 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4724 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229999 * (0x01 << 0xe9) // @472F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4730: // Incoming jump from 0x46F7, if stack[-1] == stack[-2] // Inputs[16] // { // @4734 stack[-1] // @4737 memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @4741 stack[-6] // @4753 memory[0x00:0x40] // @4759 memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @4761 memory[0x00:0x40] // @4767 storage[0x09] // @4775 memory[stack[-1] + 0xc0:stack[-1] + 0xc0 + 0x20] // @477F memory[stack[-1] + 0xe0:stack[-1] + 0xe0 + 0x20] // @4781 memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @4783 memory[0x40:0x60] // @4785 stack[-7] // @47A7 memory[0x40:0x60] // @47D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])] // @47D6 memory[0xe0 + stack[-1]:0xe0 + stack[-1] + 0x20] // @47D9 stack[-8] // } 4730 5B JUMPDEST 4731 60 PUSH1 0xa0 4733 80 DUP1 4734 82 DUP3 4735 01 ADD 4736 80 DUP1 4737 51 MLOAD 4738 60 PUSH1 0x01 473A 60 PUSH1 0x01 473C 60 PUSH1 0xa0 473E 1B SHL 473F 03 SUB 4740 80 DUP1 4741 8A DUP11 4742 16 AND 4743 60 PUSH1 0x00 4745 81 DUP2 4746 81 DUP2 4747 52 MSTORE 4748 60 PUSH1 0x10 474A 60 PUSH1 0x20 474C 90 SWAP1 474D 81 DUP2 474E 52 MSTORE 474F 60 PUSH1 0x40 4751 80 DUP1 4752 83 DUP4 4753 20 SHA3 4754 95 SWAP6 4755 90 SWAP1 4756 95 SWAP6 4757 55 SSTORE 4758 85 DUP6 4759 51 MLOAD 475A 60 PUSH1 0x11 475C 82 DUP3 475D 52 MSTORE 475E 91 SWAP2 475F 85 DUP6 4760 90 SWAP1 4761 20 SHA3 4762 91 SWAP2 4763 82 DUP3 4764 55 SSTORE 4765 60 PUSH1 0x09 4767 54 SLOAD 4768 60 PUSH1 0x01 476A 90 SWAP1 476B 92 SWAP3 476C 01 ADD 476D 91 SWAP2 476E 90 SWAP1 476F 91 SWAP2 4770 55 SSTORE 4771 60 PUSH1 0xc0 4773 87 DUP8 4774 01 ADD 4775 51 MLOAD 4776 60 PUSH1 0x06 4778 81 DUP2 4779 90 SWAP1 477A 55 SSTORE 477B 60 PUSH1 0xe0 477D 88 DUP9 477E 01 ADD 477F 51 MLOAD 4780 95 SWAP6 4781 51 MLOAD 4782 85 DUP6 4783 51 MLOAD 4784 94 SWAP5 4785 8F DUP16 4786 16 AND 4787 85 DUP6 4788 52 MSTORE 4789 91 SWAP2 478A 84 DUP5 478B 01 ADD 478C 92 SWAP3 478D 90 SWAP1 478E 92 SWAP3 478F 52 MSTORE 4790 82 DUP3 4791 84 DUP5 4792 01 ADD 4793 94 SWAP5 4794 90 SWAP1 4795 94 SWAP5 4796 52 MSTORE 4797 60 PUSH1 0x60 4799 82 DUP3 479A 01 ADD 479B 93 SWAP4 479C 90 SWAP1 479D 93 SWAP4 479E 52 MSTORE 479F 60 PUSH1 0x80 47A1 81 DUP2 47A2 01 ADD 47A3 92 SWAP3 47A4 90 SWAP1 47A5 92 SWAP3 47A6 52 MSTORE 47A7 51 MLOAD 47A8 7F PUSH32 0x1a2a22cb034d26d1854bdc6666a5b91fe25efbbb5dcad3b0355478d6f5c362a1 47C9 92 SWAP3 47CA 91 SWAP2 47CB 81 DUP2 47CC 90 SWAP1 47CD 03 SUB 47CE 90 SWAP1 47CF 91 SWAP2 47D0 01 ADD 47D1 90 SWAP1 47D2 A1 LOG1 47D3 60 PUSH1 0xe0 47D5 01 ADD 47D6 51 MLOAD 47D7 60 PUSH1 0x00 47D9 97 SWAP8 47DA 90 SWAP1 47DB 96 SWAP7 47DC 50 POP 47DD 94 SWAP5 47DE 50 POP 47DF 50 POP 47E0 50 POP 47E1 50 POP 47E2 50 POP 47E3 56 *JUMP // Stack delta = -6 // Outputs[15] // { // @4747 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @474E memory[0x20:0x40] = 0x10 // @4757 storage[keccak256(memory[0x00:0x40])] = memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @475D memory[0x20:0x40] = 0x11 // @4764 storage[keccak256(memory[0x00:0x40])] = memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @4770 storage[keccak256(memory[0x00:0x40]) + 0x01] = storage[0x09] // @477A storage[0x06] = memory[stack[-1] + 0xc0:stack[-1] + 0xc0 + 0x20] // @4788 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-7] & (0x01 << 0xa0) - 0x01 // @478F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @4796 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = memory[stack[-1] + 0xe0:stack[-1] + 0xe0 + 0x20] // @479E memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @47A6 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = memory[stack[-1] + 0xc0:stack[-1] + 0xc0 + 0x20] // @47D2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x1a2a22cb034d26d1854bdc6666a5b91fe25efbbb5dcad3b0355478d6f5c362a1]); // @47D9 stack[-8] = 0x00 // @47DB stack[-7] = memory[0xe0 + stack[-1]:0xe0 + stack[-1] + 0x20] // } // Block ends with unconditional jump to stack[-8] label_47E4: // Incoming call from 0x42D2, returns to 0x42D3 // Incoming call from 0x33FD, returns to 0x33FE // Incoming call from 0x4222, returns to 0x4223 // Incoming call from 0x3352, returns to 0x3353 // Inputs[1] { @47E8 stack[-2] } 47E4 5B JUMPDEST 47E5 60 PUSH1 0x00 47E7 80 DUP1 47E8 83 DUP4 47E9 61 PUSH2 0x47f7 47EC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @47E5 stack[0] = 0x00 // @47E7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x47f7, if stack[-2] label_47ED: // Incoming jump from 0x47EC, if not stack[-2] // Inputs[1] { @47F0 stack[-2] } 47ED 50 POP 47EE 60 PUSH1 0x00 47F0 90 SWAP1 47F1 50 POP 47F2 80 DUP1 47F3 61 PUSH2 0x257f 47F6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @47F0 stack[-2] = 0x00 // @47F2 stack[-1] = 0x00 // } // Block ends with unconditional jump to 0x257f label_47F7: // Incoming jump from 0x47EC, if stack[-2] // Inputs[2] // { // @47F8 stack[-4] // @47F9 stack[-3] // } 47F7 5B JUMPDEST 47F8 83 DUP4 47F9 83 DUP4 47FA 02 MUL 47FB 83 DUP4 47FC 85 DUP6 47FD 82 DUP3 47FE 81 DUP2 47FF 61 PUSH2 0x4804 4802 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @47FA stack[0] = stack[-3] * stack[-4] // @47FB stack[1] = stack[-3] // @47FC stack[2] = stack[-4] // @47FD stack[3] = stack[-3] * stack[-4] // } // Block ends with conditional jump to 0x4804, if stack[-4] label_4803: // Incoming jump from 0x4802, if not stack[-4] 4803 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4803 assert(); } // Block terminates label_4804: // Incoming jump from 0x4802, if stack[-4] // Inputs[3] // { // @4805 stack[-2] // @4805 stack[-1] // @4806 stack[-3] // } 4804 5B JUMPDEST 4805 04 DIV 4806 14 EQ 4807 61 PUSH2 0x4818 480A 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x4818, if stack[-1] / stack[-2] == stack[-3] label_480B: // Incoming jump from 0x480A, if not stack[-1] / stack[-2] == stack[-3] // Inputs[2] // { // @480E stack[-3] // @4812 stack[-2] // } 480B 50 POP 480C 60 PUSH1 0x02 480E 91 SWAP2 480F 50 POP 4810 60 PUSH1 0x00 4812 90 SWAP1 4813 50 POP 4814 61 PUSH2 0x257f 4817 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @480E stack[-3] = 0x02 // @4812 stack[-2] = 0x00 // } // Block ends with unconditional jump to 0x257f label_4818: // Incoming jump from 0x480A, if stack[-1] / stack[-2] == stack[-3] // Inputs[3] // { // @481B stack[-3] // @481D stack[-2] // @481D stack[-1] // } 4818 5B JUMPDEST 4819 60 PUSH1 0x00 481B 92 SWAP3 481C 50 POP 481D 90 SWAP1 481E 50 POP 481F 61 PUSH2 0x257f 4822 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @481B stack[-3] = 0x00 // @481D stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x257f label_4823: // Incoming call from 0x4261, returns to 0x4262 // Incoming call from 0x3388, returns to 0x3389 // Inputs[1] { @4827 stack[-1] } 4823 5B JUMPDEST 4824 60 PUSH1 0x00 4826 80 DUP1 4827 82 DUP3 4828 61 PUSH2 0x4837 482B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @4824 stack[0] = 0x00 // @4826 stack[1] = 0x00 // } // Block ends with conditional jump to 0x4837, if stack[-1] label_482C: // Incoming jump from 0x482B, if not stack[-1] // Inputs[1] { @482F stack[-2] } 482C 50 POP 482D 60 PUSH1 0x01 482F 90 SWAP1 4830 50 POP 4831 60 PUSH1 0x00 4833 61 PUSH2 0x257f 4836 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @482F stack[-2] = 0x01 // @4831 stack[-1] = 0x00 // } // Block ends with unconditional jump to 0x257f label_4837: // Incoming jump from 0x482B, if stack[-1] // Inputs[2] // { // @483A stack[-3] // @483B stack[-4] // } 4837 5B JUMPDEST 4838 60 PUSH1 0x00 483A 83 DUP4 483B 85 DUP6 483C 81 DUP2 483D 61 PUSH2 0x4842 4840 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @4838 stack[0] = 0x00 // @483A stack[1] = stack[-3] // @483B stack[2] = stack[-4] // } // Block ends with conditional jump to 0x4842, if stack[-3] label_4841: // Incoming jump from 0x4840, if not stack[-3] 4841 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4841 assert(); } // Block terminates label_4842: // Incoming jump from 0x4840, if stack[-3] // Inputs[8] // { // @4843 stack[-1] // @4843 stack[-2] // @4844 stack[-4] // @4846 stack[-3] // @4846 stack[-5] // @4848 stack[-7] // @484A stack[-8] // @484B stack[-6] // } 4842 5B JUMPDEST 4843 04 DIV 4844 91 SWAP2 4845 50 POP 4846 91 SWAP2 4847 50 POP 4848 92 SWAP3 4849 50 POP 484A 92 SWAP3 484B 90 SWAP1 484C 50 POP 484D 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @4848 stack[-7] = stack[-1] / stack[-2] // @484A stack[-8] = stack[-3] // } // Block ends with unconditional jump to stack[-8] label_484E: // Incoming call from 0x35F9, returns to 0x35FA // Inputs[8] // { // @4852 storage[0x00] // @4856 memory[0x40:0x60] // @4864 address(this) // @4872 stack[-1] // @487A stack[-3] // @4886 stack[-2] // @488A memory[0x40:0x60] // @48B2 address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length // } 484E 5B JUMPDEST 484F 60 PUSH1 0x00 4851 80 DUP1 4852 54 SLOAD 4853 60 PUSH1 0x40 4855 80 DUP1 4856 51 MLOAD 4857 60 PUSH1 0x01 4859 60 PUSH1 0xe0 485B 1B SHL 485C 63 PUSH4 0x6e2cf5af 4861 02 MUL 4862 81 DUP2 4863 52 MSTORE 4864 30 ADDRESS 4865 60 PUSH1 0x04 4867 82 DUP3 4868 01 ADD 4869 52 MSTORE 486A 60 PUSH1 0x01 486C 60 PUSH1 0x01 486E 60 PUSH1 0xa0 4870 1B SHL 4871 03 SUB 4872 85 DUP6 4873 81 DUP2 4874 16 AND 4875 60 PUSH1 0x24 4877 83 DUP4 4878 01 ADD 4879 52 MSTORE 487A 87 DUP8 487B 81 DUP2 487C 16 AND 487D 60 PUSH1 0x44 487F 83 DUP4 4880 01 ADD 4881 52 MSTORE 4882 60 PUSH1 0x64 4884 82 DUP3 4885 01 ADD 4886 87 DUP8 4887 90 SWAP1 4888 52 MSTORE 4889 91 SWAP2 488A 51 MLOAD 488B 84 DUP5 488C 93 SWAP4 488D 84 DUP5 488E 93 SWAP4 488F 63 PUSH4 0x01000000 4894 90 SWAP1 4895 91 SWAP2 4896 04 DIV 4897 16 AND 4898 91 SWAP2 4899 63 PUSH4 0x6e2cf5af 489E 91 SWAP2 489F 60 PUSH1 0x84 48A1 80 DUP1 48A2 83 DUP4 48A3 01 ADD 48A4 92 SWAP3 48A5 60 PUSH1 0x20 48A7 92 SWAP3 48A8 91 SWAP2 48A9 90 SWAP1 48AA 82 DUP3 48AB 90 SWAP1 48AC 03 SUB 48AD 01 ADD 48AE 81 DUP2 48AF 87 DUP8 48B0 87 DUP8 48B1 80 DUP1 48B2 3B EXTCODESIZE 48B3 15 ISZERO 48B4 80 DUP1 48B5 15 ISZERO 48B6 61 PUSH2 0x48be 48B9 57 *JUMPI // Stack delta = +13 // Outputs[18] // { // @484F stack[0] = 0x00 // @4863 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6e2cf5af * (0x01 << 0xe0) // @4869 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @4879 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @4881 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @4888 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-2] // @488C stack[1] = 0x00 // @488E stack[2] = 0x00 // @4898 stack[3] = storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01 // @489E stack[4] = 0x6e2cf5af // @48A4 stack[5] = memory[0x40:0x60] + 0x84 // @48A7 stack[6] = 0x20 // @48A8 stack[7] = memory[0x40:0x60] // @48AD stack[8] = memory[0x40:0x60] - memory[0x40:0x60] + 0x84 // @48AE stack[9] = memory[0x40:0x60] // @48AF stack[10] = 0x00 // @48B0 stack[11] = storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01 // @48B3 stack[12] = !address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x48be, if !!address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length label_48BA: // Incoming jump from 0x48B9, if not !!address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @48BD memory[0x00:0x00] } 48BA 60 PUSH1 0x00 48BC 80 DUP1 48BD FD *REVERT // Stack delta = +0 // Outputs[1] { @48BD revert(memory[0x00:0x00]); } // Block terminates label_48BE: // Incoming jump from 0x48B9, if !!address(storage[0x00] / 0x01000000 & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @48C0 msg.gas // @48C1 stack[-3] // @48C1 stack[-6] // @48C1 stack[-7] // @48C1 memory[stack[-4]:stack[-4] + stack[-5]] // @48C1 stack[-2] // @48C1 stack[-5] // @48C1 stack[-4] // @48C1 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 48BE 5B JUMPDEST 48BF 50 POP 48C0 5A GAS 48C1 F1 CALL 48C2 15 ISZERO 48C3 80 DUP1 48C4 15 ISZERO 48C5 61 PUSH2 0x48d2 48C8 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @48C1 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @48C2 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x48d2, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_48C9: // Incoming jump from 0x48C8, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @48C9 returndata.length // @48CD returndata[0x00:0x00 + returndata.length] // @48CE returndata.length // @48D1 memory[0x00:0x00 + returndata.length] // } 48C9 3D RETURNDATASIZE 48CA 60 PUSH1 0x00 48CC 80 DUP1 48CD 3E RETURNDATACOPY 48CE 3D RETURNDATASIZE 48CF 60 PUSH1 0x00 48D1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @48CD memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @48D1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_48D2: // Incoming jump from 0x48C8, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @48D9 memory[0x40:0x60] // @48DA returndata.length // } 48D2 5B JUMPDEST 48D3 50 POP 48D4 50 POP 48D5 50 POP 48D6 50 POP 48D7 60 PUSH1 0x40 48D9 51 MLOAD 48DA 3D RETURNDATASIZE 48DB 60 PUSH1 0x20 48DD 81 DUP2 48DE 10 LT 48DF 15 ISZERO 48E0 61 PUSH2 0x48e8 48E3 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @48D9 stack[-4] = memory[0x40:0x60] // @48DA stack[-3] = returndata.length // } // Block ends with conditional jump to 0x48e8, if !(returndata.length < 0x20) label_48E4: // Incoming jump from 0x48E3, if not !(returndata.length < 0x20) // Inputs[1] { @48E7 memory[0x00:0x00] } 48E4 60 PUSH1 0x00 48E6 80 DUP1 48E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @48E7 revert(memory[0x00:0x00]); } // Block terminates label_48E8: // Incoming jump from 0x48E3, if !(returndata.length < 0x20) // Inputs[3] // { // @48EA memory[stack[-2]:stack[-2] + 0x20] // @48EA stack[-2] // @48EB stack[-3] // } 48E8 5B JUMPDEST 48E9 50 POP 48EA 51 MLOAD 48EB 90 SWAP1 48EC 50 POP 48ED 80 DUP1 48EE 15 ISZERO 48EF 61 PUSH2 0x492b 48F2 57 *JUMPI // Stack delta = -2 // Outputs[1] { @48EB stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x492b, if !memory[stack[-2]:stack[-2] + 0x20] label_48F3: // Incoming jump from 0x48F2, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @48F6 memory[0x40:0x60] // @4921 memory[0x40:0x60] // @492A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 48F3 60 PUSH1 0x40 48F5 80 DUP1 48F6 51 MLOAD 48F7 60 PUSH1 0x01 48F9 60 PUSH1 0xe5 48FB 1B SHL 48FC 62 PUSH3 0x461bcd 4900 02 MUL 4901 81 DUP2 4902 52 MSTORE 4903 60 PUSH1 0x20 4905 60 PUSH1 0x04 4907 82 DUP3 4908 01 ADD 4909 52 MSTORE 490A 60 PUSH1 0x03 490C 60 PUSH1 0x24 490E 82 DUP3 490F 01 ADD 4910 52 MSTORE 4911 60 PUSH1 0x01 4913 60 PUSH1 0xe8 4915 1B SHL 4916 62 PUSH3 0x453439 491A 02 MUL 491B 60 PUSH1 0x44 491D 82 DUP3 491E 01 ADD 491F 52 MSTORE 4920 90 SWAP1 4921 51 MLOAD 4922 90 SWAP1 4923 81 DUP2 4924 90 SWAP1 4925 03 SUB 4926 60 PUSH1 0x64 4928 01 ADD 4929 90 SWAP1 492A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4902 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4909 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4910 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @491F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453439 * (0x01 << 0xe8) // @492A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_492B: // Incoming jump from 0x48F2, if !memory[stack[-2]:stack[-2] + 0x20] 492B 5B JUMPDEST 492C 61 PUSH2 0x4933 492F 61 PUSH2 0x23f2 4932 56 *JUMP // Stack delta = +1 // Outputs[1] { @492C stack[0] = 0x4933 } // Block ends with call to 0x23f2, returns to 0x4933 label_4933: // Incoming return from call to 0x23F2 at 0x4932 // Inputs[2] // { // @4936 storage[0x08] // @4937 stack[-1] // } 4933 5B JUMPDEST 4934 60 PUSH1 0x08 4936 54 SLOAD 4937 14 EQ 4938 61 PUSH2 0x4973 493B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4973, if storage[0x08] == stack[-1] label_493C: // Incoming jump from 0x493B, if not storage[0x08] == stack[-1] // Inputs[3] // { // @493F memory[0x40:0x60] // @4969 memory[0x40:0x60] // @4972 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 493C 60 PUSH1 0x40 493E 80 DUP1 493F 51 MLOAD 4940 60 PUSH1 0x01 4942 60 PUSH1 0xe5 4944 1B SHL 4945 62 PUSH3 0x461bcd 4949 02 MUL 494A 81 DUP2 494B 52 MSTORE 494C 60 PUSH1 0x20 494E 60 PUSH1 0x04 4950 82 DUP3 4951 01 ADD 4952 52 MSTORE 4953 60 PUSH1 0x02 4955 60 PUSH1 0x24 4957 82 DUP3 4958 01 ADD 4959 52 MSTORE 495A 60 PUSH1 0x01 495C 60 PUSH1 0xf0 495E 1B SHL 495F 61 PUSH2 0x4537 4962 02 MUL 4963 60 PUSH1 0x44 4965 82 DUP3 4966 01 ADD 4967 52 MSTORE 4968 90 SWAP1 4969 51 MLOAD 496A 90 SWAP1 496B 81 DUP2 496C 90 SWAP1 496D 03 SUB 496E 60 PUSH1 0x64 4970 01 ADD 4971 90 SWAP1 4972 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @494B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4952 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4959 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @4967 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4537 * (0x01 << 0xf0) // @4972 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4973: // Incoming jump from 0x493B, if storage[0x08] == stack[-1] 4973 5B JUMPDEST 4974 61 PUSH2 0x497b 4977 61 PUSH2 0x23f2 497A 56 *JUMP // Stack delta = +1 // Outputs[1] { @4974 stack[0] = 0x497b } // Block ends with call to 0x23f2, returns to 0x497B label_497B: // Incoming return from call to 0x23F2 at 0x497A // Inputs[4] // { // @497C stack[-5] // @498D memory[0x40:0x60] // @49A1 memory[0x40:0x60] // @49A8 address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } 497B 5B JUMPDEST 497C 84 DUP5 497D 60 PUSH1 0x01 497F 60 PUSH1 0x01 4981 60 PUSH1 0xa0 4983 1B SHL 4984 03 SUB 4985 16 AND 4986 63 PUSH4 0x6c540baf 498B 60 PUSH1 0x40 498D 51 MLOAD 498E 81 DUP2 498F 63 PUSH4 0xffffffff 4994 16 AND 4995 60 PUSH1 0xe0 4997 1B SHL 4998 81 DUP2 4999 52 MSTORE 499A 60 PUSH1 0x04 499C 01 ADD 499D 60 PUSH1 0x20 499F 60 PUSH1 0x40 49A1 51 MLOAD 49A2 80 DUP1 49A3 83 DUP4 49A4 03 SUB 49A5 81 DUP2 49A6 86 DUP7 49A7 80 DUP1 49A8 3B EXTCODESIZE 49A9 15 ISZERO 49AA 80 DUP1 49AB 15 ISZERO 49AC 61 PUSH2 0x49b4 49AF 57 *JUMPI // Stack delta = +9 // Outputs[10] // { // @4985 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-5] // @4986 stack[1] = 0x6c540baf // @4999 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x6c540baf) << 0xe0 // @499C stack[2] = 0x04 + memory[0x40:0x60] // @499D stack[3] = 0x20 // @49A1 stack[4] = memory[0x40:0x60] // @49A4 stack[5] = (0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @49A5 stack[6] = memory[0x40:0x60] // @49A6 stack[7] = (0x01 << 0xa0) - 0x01 & stack[-5] // @49A9 stack[8] = !address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // } // Block ends with conditional jump to 0x49b4, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length label_49B0: // Incoming jump from 0x49AF, if not !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[1] { @49B3 memory[0x00:0x00] } 49B0 60 PUSH1 0x00 49B2 80 DUP1 49B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @49B3 revert(memory[0x00:0x00]); } // Block terminates label_49B4: // Incoming jump from 0x49AF, if !!address((0x01 << 0xa0) - 0x01 & stack[-5]).code.length // Inputs[8] // { // @49B6 msg.gas // @49B7 stack[-2] // @49B7 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @49B7 stack[-3] // @49B7 stack[-5] // @49B7 stack[-6] // @49B7 memory[stack[-3]:stack[-3] + stack[-4]] // @49B7 stack[-4] // } 49B4 5B JUMPDEST 49B5 50 POP 49B6 5A GAS 49B7 FA STATICCALL 49B8 15 ISZERO 49B9 80 DUP1 49BA 15 ISZERO 49BB 61 PUSH2 0x49c8 49BE 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @49B7 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @49B8 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x49c8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_49BF: // Incoming jump from 0x49BE, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @49BF returndata.length // @49C3 returndata[0x00:0x00 + returndata.length] // @49C4 returndata.length // @49C7 memory[0x00:0x00 + returndata.length] // } 49BF 3D RETURNDATASIZE 49C0 60 PUSH1 0x00 49C2 80 DUP1 49C3 3E RETURNDATACOPY 49C4 3D RETURNDATASIZE 49C5 60 PUSH1 0x00 49C7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @49C3 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @49C7 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_49C8: // Incoming jump from 0x49BE, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @49CF memory[0x40:0x60] // @49D0 returndata.length // } 49C8 5B JUMPDEST 49C9 50 POP 49CA 50 POP 49CB 50 POP 49CC 50 POP 49CD 60 PUSH1 0x40 49CF 51 MLOAD 49D0 3D RETURNDATASIZE 49D1 60 PUSH1 0x20 49D3 81 DUP2 49D4 10 LT 49D5 15 ISZERO 49D6 61 PUSH2 0x49de 49D9 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @49CF stack[-4] = memory[0x40:0x60] // @49D0 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x49de, if !(returndata.length < 0x20) label_49DA: // Incoming jump from 0x49D9, if not !(returndata.length < 0x20) // Inputs[1] { @49DD memory[0x00:0x00] } 49DA 60 PUSH1 0x00 49DC 80 DUP1 49DD FD *REVERT // Stack delta = +0 // Outputs[1] { @49DD revert(memory[0x00:0x00]); } // Block terminates label_49DE: // Incoming jump from 0x49D9, if !(returndata.length < 0x20) // Inputs[3] // { // @49E0 stack[-2] // @49E0 memory[stack[-2]:stack[-2] + 0x20] // @49E1 stack[-3] // } 49DE 5B JUMPDEST 49DF 50 POP 49E0 51 MLOAD 49E1 14 EQ 49E2 61 PUSH2 0x4a1d 49E5 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x4a1d, if memory[stack[-2]:stack[-2] + 0x20] == stack[-3] label_49E6: // Incoming jump from 0x49E5, if not memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[3] // { // @49E9 memory[0x40:0x60] // @4A13 memory[0x40:0x60] // @4A1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 49E6 60 PUSH1 0x40 49E8 80 DUP1 49E9 51 MLOAD 49EA 60 PUSH1 0x01 49EC 60 PUSH1 0xe5 49EE 1B SHL 49EF 62 PUSH3 0x461bcd 49F3 02 MUL 49F4 81 DUP2 49F5 52 MSTORE 49F6 60 PUSH1 0x20 49F8 60 PUSH1 0x04 49FA 82 DUP3 49FB 01 ADD 49FC 52 MSTORE 49FD 60 PUSH1 0x02 49FF 60 PUSH1 0x24 4A01 82 DUP3 4A02 01 ADD 4A03 52 MSTORE 4A04 60 PUSH1 0x01 4A06 60 PUSH1 0xf0 4A08 1B SHL 4A09 61 PUSH2 0x4537 4A0C 02 MUL 4A0D 60 PUSH1 0x44 4A0F 82 DUP3 4A10 01 ADD 4A11 52 MSTORE 4A12 90 SWAP1 4A13 51 MLOAD 4A14 90 SWAP1 4A15 81 DUP2 4A16 90 SWAP1 4A17 03 SUB 4A18 60 PUSH1 0x64 4A1A 01 ADD 4A1B 90 SWAP1 4A1C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @49F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @49FC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4A03 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @4A11 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4537 * (0x01 << 0xf0) // @4A1C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4A1D: // Incoming jump from 0x49E5, if memory[stack[-2]:stack[-2] + 0x20] == stack[-3] // Inputs[2] // { // @4A1E stack[-7] // @4A28 stack[-6] // } 4A1D 5B JUMPDEST 4A1E 86 DUP7 4A1F 60 PUSH1 0x01 4A21 60 PUSH1 0x01 4A23 60 PUSH1 0xa0 4A25 1B SHL 4A26 03 SUB 4A27 16 AND 4A28 86 DUP7 4A29 60 PUSH1 0x01 4A2B 60 PUSH1 0x01 4A2D 60 PUSH1 0xa0 4A2F 1B SHL 4A30 03 SUB 4A31 16 AND 4A32 14 EQ 4A33 15 ISZERO 4A34 61 PUSH2 0x4a70 4A37 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4a70, if !((0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-7]) label_4A38: // Incoming jump from 0x4A37, if not !((0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-7]) // Inputs[3] // { // @4A3B memory[0x40:0x60] // @4A66 memory[0x40:0x60] // @4A6F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4A38 60 PUSH1 0x40 4A3A 80 DUP1 4A3B 51 MLOAD 4A3C 60 PUSH1 0x01 4A3E 60 PUSH1 0xe5 4A40 1B SHL 4A41 62 PUSH3 0x461bcd 4A45 02 MUL 4A46 81 DUP2 4A47 52 MSTORE 4A48 60 PUSH1 0x20 4A4A 60 PUSH1 0x04 4A4C 82 DUP3 4A4D 01 ADD 4A4E 52 MSTORE 4A4F 60 PUSH1 0x03 4A51 60 PUSH1 0x24 4A53 82 DUP3 4A54 01 ADD 4A55 52 MSTORE 4A56 60 PUSH1 0x01 4A58 60 PUSH1 0xec 4A5A 1B SHL 4A5B 62 PUSH3 0x045353 4A5F 02 MUL 4A60 60 PUSH1 0x44 4A62 82 DUP3 4A63 01 ADD 4A64 52 MSTORE 4A65 90 SWAP1 4A66 51 MLOAD 4A67 90 SWAP1 4A68 81 DUP2 4A69 90 SWAP1 4A6A 03 SUB 4A6B 60 PUSH1 0x64 4A6D 01 ADD 4A6E 90 SWAP1 4A6F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4A47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4A4E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4A55 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4A64 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x045353 * (0x01 << 0xec) // @4A6F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4A70: // Incoming jump from 0x4A37, if !((0x01 << 0xa0) - 0x01 & stack[-6] == (0x01 << 0xa0) - 0x01 & stack[-7]) // Inputs[1] { @4A71 stack[-5] } 4A70 5B JUMPDEST 4A71 84 DUP5 4A72 61 PUSH2 0x4aae 4A75 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4aae, if stack[-5] label_4A76: // Incoming jump from 0x4A75, if not stack[-5] // Inputs[3] // { // @4A79 memory[0x40:0x60] // @4AA4 memory[0x40:0x60] // @4AAD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4A76 60 PUSH1 0x40 4A78 80 DUP1 4A79 51 MLOAD 4A7A 60 PUSH1 0x01 4A7C 60 PUSH1 0xe5 4A7E 1B SHL 4A7F 62 PUSH3 0x461bcd 4A83 02 MUL 4A84 81 DUP2 4A85 52 MSTORE 4A86 60 PUSH1 0x20 4A88 60 PUSH1 0x04 4A8A 82 DUP3 4A8B 01 ADD 4A8C 52 MSTORE 4A8D 60 PUSH1 0x03 4A8F 60 PUSH1 0x24 4A91 82 DUP3 4A92 01 ADD 4A93 52 MSTORE 4A94 60 PUSH1 0x01 4A96 60 PUSH1 0xe8 4A98 1B SHL 4A99 62 PUSH3 0x453531 4A9D 02 MUL 4A9E 60 PUSH1 0x44 4AA0 82 DUP3 4AA1 01 ADD 4AA2 52 MSTORE 4AA3 90 SWAP1 4AA4 51 MLOAD 4AA5 90 SWAP1 4AA6 81 DUP2 4AA7 90 SWAP1 4AA8 03 SUB 4AA9 60 PUSH1 0x64 4AAB 01 ADD 4AAC 90 SWAP1 4AAD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4A85 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4A8C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4A93 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4AA2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453531 * (0x01 << 0xe8) // @4AAD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4AAE: // Incoming jump from 0x4A75, if stack[-5] // Inputs[1] { @4AB2 stack[-5] } 4AAE 5B JUMPDEST 4AAF 60 PUSH1 0x00 4AB1 19 NOT 4AB2 85 DUP6 4AB3 14 EQ 4AB4 15 ISZERO 4AB5 61 PUSH2 0x4af1 4AB8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4af1, if !(stack[-5] == ~0x00) label_4AB9: // Incoming jump from 0x4AB8, if not !(stack[-5] == ~0x00) // Inputs[3] // { // @4ABC memory[0x40:0x60] // @4AE7 memory[0x40:0x60] // @4AF0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4AB9 60 PUSH1 0x40 4ABB 80 DUP1 4ABC 51 MLOAD 4ABD 60 PUSH1 0x01 4ABF 60 PUSH1 0xe5 4AC1 1B SHL 4AC2 62 PUSH3 0x461bcd 4AC6 02 MUL 4AC7 81 DUP2 4AC8 52 MSTORE 4AC9 60 PUSH1 0x20 4ACB 60 PUSH1 0x04 4ACD 82 DUP3 4ACE 01 ADD 4ACF 52 MSTORE 4AD0 60 PUSH1 0x03 4AD2 60 PUSH1 0x24 4AD4 82 DUP3 4AD5 01 ADD 4AD6 52 MSTORE 4AD7 60 PUSH1 0x01 4AD9 60 PUSH1 0xe9 4ADB 1B SHL 4ADC 62 PUSH3 0x229a99 4AE0 02 MUL 4AE1 60 PUSH1 0x44 4AE3 82 DUP3 4AE4 01 ADD 4AE5 52 MSTORE 4AE6 90 SWAP1 4AE7 51 MLOAD 4AE8 90 SWAP1 4AE9 81 DUP2 4AEA 90 SWAP1 4AEB 03 SUB 4AEC 60 PUSH1 0x64 4AEE 01 ADD 4AEF 90 SWAP1 4AF0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4AC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4ACF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4AD6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4AE5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229a99 * (0x01 << 0xe9) // @4AF0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4AF1: // Incoming jump from 0x4AB8, if !(stack[-5] == ~0x00) // Inputs[3] // { // @4AF8 stack[-7] // @4AF9 stack[-6] // @4AFA stack[-5] // } 4AF1 5B JUMPDEST 4AF2 60 PUSH1 0x00 4AF4 80 DUP1 4AF5 61 PUSH2 0x4aff 4AF8 89 DUP10 4AF9 89 DUP10 4AFA 89 DUP10 4AFB 61 PUSH2 0x442e 4AFE 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @4AF2 stack[0] = 0x00 // @4AF4 stack[1] = 0x00 // @4AF5 stack[2] = 0x4aff // @4AF8 stack[3] = stack[-7] // @4AF9 stack[4] = stack[-6] // @4AFA stack[5] = stack[-5] // } // Block ends with call to 0x442e, returns to 0x4AFF label_4AFF: // Incoming return from call to 0x442E at 0x4AFE // Inputs[4] // { // @4B00 stack[-1] // @4B00 stack[-2] // @4B01 stack[-4] // @4B03 stack[-3] // } 4AFF 5B JUMPDEST 4B00 90 SWAP1 4B01 92 SWAP3 4B02 50 POP 4B03 90 SWAP1 4B04 50 POP 4B05 81 DUP2 4B06 15 ISZERO 4B07 61 PUSH2 0x4b43 4B0A 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @4B01 stack[-4] = stack[-2] // @4B03 stack[-3] = stack[-1] // } // Block ends with conditional jump to 0x4b43, if !stack[-2] label_4B0B: // Incoming jump from 0x4B0A, if not !stack[-2] // Inputs[3] // { // @4B0E memory[0x40:0x60] // @4B39 memory[0x40:0x60] // @4B42 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4B0B 60 PUSH1 0x40 4B0D 80 DUP1 4B0E 51 MLOAD 4B0F 60 PUSH1 0x01 4B11 60 PUSH1 0xe5 4B13 1B SHL 4B14 62 PUSH3 0x461bcd 4B18 02 MUL 4B19 81 DUP2 4B1A 52 MSTORE 4B1B 60 PUSH1 0x20 4B1D 60 PUSH1 0x04 4B1F 82 DUP3 4B20 01 ADD 4B21 52 MSTORE 4B22 60 PUSH1 0x03 4B24 60 PUSH1 0x24 4B26 82 DUP3 4B27 01 ADD 4B28 52 MSTORE 4B29 60 PUSH1 0x01 4B2B 60 PUSH1 0xe8 4B2D 1B SHL 4B2E 62 PUSH3 0x453533 4B32 02 MUL 4B33 60 PUSH1 0x44 4B35 82 DUP3 4B36 01 ADD 4B37 52 MSTORE 4B38 90 SWAP1 4B39 51 MLOAD 4B3A 90 SWAP1 4B3B 81 DUP2 4B3C 90 SWAP1 4B3D 03 SUB 4B3E 60 PUSH1 0x64 4B40 01 ADD 4B41 90 SWAP1 4B42 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4B1A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4B21 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4B28 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4B37 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453533 * (0x01 << 0xe8) // @4B42 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4B43: // Incoming jump from 0x4B0A, if !stack[-2] // Inputs[7] // { // @4B47 storage[0x00] // @4B4B memory[0x40:0x60] // @4B59 address(this) // @4B67 stack[-6] // @4B73 stack[-1] // @4B77 memory[0x40:0x60] // @4B99 address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } 4B43 5B JUMPDEST 4B44 60 PUSH1 0x00 4B46 80 DUP1 4B47 54 SLOAD 4B48 60 PUSH1 0x40 4B4A 80 DUP1 4B4B 51 MLOAD 4B4C 60 PUSH1 0x01 4B4E 60 PUSH1 0xe0 4B50 1B SHL 4B51 63 PUSH4 0xc488847b 4B56 02 MUL 4B57 81 DUP2 4B58 52 MSTORE 4B59 30 ADDRESS 4B5A 60 PUSH1 0x04 4B5C 82 DUP3 4B5D 01 ADD 4B5E 52 MSTORE 4B5F 60 PUSH1 0x01 4B61 60 PUSH1 0x01 4B63 60 PUSH1 0xa0 4B65 1B SHL 4B66 03 SUB 4B67 8A DUP11 4B68 81 DUP2 4B69 16 AND 4B6A 60 PUSH1 0x24 4B6C 83 DUP4 4B6D 01 ADD 4B6E 52 MSTORE 4B6F 60 PUSH1 0x44 4B71 82 DUP3 4B72 01 ADD 4B73 86 DUP7 4B74 90 SWAP1 4B75 52 MSTORE 4B76 82 DUP3 4B77 51 MLOAD 4B78 85 DUP6 4B79 94 SWAP5 4B7A 63 PUSH4 0x01000000 4B7F 90 SWAP1 4B80 04 DIV 4B81 90 SWAP1 4B82 91 SWAP2 4B83 16 AND 4B84 92 SWAP3 4B85 63 PUSH4 0xc488847b 4B8A 92 SWAP3 4B8B 60 PUSH1 0x64 4B8D 80 DUP1 4B8E 82 DUP3 4B8F 01 ADD 4B90 93 SWAP4 4B91 91 SWAP2 4B92 82 DUP3 4B93 90 SWAP1 4B94 03 SUB 4B95 01 ADD 4B96 81 DUP2 4B97 86 DUP7 4B98 80 DUP1 4B99 3B EXTCODESIZE 4B9A 15 ISZERO 4B9B 80 DUP1 4B9C 15 ISZERO 4B9D 61 PUSH2 0x4ba5 4BA0 57 *JUMPI // Stack delta = +11 // Outputs[15] // { // @4B44 stack[0] = 0x00 // @4B58 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc488847b * (0x01 << 0xe0) // @4B5E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @4B6E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @4B75 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @4B79 stack[1] = 0x00 // @4B84 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @4B84 stack[5] = 0x40 // @4B8A stack[3] = 0xc488847b // @4B90 stack[4] = memory[0x40:0x60] + 0x64 // @4B91 stack[6] = memory[0x40:0x60] // @4B95 stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @4B96 stack[8] = memory[0x40:0x60] // @4B97 stack[9] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @4B9A stack[10] = !address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } // Block ends with conditional jump to 0x4ba5, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length label_4BA1: // Incoming jump from 0x4BA0, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[1] { @4BA4 memory[0x00:0x00] } 4BA1 60 PUSH1 0x00 4BA3 80 DUP1 4BA4 FD *REVERT // Stack delta = +0 // Outputs[1] { @4BA4 revert(memory[0x00:0x00]); } // Block terminates label_4BA5: // Incoming jump from 0x4BA0, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[8] // { // @4BA7 msg.gas // @4BA8 stack[-2] // @4BA8 stack[-3] // @4BA8 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @4BA8 stack[-6] // @4BA8 stack[-4] // @4BA8 stack[-5] // @4BA8 memory[stack[-3]:stack[-3] + stack[-4]] // } 4BA5 5B JUMPDEST 4BA6 50 POP 4BA7 5A GAS 4BA8 FA STATICCALL 4BA9 15 ISZERO 4BAA 80 DUP1 4BAB 15 ISZERO 4BAC 61 PUSH2 0x4bb9 4BAF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @4BA8 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @4BA9 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x4bb9, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_4BB0: // Incoming jump from 0x4BAF, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @4BB0 returndata.length // @4BB4 returndata[0x00:0x00 + returndata.length] // @4BB5 returndata.length // @4BB8 memory[0x00:0x00 + returndata.length] // } 4BB0 3D RETURNDATASIZE 4BB1 60 PUSH1 0x00 4BB3 80 DUP1 4BB4 3E RETURNDATACOPY 4BB5 3D RETURNDATASIZE 4BB6 60 PUSH1 0x00 4BB8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4BB4 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4BB8 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_4BB9: // Incoming jump from 0x4BAF, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @4BC0 memory[0x40:0x60] // @4BC1 returndata.length // } 4BB9 5B JUMPDEST 4BBA 50 POP 4BBB 50 POP 4BBC 50 POP 4BBD 50 POP 4BBE 60 PUSH1 0x40 4BC0 51 MLOAD 4BC1 3D RETURNDATASIZE 4BC2 60 PUSH1 0x40 4BC4 81 DUP2 4BC5 10 LT 4BC6 15 ISZERO 4BC7 61 PUSH2 0x4bcf 4BCA 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @4BC0 stack[-4] = memory[0x40:0x60] // @4BC1 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x4bcf, if !(returndata.length < 0x40) label_4BCB: // Incoming jump from 0x4BCA, if not !(returndata.length < 0x40) // Inputs[1] { @4BCE memory[0x00:0x00] } 4BCB 60 PUSH1 0x00 4BCD 80 DUP1 4BCE FD *REVERT // Stack delta = +0 // Outputs[1] { @4BCE revert(memory[0x00:0x00]); } // Block terminates label_4BCF: // Incoming jump from 0x4BCA, if !(returndata.length < 0x40) // Inputs[5] // { // @4BD1 stack[-2] // @4BD2 memory[stack[-2]:stack[-2] + 0x20] // @4BD8 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @4BDA stack[-4] // @4BDC stack[-3] // } 4BCF 5B JUMPDEST 4BD0 50 POP 4BD1 80 DUP1 4BD2 51 MLOAD 4BD3 60 PUSH1 0x20 4BD5 90 SWAP1 4BD6 91 SWAP2 4BD7 01 ADD 4BD8 51 MLOAD 4BD9 90 SWAP1 4BDA 92 SWAP3 4BDB 50 POP 4BDC 90 SWAP1 4BDD 50 POP 4BDE 81 DUP2 4BDF 15 ISZERO 4BE0 61 PUSH2 0x4c1c 4BE3 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @4BDA stack[-4] = memory[stack[-2]:stack[-2] + 0x20] // @4BDC stack[-3] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x4c1c, if !memory[stack[-2]:stack[-2] + 0x20] label_4BE4: // Incoming jump from 0x4BE3, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @4BE7 memory[0x40:0x60] // @4C12 memory[0x40:0x60] // @4C1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4BE4 60 PUSH1 0x40 4BE6 80 DUP1 4BE7 51 MLOAD 4BE8 60 PUSH1 0x01 4BEA 60 PUSH1 0xe5 4BEC 1B SHL 4BED 62 PUSH3 0x461bcd 4BF1 02 MUL 4BF2 81 DUP2 4BF3 52 MSTORE 4BF4 60 PUSH1 0x20 4BF6 60 PUSH1 0x04 4BF8 82 DUP3 4BF9 01 ADD 4BFA 52 MSTORE 4BFB 60 PUSH1 0x03 4BFD 60 PUSH1 0x24 4BFF 82 DUP3 4C00 01 ADD 4C01 52 MSTORE 4C02 60 PUSH1 0x01 4C04 60 PUSH1 0xea 4C06 1B SHL 4C07 62 PUSH3 0x114d4d 4C0B 02 MUL 4C0C 60 PUSH1 0x44 4C0E 82 DUP3 4C0F 01 ADD 4C10 52 MSTORE 4C11 90 SWAP1 4C12 51 MLOAD 4C13 90 SWAP1 4C14 81 DUP2 4C15 90 SWAP1 4C16 03 SUB 4C17 60 PUSH1 0x64 4C19 01 ADD 4C1A 90 SWAP1 4C1B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4BF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4BFA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4C01 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4C10 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x114d4d * (0x01 << 0xea) // @4C1B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4C1C: // Incoming jump from 0x4BE3, if !memory[stack[-2]:stack[-2] + 0x20] // Inputs[6] // { // @4C1D stack[-1] // @4C1E stack[-8] // @4C2D stack[-10] // @4C30 memory[0x40:0x60] // @4C60 memory[0x40:0x60] // @4C67 address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // } 4C1C 5B JUMPDEST 4C1D 80 DUP1 4C1E 88 DUP9 4C1F 60 PUSH1 0x01 4C21 60 PUSH1 0x01 4C23 60 PUSH1 0xa0 4C25 1B SHL 4C26 03 SUB 4C27 16 AND 4C28 63 PUSH4 0x70a08231 4C2D 8C DUP13 4C2E 60 PUSH1 0x40 4C30 51 MLOAD 4C31 82 DUP3 4C32 63 PUSH4 0xffffffff 4C37 16 AND 4C38 60 PUSH1 0xe0 4C3A 1B SHL 4C3B 81 DUP2 4C3C 52 MSTORE 4C3D 60 PUSH1 0x04 4C3F 01 ADD 4C40 80 DUP1 4C41 82 DUP3 4C42 60 PUSH1 0x01 4C44 60 PUSH1 0x01 4C46 60 PUSH1 0xa0 4C48 1B SHL 4C49 03 SUB 4C4A 16 AND 4C4B 60 PUSH1 0x01 4C4D 60 PUSH1 0x01 4C4F 60 PUSH1 0xa0 4C51 1B SHL 4C52 03 SUB 4C53 16 AND 4C54 81 DUP2 4C55 52 MSTORE 4C56 60 PUSH1 0x20 4C58 01 ADD 4C59 91 SWAP2 4C5A 50 POP 4C5B 50 POP 4C5C 60 PUSH1 0x20 4C5E 60 PUSH1 0x40 4C60 51 MLOAD 4C61 80 DUP1 4C62 83 DUP4 4C63 03 SUB 4C64 81 DUP2 4C65 86 DUP7 4C66 80 DUP1 4C67 3B EXTCODESIZE 4C68 15 ISZERO 4C69 80 DUP1 4C6A 15 ISZERO 4C6B 61 PUSH2 0x4c73 4C6E 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @4C1D stack[0] = stack[-1] // @4C27 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-8] // @4C28 stack[2] = 0x70a08231 // @4C3C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @4C55 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & (0x01 << 0xa0) - 0x01 & stack[-10] // @4C59 stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @4C5C stack[4] = 0x20 // @4C60 stack[5] = memory[0x40:0x60] // @4C63 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @4C64 stack[7] = memory[0x40:0x60] // @4C65 stack[8] = (0x01 << 0xa0) - 0x01 & stack[-8] // @4C68 stack[9] = !address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // } // Block ends with conditional jump to 0x4c73, if !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length label_4C6F: // Incoming jump from 0x4C6E, if not !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // Inputs[1] { @4C72 memory[0x00:0x00] } 4C6F 60 PUSH1 0x00 4C71 80 DUP1 4C72 FD *REVERT // Stack delta = +0 // Outputs[1] { @4C72 revert(memory[0x00:0x00]); } // Block terminates label_4C73: // Incoming jump from 0x4C6E, if !!address((0x01 << 0xa0) - 0x01 & stack[-8]).code.length // Inputs[8] // { // @4C75 msg.gas // @4C76 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @4C76 memory[stack[-3]:stack[-3] + stack[-4]] // @4C76 stack[-5] // @4C76 stack[-2] // @4C76 stack[-4] // @4C76 stack[-6] // @4C76 stack[-3] // } 4C73 5B JUMPDEST 4C74 50 POP 4C75 5A GAS 4C76 FA STATICCALL 4C77 15 ISZERO 4C78 80 DUP1 4C79 15 ISZERO 4C7A 61 PUSH2 0x4c87 4C7D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @4C76 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @4C77 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x4c87, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_4C7E: // Incoming jump from 0x4C7D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @4C7E returndata.length // @4C82 returndata[0x00:0x00 + returndata.length] // @4C83 returndata.length // @4C86 memory[0x00:0x00 + returndata.length] // } 4C7E 3D RETURNDATASIZE 4C7F 60 PUSH1 0x00 4C81 80 DUP1 4C82 3E RETURNDATACOPY 4C83 3D RETURNDATASIZE 4C84 60 PUSH1 0x00 4C86 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4C82 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4C86 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_4C87: // Incoming jump from 0x4C7D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @4C8E memory[0x40:0x60] // @4C8F returndata.length // } 4C87 5B JUMPDEST 4C88 50 POP 4C89 50 POP 4C8A 50 POP 4C8B 50 POP 4C8C 60 PUSH1 0x40 4C8E 51 MLOAD 4C8F 3D RETURNDATASIZE 4C90 60 PUSH1 0x20 4C92 81 DUP2 4C93 10 LT 4C94 15 ISZERO 4C95 61 PUSH2 0x4c9d 4C98 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @4C8E stack[-4] = memory[0x40:0x60] // @4C8F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x4c9d, if !(returndata.length < 0x20) label_4C99: // Incoming jump from 0x4C98, if not !(returndata.length < 0x20) // Inputs[1] { @4C9C memory[0x00:0x00] } 4C99 60 PUSH1 0x00 4C9B 80 DUP1 4C9C FD *REVERT // Stack delta = +0 // Outputs[1] { @4C9C revert(memory[0x00:0x00]); } // Block terminates label_4C9D: // Incoming jump from 0x4C98, if !(returndata.length < 0x20) // Inputs[3] // { // @4C9F stack[-2] // @4C9F memory[stack[-2]:stack[-2] + 0x20] // @4CA0 stack[-3] // } 4C9D 5B JUMPDEST 4C9E 50 POP 4C9F 51 MLOAD 4CA0 10 LT 4CA1 15 ISZERO 4CA2 61 PUSH2 0x4cde 4CA5 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x4cde, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) label_4CA6: // Incoming jump from 0x4CA5, if not !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) // Inputs[3] // { // @4CA9 memory[0x40:0x60] // @4CD4 memory[0x40:0x60] // @4CDD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4CA6 60 PUSH1 0x40 4CA8 80 DUP1 4CA9 51 MLOAD 4CAA 60 PUSH1 0x01 4CAC 60 PUSH1 0xe5 4CAE 1B SHL 4CAF 62 PUSH3 0x461bcd 4CB3 02 MUL 4CB4 81 DUP2 4CB5 52 MSTORE 4CB6 60 PUSH1 0x20 4CB8 60 PUSH1 0x04 4CBA 82 DUP3 4CBB 01 ADD 4CBC 52 MSTORE 4CBD 60 PUSH1 0x03 4CBF 60 PUSH1 0x24 4CC1 82 DUP3 4CC2 01 ADD 4CC3 52 MSTORE 4CC4 60 PUSH1 0x01 4CC6 60 PUSH1 0xe8 4CC8 1B SHL 4CC9 62 PUSH3 0x453535 4CCD 02 MUL 4CCE 60 PUSH1 0x44 4CD0 82 DUP3 4CD1 01 ADD 4CD2 52 MSTORE 4CD3 90 SWAP1 4CD4 51 MLOAD 4CD5 90 SWAP1 4CD6 81 DUP2 4CD7 90 SWAP1 4CD8 03 SUB 4CD9 60 PUSH1 0x64 4CDB 01 ADD 4CDC 90 SWAP1 4CDD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4CB5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4CBC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4CC3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4CD2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453535 * (0x01 << 0xe8) // @4CDD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4CDE: // Incoming jump from 0x4CA5, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) // Inputs[2] // { // @4CE9 stack[-8] // @4CEB address(this) // } 4CDE 5B JUMPDEST 4CDF 60 PUSH1 0x00 4CE1 60 PUSH1 0x01 4CE3 60 PUSH1 0x01 4CE5 60 PUSH1 0xa0 4CE7 1B SHL 4CE8 03 SUB 4CE9 89 DUP10 4CEA 16 AND 4CEB 30 ADDRESS 4CEC 14 EQ 4CED 15 ISZERO 4CEE 61 PUSH2 0x4d04 4CF1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @4CDF stack[0] = 0x00 } // Block ends with conditional jump to 0x4d04, if !(address(this) == stack[-8] & (0x01 << 0xa0) - 0x01) label_4CF2: // Incoming jump from 0x4CF1, if not !(address(this) == stack[-8] & (0x01 << 0xa0) - 0x01) // Inputs[4] // { // @4CF5 address(this) // @4CF6 stack[-12] // @4CF7 stack[-11] // @4CF8 stack[-2] // } 4CF2 61 PUSH2 0x4cfd 4CF5 30 ADDRESS 4CF6 8D DUP14 4CF7 8D DUP14 4CF8 85 DUP6 4CF9 61 PUSH2 0x381c 4CFC 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @4CF2 stack[0] = 0x4cfd // @4CF5 stack[1] = address(this) // @4CF6 stack[2] = stack[-12] // @4CF7 stack[3] = stack[-11] // @4CF8 stack[4] = stack[-2] // } // Block ends with call to 0x381c, returns to 0x4CFD label_4CFD: // Incoming return from call to 0x381C at 0x4CFC // Inputs[2] // { // @4CFE stack[-2] // @4CFE stack[-1] // } 4CFD 5B JUMPDEST 4CFE 90 SWAP1 4CFF 50 POP 4D00 61 PUSH2 0x4d91 4D03 56 *JUMP // Stack delta = -1 // Outputs[1] { @4CFE stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x4d91 label_4D04: // Incoming jump from 0x4CF1, if !(address(this) == stack[-8] & (0x01 << 0xa0) - 0x01) // Inputs[7] // { // @4D08 memory[0x40:0x60] // @4D1E stack[-12] // @4D26 stack[-11] // @4D32 stack[-2] // @4D36 memory[0x40:0x60] // @4D38 stack[-9] // @4D56 address(stack[-9] & (0x01 << 0xa0) - 0x01).code.length // } 4D04 5B JUMPDEST 4D05 60 PUSH1 0x40 4D07 80 DUP1 4D08 51 MLOAD 4D09 60 PUSH1 0x01 4D0B 60 PUSH1 0xe0 4D0D 1B SHL 4D0E 63 PUSH4 0xb2a02ff1 4D13 02 MUL 4D14 81 DUP2 4D15 52 MSTORE 4D16 60 PUSH1 0x01 4D18 60 PUSH1 0x01 4D1A 60 PUSH1 0xa0 4D1C 1B SHL 4D1D 03 SUB 4D1E 8E DUP15 4D1F 81 DUP2 4D20 16 AND 4D21 60 PUSH1 0x04 4D23 83 DUP4 4D24 01 ADD 4D25 52 MSTORE 4D26 8D DUP14 4D27 81 DUP2 4D28 16 AND 4D29 60 PUSH1 0x24 4D2B 83 DUP4 4D2C 01 ADD 4D2D 52 MSTORE 4D2E 60 PUSH1 0x44 4D30 82 DUP3 4D31 01 ADD 4D32 85 DUP6 4D33 90 SWAP1 4D34 52 MSTORE 4D35 91 SWAP2 4D36 51 MLOAD 4D37 91 SWAP2 4D38 8B DUP12 4D39 16 AND 4D3A 91 SWAP2 4D3B 63 PUSH4 0xb2a02ff1 4D40 91 SWAP2 4D41 60 PUSH1 0x64 4D43 80 DUP1 4D44 82 DUP3 4D45 01 ADD 4D46 92 SWAP3 4D47 60 PUSH1 0x20 4D49 92 SWAP3 4D4A 90 SWAP1 4D4B 91 SWAP2 4D4C 90 SWAP1 4D4D 82 DUP3 4D4E 90 SWAP1 4D4F 03 SUB 4D50 01 ADD 4D51 81 DUP2 4D52 60 PUSH1 0x00 4D54 87 DUP8 4D55 80 DUP1 4D56 3B EXTCODESIZE 4D57 15 ISZERO 4D58 80 DUP1 4D59 15 ISZERO 4D5A 61 PUSH2 0x4d62 4D5D 57 *JUMPI // Stack delta = +10 // Outputs[14] // { // @4D15 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb2a02ff1 * (0x01 << 0xe0) // @4D25 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-12] // @4D2D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-11] // @4D34 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-2] // @4D3A stack[0] = stack[-9] & (0x01 << 0xa0) - 0x01 // @4D40 stack[1] = 0xb2a02ff1 // @4D46 stack[2] = memory[0x40:0x60] + 0x64 // @4D49 stack[3] = 0x20 // @4D4B stack[4] = memory[0x40:0x60] // @4D50 stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @4D51 stack[6] = memory[0x40:0x60] // @4D52 stack[7] = 0x00 // @4D54 stack[8] = stack[-9] & (0x01 << 0xa0) - 0x01 // @4D57 stack[9] = !address(stack[-9] & (0x01 << 0xa0) - 0x01).code.length // } // Block ends with conditional jump to 0x4d62, if !!address(stack[-9] & (0x01 << 0xa0) - 0x01).code.length label_4D5E: // Incoming jump from 0x4D5D, if not !!address(stack[-9] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @4D61 memory[0x00:0x00] } 4D5E 60 PUSH1 0x00 4D60 80 DUP1 4D61 FD *REVERT // Stack delta = +0 // Outputs[1] { @4D61 revert(memory[0x00:0x00]); } // Block terminates label_4D62: // Incoming jump from 0x4D5D, if !!address(stack[-9] & (0x01 << 0xa0) - 0x01).code.length // Inputs[9] // { // @4D64 msg.gas // @4D65 stack[-6] // @4D65 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4D65 stack[-5] // @4D65 stack[-3] // @4D65 stack[-2] // @4D65 memory[stack[-4]:stack[-4] + stack[-5]] // @4D65 stack[-4] // @4D65 stack[-7] // } 4D62 5B JUMPDEST 4D63 50 POP 4D64 5A GAS 4D65 F1 CALL 4D66 15 ISZERO 4D67 80 DUP1 4D68 15 ISZERO 4D69 61 PUSH2 0x4d76 4D6C 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @4D65 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4D66 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x4d76, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_4D6D: // Incoming jump from 0x4D6C, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @4D6D returndata.length // @4D71 returndata[0x00:0x00 + returndata.length] // @4D72 returndata.length // @4D75 memory[0x00:0x00 + returndata.length] // } 4D6D 3D RETURNDATASIZE 4D6E 60 PUSH1 0x00 4D70 80 DUP1 4D71 3E RETURNDATACOPY 4D72 3D RETURNDATASIZE 4D73 60 PUSH1 0x00 4D75 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4D71 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4D75 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_4D76: // Incoming jump from 0x4D6C, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @4D7D memory[0x40:0x60] // @4D7E returndata.length // } 4D76 5B JUMPDEST 4D77 50 POP 4D78 50 POP 4D79 50 POP 4D7A 50 POP 4D7B 60 PUSH1 0x40 4D7D 51 MLOAD 4D7E 3D RETURNDATASIZE 4D7F 60 PUSH1 0x20 4D81 81 DUP2 4D82 10 LT 4D83 15 ISZERO 4D84 61 PUSH2 0x4d8c 4D87 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @4D7D stack[-4] = memory[0x40:0x60] // @4D7E stack[-3] = returndata.length // } // Block ends with conditional jump to 0x4d8c, if !(returndata.length < 0x20) label_4D88: // Incoming jump from 0x4D87, if not !(returndata.length < 0x20) // Inputs[1] { @4D8B memory[0x00:0x00] } 4D88 60 PUSH1 0x00 4D8A 80 DUP1 4D8B FD *REVERT // Stack delta = +0 // Outputs[1] { @4D8B revert(memory[0x00:0x00]); } // Block terminates label_4D8C: // Incoming jump from 0x4D87, if !(returndata.length < 0x20) // Inputs[3] // { // @4D8E stack[-2] // @4D8E memory[stack[-2]:stack[-2] + 0x20] // @4D8F stack[-3] // } 4D8C 5B JUMPDEST 4D8D 50 POP 4D8E 51 MLOAD 4D8F 90 SWAP1 4D90 50 POP 4D91 5B JUMPDEST 4D92 80 DUP1 4D93 15 ISZERO 4D94 61 PUSH2 0x4dd0 4D97 57 *JUMPI // Stack delta = -2 // Outputs[1] { @4D8F stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x4dd0, if !memory[stack[-2]:stack[-2] + 0x20] label_4D98: // Incoming jump from 0x4D97, if not !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x4D97, if not !stack[-1] // Inputs[3] // { // @4D9B memory[0x40:0x60] // @4DC6 memory[0x40:0x60] // @4DCF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4D98 60 PUSH1 0x40 4D9A 80 DUP1 4D9B 51 MLOAD 4D9C 60 PUSH1 0x01 4D9E 60 PUSH1 0xe5 4DA0 1B SHL 4DA1 62 PUSH3 0x461bcd 4DA5 02 MUL 4DA6 81 DUP2 4DA7 52 MSTORE 4DA8 60 PUSH1 0x20 4DAA 60 PUSH1 0x04 4DAC 82 DUP3 4DAD 01 ADD 4DAE 52 MSTORE 4DAF 60 PUSH1 0x03 4DB1 60 PUSH1 0x24 4DB3 82 DUP3 4DB4 01 ADD 4DB5 52 MSTORE 4DB6 60 PUSH1 0x01 4DB8 60 PUSH1 0xe9 4DBA 1B SHL 4DBB 62 PUSH3 0x229a9b 4DBF 02 MUL 4DC0 60 PUSH1 0x44 4DC2 82 DUP3 4DC3 01 ADD 4DC4 52 MSTORE 4DC5 90 SWAP1 4DC6 51 MLOAD 4DC7 90 SWAP1 4DC8 81 DUP2 4DC9 90 SWAP1 4DCA 03 SUB 4DCB 60 PUSH1 0x64 4DCD 01 ADD 4DCE 90 SWAP1 4DCF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4DA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4DAE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4DB5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4DC4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229a9b * (0x01 << 0xe9) // @4DCF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4DD0: // Incoming jump from 0x4D97, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x4D97, if !stack[-1] // Inputs[9] // { // @4DD5 memory[0x40:0x60] // @4DDF stack[-12] // @4DE4 stack[-11] // @4DEE stack[-4] // @4DF1 stack[-9] // @4DFC stack[-2] // @4E00 memory[0x40:0x60] // @4E2A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])] // @4E2D stack[-13] // } 4DD0 5B JUMPDEST 4DD1 50 POP 4DD2 60 PUSH1 0x40 4DD4 80 DUP1 4DD5 51 MLOAD 4DD6 60 PUSH1 0x01 4DD8 60 PUSH1 0x01 4DDA 60 PUSH1 0xa0 4DDC 1B SHL 4DDD 03 SUB 4DDE 80 DUP1 4DDF 8E DUP15 4DE0 16 AND 4DE1 82 DUP3 4DE2 52 MSTORE 4DE3 80 DUP1 4DE4 8D DUP14 4DE5 16 AND 4DE6 60 PUSH1 0x20 4DE8 83 DUP4 4DE9 01 ADD 4DEA 52 MSTORE 4DEB 81 DUP2 4DEC 83 DUP4 4DED 01 ADD 4DEE 86 DUP7 4DEF 90 SWAP1 4DF0 52 MSTORE 4DF1 8A DUP11 4DF2 16 AND 4DF3 60 PUSH1 0x60 4DF5 82 DUP3 4DF6 01 ADD 4DF7 52 MSTORE 4DF8 60 PUSH1 0x80 4DFA 81 DUP2 4DFB 01 ADD 4DFC 83 DUP4 4DFD 90 SWAP1 4DFE 52 MSTORE 4DFF 90 SWAP1 4E00 51 MLOAD 4E01 7F PUSH32 0x298637f684da70674f26509b10f07ec2fbc77a335ab1e7d6215a4b2484d8bb52 4E22 91 SWAP2 4E23 81 DUP2 4E24 90 SWAP1 4E25 03 SUB 4E26 60 PUSH1 0xa0 4E28 01 ADD 4E29 90 SWAP1 4E2A A1 LOG1 4E2B 60 PUSH1 0x00 4E2D 9B SWAP12 4E2E 92 SWAP3 4E2F 9A SWAP11 4E30 50 POP 4E31 91 SWAP2 4E32 98 SWAP9 4E33 50 POP 4E34 50 POP 4E35 50 POP 4E36 50 POP 4E37 50 POP 4E38 50 POP 4E39 50 POP 4E3A 50 POP 4E3B 50 POP 4E3C 56 *JUMP // Stack delta = -11 // Outputs[8] // { // @4DE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-12] & (0x01 << 0xa0) - 0x01 // @4DEA memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-11] & (0x01 << 0xa0) - 0x01 // @4DF0 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-4] // @4DF7 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-9] & (0x01 << 0xa0) - 0x01 // @4DFE memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-2] // @4E2A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0xa0 + (memory[0x40:0x60] - memory[0x40:0x60])], [0x298637f684da70674f26509b10f07ec2fbc77a335ab1e7d6215a4b2484d8bb52]); // @4E2D stack[-13] = 0x00 // @4E2F stack[-12] = stack[-4] // } // Block ends with unconditional jump to stack[-13] label_4E3D: // Incoming call from 0x3B3A, returns to 0x1253 // Inputs[7] // { // @4E41 storage[0x00] // @4E45 memory[0x40:0x60] // @4E53 address(this) // @4E61 stack[-2] // @4E6D stack[-1] // @4E71 memory[0x40:0x60] // @4E99 address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } 4E3D 5B JUMPDEST 4E3E 60 PUSH1 0x00 4E40 80 DUP1 4E41 54 SLOAD 4E42 60 PUSH1 0x40 4E44 80 DUP1 4E45 51 MLOAD 4E46 60 PUSH1 0x01 4E48 60 PUSH1 0xe2 4E4A 1B SHL 4E4B 63 PUSH4 0x368f5153 4E50 02 MUL 4E51 81 DUP2 4E52 52 MSTORE 4E53 30 ADDRESS 4E54 60 PUSH1 0x04 4E56 82 DUP3 4E57 01 ADD 4E58 52 MSTORE 4E59 60 PUSH1 0x01 4E5B 60 PUSH1 0x01 4E5D 60 PUSH1 0xa0 4E5F 1B SHL 4E60 03 SUB 4E61 86 DUP7 4E62 81 DUP2 4E63 16 AND 4E64 60 PUSH1 0x24 4E66 83 DUP4 4E67 01 ADD 4E68 52 MSTORE 4E69 60 PUSH1 0x44 4E6B 82 DUP3 4E6C 01 ADD 4E6D 86 DUP7 4E6E 90 SWAP1 4E6F 52 MSTORE 4E70 91 SWAP2 4E71 51 MLOAD 4E72 84 DUP5 4E73 93 SWAP4 4E74 63 PUSH4 0x01000000 4E79 90 SWAP1 4E7A 04 DIV 4E7B 90 SWAP1 4E7C 92 SWAP3 4E7D 16 AND 4E7E 91 SWAP2 4E7F 63 PUSH4 0xda3d454c 4E84 91 SWAP2 4E85 60 PUSH1 0x64 4E87 80 DUP1 4E88 82 DUP3 4E89 01 ADD 4E8A 92 SWAP3 4E8B 60 PUSH1 0x20 4E8D 92 SWAP3 4E8E 90 SWAP1 4E8F 91 SWAP2 4E90 90 SWAP1 4E91 82 DUP3 4E92 90 SWAP1 4E93 03 SUB 4E94 01 ADD 4E95 81 DUP2 4E96 87 DUP8 4E97 87 DUP8 4E98 80 DUP1 4E99 3B EXTCODESIZE 4E9A 15 ISZERO 4E9B 80 DUP1 4E9C 15 ISZERO 4E9D 61 PUSH2 0x4ea5 4EA0 57 *JUMPI // Stack delta = +12 // Outputs[16] // { // @4E3E stack[0] = 0x00 // @4E52 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x368f5153 * (0x01 << 0xe2) // @4E58 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @4E68 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @4E6F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @4E73 stack[1] = 0x00 // @4E7E stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @4E84 stack[3] = 0xda3d454c // @4E8A stack[4] = memory[0x40:0x60] + 0x64 // @4E8D stack[5] = 0x20 // @4E8F stack[6] = memory[0x40:0x60] // @4E94 stack[7] = memory[0x40:0x60] - memory[0x40:0x60] + 0x64 // @4E95 stack[8] = memory[0x40:0x60] // @4E96 stack[9] = 0x00 // @4E97 stack[10] = (0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000 // @4E9A stack[11] = !address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // } // Block ends with conditional jump to 0x4ea5, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length label_4EA1: // Incoming jump from 0x4EA0, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[1] { @4EA4 memory[0x00:0x00] } 4EA1 60 PUSH1 0x00 4EA3 80 DUP1 4EA4 FD *REVERT // Stack delta = +0 // Outputs[1] { @4EA4 revert(memory[0x00:0x00]); } // Block terminates label_4EA5: // Incoming jump from 0x4EA0, if !!address((0x01 << 0xa0) - 0x01 & storage[0x00] / 0x01000000).code.length // Inputs[9] // { // @4EA7 msg.gas // @4EA8 stack[-5] // @4EA8 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4EA8 stack[-4] // @4EA8 stack[-6] // @4EA8 memory[stack[-4]:stack[-4] + stack[-5]] // @4EA8 stack[-2] // @4EA8 stack[-7] // @4EA8 stack[-3] // } 4EA5 5B JUMPDEST 4EA6 50 POP 4EA7 5A GAS 4EA8 F1 CALL 4EA9 15 ISZERO 4EAA 80 DUP1 4EAB 15 ISZERO 4EAC 61 PUSH2 0x4eb9 4EAF 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @4EA8 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @4EA9 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x4eb9, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_4EB0: // Incoming jump from 0x4EAF, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @4EB0 returndata.length // @4EB4 returndata[0x00:0x00 + returndata.length] // @4EB5 returndata.length // @4EB8 memory[0x00:0x00 + returndata.length] // } 4EB0 3D RETURNDATASIZE 4EB1 60 PUSH1 0x00 4EB3 80 DUP1 4EB4 3E RETURNDATACOPY 4EB5 3D RETURNDATASIZE 4EB6 60 PUSH1 0x00 4EB8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @4EB4 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @4EB8 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_4EB9: // Incoming jump from 0x4EAF, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @4EC0 memory[0x40:0x60] // @4EC1 returndata.length // } 4EB9 5B JUMPDEST 4EBA 50 POP 4EBB 50 POP 4EBC 50 POP 4EBD 50 POP 4EBE 60 PUSH1 0x40 4EC0 51 MLOAD 4EC1 3D RETURNDATASIZE 4EC2 60 PUSH1 0x20 4EC4 81 DUP2 4EC5 10 LT 4EC6 15 ISZERO 4EC7 61 PUSH2 0x4ecf 4ECA 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @4EC0 stack[-4] = memory[0x40:0x60] // @4EC1 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x4ecf, if !(returndata.length < 0x20) label_4ECB: // Incoming jump from 0x4ECA, if not !(returndata.length < 0x20) // Inputs[1] { @4ECE memory[0x00:0x00] } 4ECB 60 PUSH1 0x00 4ECD 80 DUP1 4ECE FD *REVERT // Stack delta = +0 // Outputs[1] { @4ECE revert(memory[0x00:0x00]); } // Block terminates label_4ECF: // Incoming jump from 0x4ECA, if !(returndata.length < 0x20) // Inputs[3] // { // @4ED1 memory[stack[-2]:stack[-2] + 0x20] // @4ED1 stack[-2] // @4ED2 stack[-3] // } 4ECF 5B JUMPDEST 4ED0 50 POP 4ED1 51 MLOAD 4ED2 90 SWAP1 4ED3 50 POP 4ED4 80 DUP1 4ED5 15 ISZERO 4ED6 61 PUSH2 0x4f12 4ED9 57 *JUMPI // Stack delta = -2 // Outputs[1] { @4ED2 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x4f12, if !memory[stack[-2]:stack[-2] + 0x20] label_4EDA: // Incoming jump from 0x4ED9, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @4EDD memory[0x40:0x60] // @4F08 memory[0x40:0x60] // @4F11 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4EDA 60 PUSH1 0x40 4EDC 80 DUP1 4EDD 51 MLOAD 4EDE 60 PUSH1 0x01 4EE0 60 PUSH1 0xe5 4EE2 1B SHL 4EE3 62 PUSH3 0x461bcd 4EE7 02 MUL 4EE8 81 DUP2 4EE9 52 MSTORE 4EEA 60 PUSH1 0x20 4EEC 60 PUSH1 0x04 4EEE 82 DUP3 4EEF 01 ADD 4EF0 52 MSTORE 4EF1 60 PUSH1 0x03 4EF3 60 PUSH1 0x24 4EF5 82 DUP3 4EF6 01 ADD 4EF7 52 MSTORE 4EF8 60 PUSH1 0x01 4EFA 60 PUSH1 0xe8 4EFC 1B SHL 4EFD 62 PUSH3 0x453231 4F01 02 MUL 4F02 60 PUSH1 0x44 4F04 82 DUP3 4F05 01 ADD 4F06 52 MSTORE 4F07 90 SWAP1 4F08 51 MLOAD 4F09 90 SWAP1 4F0A 81 DUP2 4F0B 90 SWAP1 4F0C 03 SUB 4F0D 60 PUSH1 0x64 4F0F 01 ADD 4F10 90 SWAP1 4F11 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4EE9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4EF0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4EF7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4F06 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453231 * (0x01 << 0xe8) // @4F11 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4F12: // Incoming jump from 0x4ED9, if !memory[stack[-2]:stack[-2] + 0x20] 4F12 5B JUMPDEST 4F13 61 PUSH2 0x4f1a 4F16 61 PUSH2 0x23f2 4F19 56 *JUMP // Stack delta = +1 // Outputs[1] { @4F13 stack[0] = 0x4f1a } // Block ends with call to 0x23f2, returns to 0x4F1A label_4F1A: // Incoming return from call to 0x23F2 at 0x4F19 // Inputs[2] // { // @4F1D storage[0x08] // @4F1E stack[-1] // } 4F1A 5B JUMPDEST 4F1B 60 PUSH1 0x08 4F1D 54 SLOAD 4F1E 14 EQ 4F1F 61 PUSH2 0x4f5b 4F22 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x4f5b, if storage[0x08] == stack[-1] label_4F23: // Incoming jump from 0x4F22, if not storage[0x08] == stack[-1] // Inputs[3] // { // @4F26 memory[0x40:0x60] // @4F51 memory[0x40:0x60] // @4F5A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4F23 60 PUSH1 0x40 4F25 80 DUP1 4F26 51 MLOAD 4F27 60 PUSH1 0x01 4F29 60 PUSH1 0xe5 4F2B 1B SHL 4F2C 62 PUSH3 0x461bcd 4F30 02 MUL 4F31 81 DUP2 4F32 52 MSTORE 4F33 60 PUSH1 0x20 4F35 60 PUSH1 0x04 4F37 82 DUP3 4F38 01 ADD 4F39 52 MSTORE 4F3A 60 PUSH1 0x03 4F3C 60 PUSH1 0x24 4F3E 82 DUP3 4F3F 01 ADD 4F40 52 MSTORE 4F41 60 PUSH1 0x01 4F43 60 PUSH1 0xe9 4F45 1B SHL 4F46 62 PUSH3 0x229919 4F4A 02 MUL 4F4B 60 PUSH1 0x44 4F4D 82 DUP3 4F4E 01 ADD 4F4F 52 MSTORE 4F50 90 SWAP1 4F51 51 MLOAD 4F52 90 SWAP1 4F53 81 DUP2 4F54 90 SWAP1 4F55 03 SUB 4F56 60 PUSH1 0x64 4F58 01 ADD 4F59 90 SWAP1 4F5A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4F32 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4F39 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4F40 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4F4F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229919 * (0x01 << 0xe9) // @4F5A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4F5B: // Incoming jump from 0x4F22, if storage[0x08] == stack[-1] // Inputs[1] { @4F5C stack[-3] } 4F5B 5B JUMPDEST 4F5C 82 DUP3 4F5D 61 PUSH2 0x4f64 4F60 61 PUSH2 0x306e 4F63 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @4F5C stack[0] = stack[-3] // @4F5D stack[1] = 0x4f64 // } // Block ends with call to 0x306e, returns to 0x4F64 label_4F64: // Incoming return from call to 0x306E at 0x4F63 // Inputs[2] // { // @4F65 stack[-1] // @4F65 stack[-2] // } 4F64 5B JUMPDEST 4F65 10 LT 4F66 15 ISZERO 4F67 61 PUSH2 0x4fa3 4F6A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x4fa3, if !(stack[-1] < stack[-2]) label_4F6B: // Incoming jump from 0x4F6A, if not !(stack[-1] < stack[-2]) // Inputs[3] // { // @4F6E memory[0x40:0x60] // @4F99 memory[0x40:0x60] // @4FA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4F6B 60 PUSH1 0x40 4F6D 80 DUP1 4F6E 51 MLOAD 4F6F 60 PUSH1 0x01 4F71 60 PUSH1 0xe5 4F73 1B SHL 4F74 62 PUSH3 0x461bcd 4F78 02 MUL 4F79 81 DUP2 4F7A 52 MSTORE 4F7B 60 PUSH1 0x20 4F7D 60 PUSH1 0x04 4F7F 82 DUP3 4F80 01 ADD 4F81 52 MSTORE 4F82 60 PUSH1 0x03 4F84 60 PUSH1 0x24 4F86 82 DUP3 4F87 01 ADD 4F88 52 MSTORE 4F89 60 PUSH1 0x01 4F8B 60 PUSH1 0xe8 4F8D 1B SHL 4F8E 62 PUSH3 0x453233 4F92 02 MUL 4F93 60 PUSH1 0x44 4F95 82 DUP3 4F96 01 ADD 4F97 52 MSTORE 4F98 90 SWAP1 4F99 51 MLOAD 4F9A 90 SWAP1 4F9B 81 DUP2 4F9C 90 SWAP1 4F9D 03 SUB 4F9E 60 PUSH1 0x64 4FA0 01 ADD 4FA1 90 SWAP1 4FA2 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4F7A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @4F81 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @4F88 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @4F97 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453233 * (0x01 << 0xe8) // @4FA2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_4FA3: // Incoming jump from 0x4F6A, if !(stack[-1] < stack[-2]) 4FA3 5B JUMPDEST 4FA4 61 PUSH2 0x4fab 4FA7 61 PUSH2 0x5451 4FAA 56 *JUMP // Stack delta = +1 // Outputs[1] { @4FA4 stack[0] = 0x4fab } // Block ends with call to 0x5451, returns to 0x4FAB label_4FAB: // Incoming return from call to 0x5451 at 0x4FAA // Inputs[1] { @4FAF stack[-5] } 4FAB 5B JUMPDEST 4FAC 61 PUSH2 0x4fb4 4FAF 85 DUP6 4FB0 61 PUSH2 0x330c 4FB3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @4FAC stack[0] = 0x4fb4 // @4FAF stack[1] = stack[-5] // } // Block ends with call to 0x330c, returns to 0x4FB4 label_4FB4: // Incoming return from call to 0x330C at 0x4FB3 // Inputs[3] // { // @4FB7 stack[-3] // @4FB9 stack[-1] // @4FBD stack[-2] // } 4FB4 5B JUMPDEST 4FB5 60 PUSH1 0x20 4FB7 83 DUP4 4FB8 01 ADD 4FB9 81 DUP2 4FBA 90 SWAP1 4FBB 52 MSTORE 4FBC 82 DUP3 4FBD 82 DUP3 4FBE 60 PUSH1 0x03 4FC0 81 DUP2 4FC1 11 GT 4FC2 15 ISZERO 4FC3 61 PUSH2 0x4fc8 4FC6 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @4FBB memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = stack[-1] // @4FBC stack[0] = stack[-3] // @4FBD stack[1] = stack[-2] // } // Block ends with conditional jump to 0x4fc8, if !(stack[-2] > 0x03) label_4FC7: // Incoming jump from 0x4FC6, if not !(stack[-2] > 0x03) 4FC7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4FC7 assert(); } // Block terminates label_4FC8: // Incoming jump from 0x4FC6, if !(stack[-2] > 0x03) // Inputs[1] { @4FCB stack[-1] } 4FC8 5B JUMPDEST 4FC9 60 PUSH1 0x03 4FCB 81 DUP2 4FCC 11 GT 4FCD 15 ISZERO 4FCE 61 PUSH2 0x4fd3 4FD1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x4fd3, if !(stack[-1] > 0x03) label_4FD2: // Incoming jump from 0x4FD1, if not !(stack[-1] > 0x03) 4FD2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4FD2 assert(); } // Block terminates label_4FD3: // Incoming jump from 0x4FD1, if !(stack[-1] > 0x03) // Inputs[5] // { // @4FD4 stack[-1] // @4FD4 stack[-2] // @4FD9 stack[-4] // @4FDB stack[-5] // @4FDC memory[stack[-5]:stack[-5] + 0x20] // } 4FD3 5B JUMPDEST 4FD4 90 SWAP1 4FD5 52 MSTORE 4FD6 50 POP 4FD7 60 PUSH1 0x00 4FD9 90 SWAP1 4FDA 50 POP 4FDB 81 DUP2 4FDC 51 MLOAD 4FDD 60 PUSH1 0x03 4FDF 81 DUP2 4FE0 11 GT 4FE1 15 ISZERO 4FE2 61 PUSH2 0x4fe7 4FE5 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @4FD5 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @4FD9 stack[-4] = 0x00 // @4FDC stack[-3] = memory[stack[-5]:stack[-5] + 0x20] // } // Block ends with conditional jump to 0x4fe7, if !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) label_4FE6: // Incoming jump from 0x4FE5, if not !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) 4FE6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @4FE6 assert(); } // Block terminates label_4FE7: // Incoming jump from 0x4FE5, if !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @4FE8 stack[-2] // @4FE8 stack[-1] // } 4FE7 5B JUMPDEST 4FE8 14 EQ 4FE9 61 PUSH2 0x5025 4FEC 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x5025, if stack[-1] == stack[-2] label_4FED: // Incoming jump from 0x4FEC, if not stack[-1] == stack[-2] // Inputs[3] // { // @4FF0 memory[0x40:0x60] // @501B memory[0x40:0x60] // @5024 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 4FED 60 PUSH1 0x40 4FEF 80 DUP1 4FF0 51 MLOAD 4FF1 60 PUSH1 0x01 4FF3 60 PUSH1 0xe5 4FF5 1B SHL 4FF6 62 PUSH3 0x461bcd 4FFA 02 MUL 4FFB 81 DUP2 4FFC 52 MSTORE 4FFD 60 PUSH1 0x20 4FFF 60 PUSH1 0x04 5001 82 DUP3 5002 01 ADD 5003 52 MSTORE 5004 60 PUSH1 0x03 5006 60 PUSH1 0x24 5008 82 DUP3 5009 01 ADD 500A 52 MSTORE 500B 60 PUSH1 0x01 500D 60 PUSH1 0xea 500F 1B SHL 5010 62 PUSH3 0x114c8d 5014 02 MUL 5015 60 PUSH1 0x44 5017 82 DUP3 5018 01 ADD 5019 52 MSTORE 501A 90 SWAP1 501B 51 MLOAD 501C 90 SWAP1 501D 81 DUP2 501E 90 SWAP1 501F 03 SUB 5020 60 PUSH1 0x64 5022 01 ADD 5023 90 SWAP1 5024 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @4FFC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @5003 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @500A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @5019 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x114c8d * (0x01 << 0xea) // @5024 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_5025: // Incoming jump from 0x4FEC, if stack[-1] == stack[-2] // Inputs[3] // { // @5029 stack[-1] // @502D memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @502E stack[-4] // } 5025 5B JUMPDEST 5026 61 PUSH2 0x5033 5029 81 DUP2 502A 60 PUSH1 0x20 502C 01 ADD 502D 51 MLOAD 502E 85 DUP6 502F 61 PUSH2 0x2586 5032 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @5026 stack[0] = 0x5033 // @502D stack[1] = memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @502E stack[2] = stack[-4] // } // Block ends with call to 0x2586, returns to 0x5033 label_5033: // Incoming return from call to 0x2586 at 0x5032 // Inputs[3] // { // @5036 stack[-3] // @5038 stack[-1] // @503C stack[-2] // } 5033 5B JUMPDEST 5034 60 PUSH1 0x40 5036 83 DUP4 5037 01 ADD 5038 81 DUP2 5039 90 SWAP1 503A 52 MSTORE 503B 82 DUP3 503C 82 DUP3 503D 60 PUSH1 0x03 503F 81 DUP2 5040 11 GT 5041 15 ISZERO 5042 61 PUSH2 0x5047 5045 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @503A memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] = stack[-1] // @503B stack[0] = stack[-3] // @503C stack[1] = stack[-2] // } // Block ends with conditional jump to 0x5047, if !(stack[-2] > 0x03) label_5046: // Incoming jump from 0x5045, if not !(stack[-2] > 0x03) 5046 FE *ASSERT // Stack delta = +0 // Outputs[1] { @5046 assert(); } // Block terminates label_5047: // Incoming jump from 0x5045, if !(stack[-2] > 0x03) // Inputs[1] { @504A stack[-1] } 5047 5B JUMPDEST 5048 60 PUSH1 0x03 504A 81 DUP2 504B 11 GT 504C 15 ISZERO 504D 61 PUSH2 0x5052 5050 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x5052, if !(stack[-1] > 0x03) label_5051: // Incoming jump from 0x5050, if not !(stack[-1] > 0x03) 5051 FE *ASSERT // Stack delta = +0 // Outputs[1] { @5051 assert(); } // Block terminates label_5052: // Incoming jump from 0x5050, if !(stack[-1] > 0x03) // Inputs[5] // { // @5053 stack[-1] // @5053 stack[-2] // @5058 stack[-4] // @505A stack[-5] // @505B memory[stack[-5]:stack[-5] + 0x20] // } 5052 5B JUMPDEST 5053 90 SWAP1 5054 52 MSTORE 5055 50 POP 5056 60 PUSH1 0x00 5058 90 SWAP1 5059 50 POP 505A 81 DUP2 505B 51 MLOAD 505C 60 PUSH1 0x03 505E 81 DUP2 505F 11 GT 5060 15 ISZERO 5061 61 PUSH2 0x5066 5064 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @5054 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @5058 stack[-4] = 0x00 // @505B stack[-3] = memory[stack[-5]:stack[-5] + 0x20] // } // Block ends with conditional jump to 0x5066, if !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) label_5065: // Incoming jump from 0x5064, if not !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) 5065 FE *ASSERT // Stack delta = +0 // Outputs[1] { @5065 assert(); } // Block terminates label_5066: // Incoming jump from 0x5064, if !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @5067 stack[-2] // @5067 stack[-1] // } 5066 5B JUMPDEST 5067 14 EQ 5068 61 PUSH2 0x50a4 506B 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x50a4, if stack[-1] == stack[-2] label_506C: // Incoming jump from 0x506B, if not stack[-1] == stack[-2] // Inputs[3] // { // @506F memory[0x40:0x60] // @509A memory[0x40:0x60] // @50A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 506C 60 PUSH1 0x40 506E 80 DUP1 506F 51 MLOAD 5070 60 PUSH1 0x01 5072 60 PUSH1 0xe5 5074 1B SHL 5075 62 PUSH3 0x461bcd 5079 02 MUL 507A 81 DUP2 507B 52 MSTORE 507C 60 PUSH1 0x20 507E 60 PUSH1 0x04 5080 82 DUP3 5081 01 ADD 5082 52 MSTORE 5083 60 PUSH1 0x03 5085 60 PUSH1 0x24 5087 82 DUP3 5088 01 ADD 5089 52 MSTORE 508A 60 PUSH1 0x01 508C 60 PUSH1 0xe8 508E 1B SHL 508F 62 PUSH3 0x453235 5093 02 MUL 5094 60 PUSH1 0x44 5096 82 DUP3 5097 01 ADD 5098 52 MSTORE 5099 90 SWAP1 509A 51 MLOAD 509B 90 SWAP1 509C 81 DUP2 509D 90 SWAP1 509E 03 SUB 509F 60 PUSH1 0x64 50A1 01 ADD 50A2 90 SWAP1 50A3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @507B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @5082 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @5089 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @5098 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453235 * (0x01 << 0xe8) // @50A3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_50A4: // Incoming jump from 0x506B, if stack[-1] == stack[-2] // Inputs[2] // { // @50AA storage[0x06] // @50AB stack[-4] // } 50A4 5B JUMPDEST 50A5 61 PUSH2 0x50b0 50A8 60 PUSH1 0x06 50AA 54 SLOAD 50AB 85 DUP6 50AC 61 PUSH2 0x2586 50AF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @50A5 stack[0] = 0x50b0 // @50AA stack[1] = storage[0x06] // @50AB stack[2] = stack[-4] // } // Block ends with call to 0x2586, returns to 0x50B0 label_50B0: // Incoming return from call to 0x2586 at 0x50AF // Inputs[3] // { // @50B3 stack[-3] // @50B5 stack[-1] // @50B9 stack[-2] // } 50B0 5B JUMPDEST 50B1 60 PUSH1 0x60 50B3 83 DUP4 50B4 01 ADD 50B5 81 DUP2 50B6 90 SWAP1 50B7 52 MSTORE 50B8 82 DUP3 50B9 82 DUP3 50BA 60 PUSH1 0x03 50BC 81 DUP2 50BD 11 GT 50BE 15 ISZERO 50BF 61 PUSH2 0x50c4 50C2 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @50B7 memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] = stack[-1] // @50B8 stack[0] = stack[-3] // @50B9 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x50c4, if !(stack[-2] > 0x03) label_50C3: // Incoming jump from 0x50C2, if not !(stack[-2] > 0x03) 50C3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @50C3 assert(); } // Block terminates label_50C4: // Incoming jump from 0x50C2, if !(stack[-2] > 0x03) // Inputs[1] { @50C7 stack[-1] } 50C4 5B JUMPDEST 50C5 60 PUSH1 0x03 50C7 81 DUP2 50C8 11 GT 50C9 15 ISZERO 50CA 61 PUSH2 0x50cf 50CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x50cf, if !(stack[-1] > 0x03) label_50CE: // Incoming jump from 0x50CD, if not !(stack[-1] > 0x03) 50CE FE *ASSERT // Stack delta = +0 // Outputs[1] { @50CE assert(); } // Block terminates label_50CF: // Incoming jump from 0x50CD, if !(stack[-1] > 0x03) // Inputs[5] // { // @50D0 stack[-1] // @50D0 stack[-2] // @50D5 stack[-4] // @50D7 stack[-5] // @50D8 memory[stack[-5]:stack[-5] + 0x20] // } 50CF 5B JUMPDEST 50D0 90 SWAP1 50D1 52 MSTORE 50D2 50 POP 50D3 60 PUSH1 0x00 50D5 90 SWAP1 50D6 50 POP 50D7 81 DUP2 50D8 51 MLOAD 50D9 60 PUSH1 0x03 50DB 81 DUP2 50DC 11 GT 50DD 15 ISZERO 50DE 61 PUSH2 0x50e3 50E1 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @50D1 memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @50D5 stack[-4] = 0x00 // @50D8 stack[-3] = memory[stack[-5]:stack[-5] + 0x20] // } // Block ends with conditional jump to 0x50e3, if !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) label_50E2: // Incoming jump from 0x50E1, if not !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) 50E2 FE *ASSERT // Stack delta = +0 // Outputs[1] { @50E2 assert(); } // Block terminates label_50E3: // Incoming jump from 0x50E1, if !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @50E4 stack[-1] // @50E4 stack[-2] // } 50E3 5B JUMPDEST 50E4 14 EQ 50E5 61 PUSH2 0x5121 50E8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x5121, if stack[-1] == stack[-2] label_50E9: // Incoming jump from 0x50E8, if not stack[-1] == stack[-2] // Inputs[3] // { // @50EC memory[0x40:0x60] // @5117 memory[0x40:0x60] // @5120 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 50E9 60 PUSH1 0x40 50EB 80 DUP1 50EC 51 MLOAD 50ED 60 PUSH1 0x01 50EF 60 PUSH1 0xe5 50F1 1B SHL 50F2 62 PUSH3 0x461bcd 50F6 02 MUL 50F7 81 DUP2 50F8 52 MSTORE 50F9 60 PUSH1 0x20 50FB 60 PUSH1 0x04 50FD 82 DUP3 50FE 01 ADD 50FF 52 MSTORE 5100 60 PUSH1 0x03 5102 60 PUSH1 0x24 5104 82 DUP3 5105 01 ADD 5106 52 MSTORE 5107 60 PUSH1 0x01 5109 60 PUSH1 0xe9 510B 1B SHL 510C 62 PUSH3 0x22991b 5110 02 MUL 5111 60 PUSH1 0x44 5113 82 DUP3 5114 01 ADD 5115 52 MSTORE 5116 90 SWAP1 5117 51 MLOAD 5118 90 SWAP1 5119 81 DUP2 511A 90 SWAP1 511B 03 SUB 511C 60 PUSH1 0x64 511E 01 ADD 511F 90 SWAP1 5120 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @50F8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @50FF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @5106 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @5115 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x22991b * (0x01 << 0xe9) // @5120 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_5121: // Incoming jump from 0x50E8, if stack[-1] == stack[-2] // Inputs[2] // { // @5125 stack[-5] // @5126 stack[-4] // } 5121 5B JUMPDEST 5122 61 PUSH2 0x512b 5125 85 DUP6 5126 85 DUP6 5127 61 PUSH2 0x43ee 512A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @5122 stack[0] = 0x512b // @5125 stack[1] = stack[-5] // @5126 stack[2] = stack[-4] // } // Block ends with call to 0x43ee, returns to 0x512B label_512B: // Incoming return from call to 0x43EE at 0x512A // Inputs[10] // { // @512E stack[-2] // @5130 stack[-1] // @5138 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @5141 stack[-6] // @5151 memory[0x00:0x40] // @5157 storage[0x09] // @5165 memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @516E memory[0x00:0x40] // @516F storage[keccak256(memory[0x00:0x40])] // @5171 memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // } 512B 5B JUMPDEST 512C 60 PUSH1 0x80 512E 82 DUP3 512F 01 ADD 5130 90 SWAP1 5131 81 DUP2 5132 52 MSTORE 5133 60 PUSH1 0x40 5135 80 DUP1 5136 83 DUP4 5137 01 ADD 5138 51 MLOAD 5139 60 PUSH1 0x01 513B 60 PUSH1 0x01 513D 60 PUSH1 0xa0 513F 1B SHL 5140 03 SUB 5141 88 DUP9 5142 16 AND 5143 60 PUSH1 0x00 5145 90 SWAP1 5146 81 DUP2 5147 52 MSTORE 5148 60 PUSH1 0x11 514A 60 PUSH1 0x20 514C 90 SWAP1 514D 81 DUP2 514E 52 MSTORE 514F 83 DUP4 5150 82 DUP3 5151 20 SHA3 5152 92 SWAP3 5153 83 DUP4 5154 55 SSTORE 5155 60 PUSH1 0x09 5157 54 SLOAD 5158 60 PUSH1 0x01 515A 90 SWAP1 515B 93 SWAP4 515C 01 ADD 515D 92 SWAP3 515E 90 SWAP1 515F 92 SWAP3 5160 55 SSTORE 5161 60 PUSH1 0x60 5163 85 DUP6 5164 01 ADD 5165 51 MLOAD 5166 60 PUSH1 0x06 5168 55 SSTORE 5169 60 PUSH1 0x10 516B 90 SWAP1 516C 91 SWAP2 516D 52 MSTORE 516E 20 SHA3 516F 54 SLOAD 5170 90 SWAP1 5171 51 MLOAD 5172 61 PUSH2 0x517b 5175 91 SWAP2 5176 90 SWAP1 5177 61 PUSH2 0x2586 517A 56 *JUMP // Stack delta = +2 // Outputs[10] // { // @5132 memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] = stack[-1] // @5147 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @514E memory[0x20:0x40] = 0x11 // @5154 storage[keccak256(memory[0x00:0x40])] = memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @5160 storage[keccak256(memory[0x00:0x40]) + 0x01] = storage[0x09] // @5168 storage[0x06] = memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @516D memory[0x20:0x40] = 0x10 // @5175 stack[-1] = 0x517b // @5176 stack[1] = memory[stack[-2] + 0x80:stack[-2] + 0x80 + 0x20] // @5176 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2586, returns to 0x517B label_517B: // Incoming return from call to 0x2586 at 0x517A // Inputs[3] // { // @517E stack[-3] // @5180 stack[-1] // @5184 stack[-2] // } 517B 5B JUMPDEST 517C 60 PUSH1 0xa0 517E 83 DUP4 517F 01 ADD 5180 81 DUP2 5181 90 SWAP1 5182 52 MSTORE 5183 82 DUP3 5184 82 DUP3 5185 60 PUSH1 0x03 5187 81 DUP2 5188 11 GT 5189 15 ISZERO 518A 61 PUSH2 0x518f 518D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @5182 memory[stack[-3] + 0xa0:stack[-3] + 0xa0 + 0x20] = stack[-1] // @5183 stack[0] = stack[-3] // @5184 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x518f, if !(stack[-2] > 0x03) label_518E: // Incoming jump from 0x518D, if not !(stack[-2] > 0x03) 518E FE *ASSERT // Stack delta = +0 // Outputs[1] { @518E assert(); } // Block terminates label_518F: // Incoming jump from 0x518D, if !(stack[-2] > 0x03) // Inputs[1] { @5192 stack[-1] } 518F 5B JUMPDEST 5190 60 PUSH1 0x03 5192 81 DUP2 5193 11 GT 5194 15 ISZERO 5195 61 PUSH2 0x519a 5198 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x519a, if !(stack[-1] > 0x03) label_5199: // Incoming jump from 0x5198, if not !(stack[-1] > 0x03) 5199 FE *ASSERT // Stack delta = +0 // Outputs[1] { @5199 assert(); } // Block terminates label_519A: // Incoming jump from 0x5198, if !(stack[-1] > 0x03) // Inputs[5] // { // @519B stack[-1] // @519B stack[-2] // @51A0 stack[-4] // @51A2 stack[-5] // @51A3 memory[stack[-5]:stack[-5] + 0x20] // } 519A 5B JUMPDEST 519B 90 SWAP1 519C 52 MSTORE 519D 50 POP 519E 60 PUSH1 0x00 51A0 90 SWAP1 51A1 50 POP 51A2 81 DUP2 51A3 51 MLOAD 51A4 60 PUSH1 0x03 51A6 81 DUP2 51A7 11 GT 51A8 15 ISZERO 51A9 61 PUSH2 0x51ae 51AC 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @519C memory[stack[-2]:stack[-2] + 0x20] = stack[-1] // @51A0 stack[-4] = 0x00 // @51A3 stack[-3] = memory[stack[-5]:stack[-5] + 0x20] // } // Block ends with conditional jump to 0x51ae, if !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) label_51AD: // Incoming jump from 0x51AC, if not !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) 51AD FE *ASSERT // Stack delta = +0 // Outputs[1] { @51AD assert(); } // Block terminates label_51AE: // Incoming jump from 0x51AC, if !(memory[stack[-5]:stack[-5] + 0x20] > 0x03) // Inputs[2] // { // @51AF stack[-1] // @51AF stack[-2] // } 51AE 5B JUMPDEST 51AF 14 EQ 51B0 61 PUSH2 0x51ec 51B3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x51ec, if stack[-1] == stack[-2] label_51B4: // Incoming jump from 0x51B3, if not stack[-1] == stack[-2] // Inputs[3] // { // @51B7 memory[0x40:0x60] // @51E2 memory[0x40:0x60] // @51EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 51B4 60 PUSH1 0x40 51B6 80 DUP1 51B7 51 MLOAD 51B8 60 PUSH1 0x01 51BA 60 PUSH1 0xe5 51BC 1B SHL 51BD 62 PUSH3 0x461bcd 51C1 02 MUL 51C2 81 DUP2 51C3 52 MSTORE 51C4 60 PUSH1 0x20 51C6 60 PUSH1 0x04 51C8 82 DUP3 51C9 01 ADD 51CA 52 MSTORE 51CB 60 PUSH1 0x03 51CD 60 PUSH1 0x24 51CF 82 DUP3 51D0 01 ADD 51D1 52 MSTORE 51D2 60 PUSH1 0x01 51D4 60 PUSH1 0xe8 51D6 1B SHL 51D7 62 PUSH3 0x453237 51DB 02 MUL 51DC 60 PUSH1 0x44 51DE 82 DUP3 51DF 01 ADD 51E0 52 MSTORE 51E1 90 SWAP1 51E2 51 MLOAD 51E3 90 SWAP1 51E4 81 DUP2 51E5 90 SWAP1 51E6 03 SUB 51E7 60 PUSH1 0x64 51E9 01 ADD 51EA 90 SWAP1 51EB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @51C3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @51CA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @51D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @51E0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x453237 * (0x01 << 0xe8) // @51EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_51EC: // Incoming jump from 0x51B3, if stack[-1] == stack[-2] // Inputs[5] // { // @51EF stack[-1] // @51F1 memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @51FA stack[-5] // @5209 memory[0x00:0x40] // @520E stack[-6] // } 51EC 5B JUMPDEST 51ED 60 PUSH1 0xa0 51EF 81 DUP2 51F0 01 ADD 51F1 51 MLOAD 51F2 60 PUSH1 0x01 51F4 60 PUSH1 0x01 51F6 60 PUSH1 0xa0 51F8 1B SHL 51F9 03 SUB 51FA 86 DUP7 51FB 16 AND 51FC 60 PUSH1 0x00 51FE 90 SWAP1 51FF 81 DUP2 5200 52 MSTORE 5201 60 PUSH1 0x10 5203 60 PUSH1 0x20 5205 52 MSTORE 5206 60 PUSH1 0x40 5208 81 DUP2 5209 20 SHA3 520A 91 SWAP2 520B 90 SWAP1 520C 91 SWAP2 520D 55 SSTORE 520E 95 SWAP6 520F 94 SWAP5 5210 50 POP 5211 50 POP 5212 50 POP 5213 50 POP 5214 50 POP 5215 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @5200 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @5205 memory[0x20:0x40] = 0x10 // @520D storage[keccak256(memory[0x00:0x40])] = memory[stack[-1] + 0xa0:stack[-1] + 0xa0 + 0x20] // @520E stack[-6] = 0x00 // } // Block ends with unconditional jump to stack[-6] label_5216: // Incoming call from 0x3B45, returns to 0x3B46 // Inputs[3] // { // @5217 stack[-1] // @5217 address(stack[-1]).code.length // @521A stack[-2] // } 5216 5B JUMPDEST 5217 3B EXTCODESIZE 5218 15 ISZERO 5219 15 ISZERO 521A 90 SWAP1 521B 56 *JUMP // Stack delta = -1 // Outputs[1] { @521A stack[-2] = !!address(stack[-1]).code.length } // Block ends with unconditional jump to stack[-2] label_521C: // Incoming call from 0x41AB, returns to 0x41AC 521C 5B JUMPDEST 521D 60 PUSH1 0x00 521F 80 DUP1 5220 60 PUSH1 0x00 5222 80 DUP1 5223 61 PUSH2 0x522a 5226 61 PUSH2 0x23f2 5229 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @521D stack[0] = 0x00 // @521F stack[1] = 0x00 // @5220 stack[2] = 0x00 // @5222 stack[3] = 0x00 // @5223 stack[4] = 0x522a // } // Block ends with call to 0x23f2, returns to 0x522A label_522A: // Incoming return from call to 0x23F2 at 0x5229 // Inputs[2] // { // @522D storage[0x08] // @522E stack[-1] // } 522A 5B JUMPDEST 522B 60 PUSH1 0x08 522D 54 SLOAD 522E 14 EQ 522F 61 PUSH2 0x526a 5232 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x526a, if storage[0x08] == stack[-1] label_5233: // Incoming jump from 0x5232, if not storage[0x08] == stack[-1] // Inputs[3] // { // @5236 memory[0x40:0x60] // @5260 memory[0x40:0x60] // @5269 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 5233 60 PUSH1 0x40 5235 80 DUP1 5236 51 MLOAD 5237 60 PUSH1 0x01 5239 60 PUSH1 0xe5 523B 1B SHL 523C 62 PUSH3 0x461bcd 5240 02 MUL 5241 81 DUP2 5242 52 MSTORE 5243 60 PUSH1 0x20 5245 60 PUSH1 0x04 5247 82 DUP3 5248 01 ADD 5249 52 MSTORE 524A 60 PUSH1 0x02 524C 60 PUSH1 0x24 524E 82 DUP3 524F 01 ADD 5250 52 MSTORE 5251 60 PUSH1 0x01 5253 60 PUSH1 0xf0 5255 1B SHL 5256 61 PUSH2 0x4537 5259 02 MUL 525A 60 PUSH1 0x44 525C 82 DUP3 525D 01 ADD 525E 52 MSTORE 525F 90 SWAP1 5260 51 MLOAD 5261 90 SWAP1 5262 81 DUP2 5263 90 SWAP1 5264 03 SUB 5265 60 PUSH1 0x64 5267 01 ADD 5268 90 SWAP1 5269 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @5242 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @5249 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @5250 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @525E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4537 * (0x01 << 0xf0) // @5269 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_526A: // Incoming jump from 0x5232, if storage[0x08] == stack[-1] // Inputs[2] // { // @526E msg.sender // @526F stack[-5] // } 526A 5B JUMPDEST 526B 61 PUSH2 0x5274 526E 33 CALLER 526F 86 DUP7 5270 61 PUSH2 0x24a1 5273 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @526B stack[0] = 0x5274 // @526E stack[1] = msg.sender // @526F stack[2] = stack[-5] // } // Block ends with call to 0x24a1, returns to 0x5274 label_5274: // Incoming return from call to 0x24A1 at 0x5273 // Inputs[5] // { // @5275 stack[-1] // @5275 stack[-2] // @527A storage[0x0a] // @527C stack[-3] // @5280 storage[0x0a] // } 5274 5B JUMPDEST 5275 90 SWAP1 5276 50 POP 5277 80 DUP1 5278 60 PUSH1 0x0a 527A 54 SLOAD 527B 01 ADD 527C 91 SWAP2 527D 50 POP 527E 60 PUSH1 0x0a 5280 54 SLOAD 5281 82 DUP3 5282 10 LT 5283 15 ISZERO 5284 61 PUSH2 0x52c0 5287 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @5275 stack[-2] = stack[-1] // @527C stack[-3] = storage[0x0a] + stack[-1] // } // Block ends with conditional jump to 0x52c0, if !(storage[0x0a] + stack[-1] < storage[0x0a]) label_5288: // Incoming jump from 0x5287, if not !(storage[0x0a] + stack[-1] < storage[0x0a]) // Inputs[3] // { // @528B memory[0x40:0x60] // @52B6 memory[0x40:0x60] // @52BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 5288 60 PUSH1 0x40 528A 80 DUP1 528B 51 MLOAD 528C 60 PUSH1 0x01 528E 60 PUSH1 0xe5 5290 1B SHL 5291 62 PUSH3 0x461bcd 5295 02 MUL 5296 81 DUP2 5297 52 MSTORE 5298 60 PUSH1 0x20 529A 60 PUSH1 0x04 529C 82 DUP3 529D 01 ADD 529E 52 MSTORE 529F 60 PUSH1 0x03 52A1 60 PUSH1 0x24 52A3 82 DUP3 52A4 01 ADD 52A5 52 MSTORE 52A6 60 PUSH1 0x01 52A8 60 PUSH1 0xe9 52AA 1B SHL 52AB 62 PUSH3 0x229a1b 52AF 02 MUL 52B0 60 PUSH1 0x44 52B2 82 DUP3 52B3 01 ADD 52B4 52 MSTORE 52B5 90 SWAP1 52B6 51 MLOAD 52B7 90 SWAP1 52B8 81 DUP2 52B9 90 SWAP1 52BA 03 SUB 52BB 60 PUSH1 0x64 52BD 01 ADD 52BE 90 SWAP1 52BF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @5297 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd * (0x01 << 0xe5) // @529E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @52A5 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @52B4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x229a1b * (0x01 << 0xe9) // @52BF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_52C0: // Incoming jump from 0x5287, if !(storage[0x0a] + stack[-1] < storage[0x0a]) // Inputs[10] // { // @52C3 stack[-2] // @52C9 memory[0x40:0x60] // @52CA msg.sender // @52D1 stack[-1] // @52DB memory[0x40:0x60] // @5305 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])] // @5308 stack[-4] // @530A stack[-3] // @530D stack[-5] // @530F stack[-6] // } 52C0 5B JUMPDEST 52C1 60 PUSH1 0x0a 52C3 82 DUP3 52C4 90 SWAP1 52C5 55 SSTORE 52C6 60 PUSH1 0x40 52C8 80 DUP1 52C9 51 MLOAD 52CA 33 CALLER 52CB 81 DUP2 52CC 52 MSTORE 52CD 60 PUSH1 0x20 52CF 81 DUP2 52D0 01 ADD 52D1 83 DUP4 52D2 90 SWAP1 52D3 52 MSTORE 52D4 80 DUP1 52D5 82 DUP3 52D6 01 ADD 52D7 84 DUP5 52D8 90 SWAP1 52D9 52 MSTORE 52DA 90 SWAP1 52DB 51 MLOAD 52DC 7F PUSH32 0xa91e67c5ea634cd43a12c5a482724b03de01e85ca68702a53d0c2f45cb7c1dc5 52FD 91 SWAP2 52FE 81 DUP2 52FF 90 SWAP1 5300 03 SUB 5301 60 PUSH1 0x60 5303 01 ADD 5304 90 SWAP1 5305 A1 LOG1 5306 60 PUSH1 0x00 5308 93 SWAP4 5309 50 POP 530A 91 SWAP2 530B 50 POP 530C 50 POP 530D 91 SWAP2 530E 50 POP 530F 91 SWAP2 5310 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @52C5 storage[0x0a] = stack[-2] // @52CC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.sender // @52D3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @52D9 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-2] // @5305 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x60 + (memory[0x40:0x60] - memory[0x40:0x60])], [0xa91e67c5ea634cd43a12c5a482724b03de01e85ca68702a53d0c2f45cb7c1dc5]); // @530D stack[-5] = stack[-1] // @530F stack[-6] = 0x00 // } // Block ends with unconditional jump to stack[-6] label_5311: // Incoming call from 0x454C, returns to 0x454D // Incoming call from 0x0CD0, returns to 0x0CD1 // Inputs[2] // { // @5315 memory[0x40:0x60] // @5355 stack[-1] // } 5311 5B JUMPDEST 5312 60 PUSH1 0x40 5314 80 DUP1 5315 51 MLOAD 5316 61 PUSH2 0x0100 5319 81 DUP2 531A 01 ADD 531B 90 SWAP1 531C 91 SWAP2 531D 52 MSTORE 531E 80 DUP1 531F 60 PUSH1 0x00 5321 81 DUP2 5322 52 MSTORE 5323 60 PUSH1 0x20 5325 01 ADD 5326 60 PUSH1 0x00 5328 81 DUP2 5329 52 MSTORE 532A 60 PUSH1 0x20 532C 01 ADD 532D 60 PUSH1 0x00 532F 81 DUP2 5330 52 MSTORE 5331 60 PUSH1 0x20 5333 01 ADD 5334 60 PUSH1 0x00 5336 81 DUP2 5337 52 MSTORE 5338 60 PUSH1 0x20 533A 01 ADD 533B 60 PUSH1 0x00 533D 81 DUP2 533E 52 MSTORE 533F 60 PUSH1 0x20 5341 01 ADD 5342 60 PUSH1 0x00 5344 81 DUP2 5345 52 MSTORE 5346 60 PUSH1 0x20 5348 01 ADD 5349 60 PUSH1 0x00 534B 81 DUP2 534C 52 MSTORE 534D 60 PUSH1 0x20 534F 01 ADD 5350 60 PUSH1 0x00 5352 81 DUP2 5353 52 MSTORE 5354 50 POP 5355 90 SWAP1 5356 56 *JUMP // Stack delta = +0 // Outputs[10] // { // @531D memory[0x40:0x60] = memory[0x40:0x60] + 0x0100 // @5322 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @5329 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5330 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5337 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @533E memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5345 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @534C memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5353 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5355 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_5357: // Incoming call from 0x3063, returns to 0x3064 // Incoming call from 0x253E, returns to 0x253F // Incoming call from 0x1BB1, returns to 0x1BB2 // Incoming call from 0x420D, returns to 0x420E // Incoming call from 0x33EC, returns to 0x33ED // Incoming call from 0x14CF, returns to 0x14D0 // Incoming call from 0x2426, returns to 0x2427 // Incoming call from 0x3457, returns to 0x3458 // Incoming call from 0x42BD, returns to 0x42BE // Inputs[2] // { // @535A memory[0x40:0x60] // @5368 stack[-1] // } 5357 5B JUMPDEST 5358 60 PUSH1 0x40 535A 51 MLOAD 535B 80 DUP1 535C 60 PUSH1 0x20 535E 01 ADD 535F 60 PUSH1 0x40 5361 52 MSTORE 5362 80 DUP1 5363 60 PUSH1 0x00 5365 81 DUP2 5366 52 MSTORE 5367 50 POP 5368 90 SWAP1 5369 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @5361 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @5366 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @5368 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_536A: // Incoming call from 0x2958, returns to 0x2959 // Inputs[2] // { // @536E memory[0x40:0x60] // @53D1 stack[-1] // } 536A 5B JUMPDEST 536B 60 PUSH1 0x40 536D 80 DUP1 536E 51 MLOAD 536F 61 PUSH2 0x01a0 5372 81 DUP2 5373 01 ADD 5374 90 SWAP1 5375 91 SWAP2 5376 52 MSTORE 5377 80 DUP1 5378 60 PUSH1 0x00 537A 81 DUP2 537B 52 MSTORE 537C 60 PUSH1 0x20 537E 01 ADD 537F 60 PUSH1 0x00 5381 81 DUP2 5382 52 MSTORE 5383 60 PUSH1 0x20 5385 01 ADD 5386 60 PUSH1 0x00 5388 81 DUP2 5389 52 MSTORE 538A 60 PUSH1 0x20 538C 01 ADD 538D 60 PUSH1 0x00 538F 81 DUP2 5390 52 MSTORE 5391 60 PUSH1 0x20 5393 01 ADD 5394 60 PUSH1 0x00 5396 81 DUP2 5397 52 MSTORE 5398 60 PUSH1 0x20 539A 01 ADD 539B 60 PUSH1 0x00 539D 81 DUP2 539E 52 MSTORE 539F 60 PUSH1 0x20 53A1 01 ADD 53A2 60 PUSH1 0x00 53A4 81 DUP2 53A5 52 MSTORE 53A6 60 PUSH1 0x20 53A8 01 ADD 53A9 60 PUSH1 0x00 53AB 81 DUP2 53AC 52 MSTORE 53AD 60 PUSH1 0x20 53AF 01 ADD 53B0 60 PUSH1 0x00 53B2 81 DUP2 53B3 52 MSTORE 53B4 60 PUSH1 0x20 53B6 01 ADD 53B7 60 PUSH1 0x00 53B9 81 DUP2 53BA 52 MSTORE 53BB 60 PUSH1 0x20 53BD 01 ADD 53BE 60 PUSH1 0x00 53C0 81 DUP2 53C1 52 MSTORE 53C2 60 PUSH1 0x20 53C4 01 ADD 53C5 60 PUSH1 0x00 53C7 81 DUP2 53C8 52 MSTORE 53C9 60 PUSH1 0x20 53CB 01 ADD 53CC 60 PUSH1 0x00 53CE 81 DUP2 53CF 52 MSTORE 53D0 50 POP 53D1 90 SWAP1 53D2 56 *JUMP // Stack delta = +0 // Outputs[15] // { // @5376 memory[0x40:0x60] = memory[0x40:0x60] + 0x01a0 // @537B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @5382 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5389 memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5390 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5397 memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @539E memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @53A5 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @53AC memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @53B3 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @53BA memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @53C1 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @53C8 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @53CF memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @53D1 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_53D3: // Incoming jump from 0x3D51 // Inputs[5] // { // @53D4 stack[-3] // @53D6 storage[stack[-3]] // @53F0 memory[0x00:0x20] // @53FB stack[-2] // @53FC stack[-1] // } 53D3 5B JUMPDEST 53D4 82 DUP3 53D5 80 DUP1 53D6 54 SLOAD 53D7 60 PUSH1 0x01 53D9 81 DUP2 53DA 60 PUSH1 0x01 53DC 16 AND 53DD 15 ISZERO 53DE 61 PUSH2 0x0100 53E1 02 MUL 53E2 03 SUB 53E3 16 AND 53E4 60 PUSH1 0x02 53E6 90 SWAP1 53E7 04 DIV 53E8 90 SWAP1 53E9 60 PUSH1 0x00 53EB 52 MSTORE 53EC 60 PUSH1 0x20 53EE 60 PUSH1 0x00 53F0 20 SHA3 53F1 90 SWAP1 53F2 60 PUSH1 0x1f 53F4 01 ADD 53F5 60 PUSH1 0x20 53F7 90 SWAP1 53F8 04 DIV 53F9 81 DUP2 53FA 01 ADD 53FB 92 SWAP3 53FC 82 DUP3 53FD 60 PUSH1 0x1f 53FF 10 LT 5400 61 PUSH2 0x5414 5403 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @53EB memory[0x00:0x20] = stack[-3] // @53F1 stack[0] = keccak256(memory[0x00:0x20]) // @53FB stack[1] = stack[-2] // @53FB stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x5414, if 0x1f < stack[-1] label_5404: // Incoming jump from 0x5403, if not 0x1f < stack[-1] // Inputs[4] // { // @5404 stack[-1] // @5405 memory[stack[-1]:stack[-1] + 0x20] // @540A stack[-3] // @540E stack[-5] // } 5404 80 DUP1 5405 51 MLOAD 5406 60 PUSH1 0xff 5408 19 NOT 5409 16 AND 540A 83 DUP4 540B 80 DUP1 540C 01 ADD 540D 17 OR 540E 85 DUP6 540F 55 SSTORE 5410 61 PUSH2 0x5441 5413 56 *JUMP // Stack delta = +0 // Outputs[1] { @540F storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x5441 label_5414: // Incoming jump from 0x5403, if 0x1f < stack[-1] // Inputs[2] // { // @5415 stack[-3] // @541B stack[-5] // } 5414 5B JUMPDEST 5415 82 DUP3 5416 80 DUP1 5417 01 ADD 5418 60 PUSH1 0x01 541A 01 ADD 541B 85 DUP6 541C 55 SSTORE 541D 82 DUP3 541E 15 ISZERO 541F 61 PUSH2 0x5441 5422 57 *JUMPI // Stack delta = +0 // Outputs[1] { @541C storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x5441, if !stack[-3] label_5423: // Incoming jump from 0x5422, if not !stack[-3] // Inputs[2] // { // @5423 stack[-1] // @5423 stack[-3] // } 5423 91 SWAP2 5424 82 DUP3 5425 01 ADD 5426 5B JUMPDEST 5427 82 DUP3 5428 81 DUP2 5429 11 GT 542A 15 ISZERO 542B 61 PUSH2 0x5441 542E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @5423 stack[-3] = stack[-1] // @5425 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x5441, if !(stack[-1] + stack[-3] > stack[-1]) label_542F: // Incoming jump from 0x542E, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x542E, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @542F stack[-3] // @5430 memory[stack[-3]:stack[-3] + 0x20] // @5431 stack[-2] // @5433 stack[-1] // } 542F 82 DUP3 5430 51 MLOAD 5431 82 DUP3 5432 55 SSTORE 5433 91 SWAP2 5434 60 PUSH1 0x20 5436 01 ADD 5437 91 SWAP2 5438 90 SWAP1 5439 60 PUSH1 0x01 543B 01 ADD 543C 90 SWAP1 543D 61 PUSH2 0x5426 5440 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @5432 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @5437 stack[-3] = 0x20 + stack[-3] // @543C stack[-2] = 0x01 + stack[-2] // @543C stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x5426 label_5441: // Incoming jump from 0x5413 // Incoming jump from 0x542E, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x5422, if !stack[-3] // Incoming jump from 0x542E, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @5446 stack[-4] // @5447 stack[-3] // } 5441 5B JUMPDEST 5442 50 POP 5443 61 PUSH2 0x544d 5446 92 SWAP3 5447 91 SWAP2 5448 50 POP 5449 61 PUSH2 0x5488 544C 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @5446 stack[-4] = 0x544d // @5447 stack[-3] = stack[-4] // } // Block ends with unconditional jump to 0x5488 label_544D: // Incoming call from 0x5496, returns to 0x11A6, if !(stack[-2] > stack[-1]) // Incoming jump from 0x5496, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @544F stack[-2] // @544F stack[-3] // } 544D 5B JUMPDEST 544E 50 POP 544F 90 SWAP1 5450 56 *JUMP // Stack delta = -2 // Outputs[1] { @544F stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_5451: // Incoming call from 0x4FAA, returns to 0x4FAB // Inputs[2] // { // @5455 memory[0x40:0x60] // @5486 stack[-1] // } 5451 5B JUMPDEST 5452 60 PUSH1 0x40 5454 80 DUP1 5455 51 MLOAD 5456 60 PUSH1 0xc0 5458 81 DUP2 5459 01 ADD 545A 90 SWAP1 545B 91 SWAP2 545C 52 MSTORE 545D 80 DUP1 545E 60 PUSH1 0x00 5460 81 DUP2 5461 52 MSTORE 5462 60 PUSH1 0x20 5464 01 ADD 5465 60 PUSH1 0x00 5467 81 DUP2 5468 52 MSTORE 5469 60 PUSH1 0x20 546B 01 ADD 546C 60 PUSH1 0x00 546E 81 DUP2 546F 52 MSTORE 5470 60 PUSH1 0x20 5472 01 ADD 5473 60 PUSH1 0x00 5475 81 DUP2 5476 52 MSTORE 5477 60 PUSH1 0x20 5479 01 ADD 547A 60 PUSH1 0x00 547C 81 DUP2 547D 52 MSTORE 547E 60 PUSH1 0x20 5480 01 ADD 5481 60 PUSH1 0x00 5483 81 DUP2 5484 52 MSTORE 5485 50 POP 5486 90 SWAP1 5487 56 *JUMP // Stack delta = +0 // Outputs[8] // { // @545C memory[0x40:0x60] = memory[0x40:0x60] + 0xc0 // @5461 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @5468 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @546F memory[0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5476 memory[0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @547D memory[0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5484 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x20 + memory[0x40:0x60] + 0x20] = 0x00 // @5486 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_5488: // Incoming jump from 0x544C // Inputs[2] // { // @548C stack[-2] // @548D stack[-1] // } 5488 5B JUMPDEST 5489 61 PUSH2 0x11a6 548C 91 SWAP2 548D 90 SWAP1 548E 5B JUMPDEST 548F 80 DUP1 5490 82 DUP3 5491 11 GT 5492 15 ISZERO 5493 61 PUSH2 0x544d 5496 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @548C stack[-2] = 0x11a6 // @548D stack[-1] = stack[-2] // @548D stack[0] = stack[-1] // } // Block ends with conditional call to 0x544d, returns to 0x11A6, if !(stack[-2] > stack[-1]) label_5497: // Incoming jump from 0x5496, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x5496, if not !(stack[-2] > stack[-1]) // Inputs[1] { @5499 stack[-1] } 5497 60 PUSH1 0x00 5499 81 DUP2 549A 55 SSTORE 549B 60 PUSH1 0x01 549D 01 ADD 549E 61 PUSH2 0x548e 54A1 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @549A storage[stack[-1]] = 0x00 // @549D stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x548e 54A2 FE *ASSERT 54A3 49 49 54A4 6E PUSH15 0x697469616c697a61626c653a20636f 54B4 6E PUSH15 0x747261637420697320616c72656164 54C4 79 PUSH26 0x20696e697469616c697a6564ddf252ad1be2c89b69c2b068fc37 54DF 8D DUP14 54E0 AA AA 54E1 95 SWAP6 54E2 2B 2B 54E3 A7 A7 54E4 F1 CALL 54E5 63 PUSH4 0xc4a11628 54EA F5 CREATE2 54EB 5A GAS 54EC 4D 4D 54ED F5 CREATE2 54EE 23 23 54EF B3 B3 54F0 EF EF 54F1 A1 LOG1 54F2 65 PUSH6 0x627a7a723058 54F9 20 SHA3 54FA 7F PUSH32 0xb545cf31985d54cc67e3bc1ff632ef2c1b86e62c8e72bf1a91a28ba7422d0800 551B 29 29