Online Solidity Decompiler

label_0000: // Incoming return from call to 0x2305 at 0x2304 // 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 0x028c 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x028c, 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 0x715018a6 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 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb88d4fde 0024 11 GT 0025 61 PUSH2 0x00c1 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00c1, if 0xb88d4fde > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xdc53fd92 002F 11 GT 0030 61 PUSH2 0x007a 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007a, if 0xdc53fd92 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xdc53fd92 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xdc53fd92 003A 14 EQ 003B 61 PUSH2 0x076c 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x076c, if 0xdc53fd92 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xdc53fd92 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xdca17145 0045 14 EQ 0046 61 PUSH2 0x0787 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0787, if 0xdca17145 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xdca17145 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x07a2 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a2, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x07c2 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07c2, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf8dc92c6 0066 14 EQ 0067 61 PUSH2 0x07e2 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e2, if 0xf8dc92c6 == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf8dc92c6 == stack[-1] // Inputs[1] { @006B stack[-1] } 006B 80 DUP1 006C 63 PUSH4 0xf968adbe 0071 14 EQ 0072 61 PUSH2 0x07fd 0075 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07fd, if 0xf968adbe == stack[-1] label_0076: // Incoming jump from 0x0075, if not 0xf968adbe == stack[-1] // Inputs[1] { @0079 memory[0x00:0x00] } 0076 60 PUSH1 0x00 0078 80 DUP1 0079 FD *REVERT // Stack delta = +0 // Outputs[1] { @0079 revert(memory[0x00:0x00]); } // Block terminates label_007A: // Incoming jump from 0x0033, if 0xdc53fd92 > stack[-1] // Inputs[1] { @007B stack[-1] } 007A 5B JUMPDEST 007B 80 DUP1 007C 63 PUSH4 0xb88d4fde 0081 14 EQ 0082 61 PUSH2 0x06b6 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b6, if 0xb88d4fde == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xbfa457bc 008C 14 EQ 008D 61 PUSH2 0x06d6 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06d6, if 0xbfa457bc == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xbfa457bc == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xc87b56dd 0097 14 EQ 0098 61 PUSH2 0x06f6 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06f6, if 0xc87b56dd == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xc87b56dd == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xcd7c0326 00A2 14 EQ 00A3 61 PUSH2 0x0716 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0716, if 0xcd7c0326 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xcd7c0326 == stack[-1] // Inputs[1] { @00A7 stack[-1] } 00A7 80 DUP1 00A8 63 PUSH4 0xd0ebdbe7 00AD 14 EQ 00AE 61 PUSH2 0x0736 00B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0736, if 0xd0ebdbe7 == stack[-1] label_00B2: // Incoming jump from 0x00B1, if not 0xd0ebdbe7 == stack[-1] // Inputs[1] { @00B2 stack[-1] } 00B2 80 DUP1 00B3 63 PUSH4 0xd5abeb01 00B8 14 EQ 00B9 61 PUSH2 0x0756 00BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0756, if 0xd5abeb01 == stack[-1] label_00BD: // Incoming jump from 0x00BC, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @00C0 memory[0x00:0x00] } 00BD 60 PUSH1 0x00 00BF 80 DUP1 00C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @00C0 revert(memory[0x00:0x00]); } // Block terminates label_00C1: // Incoming jump from 0x0028, if 0xb88d4fde > stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C1 5B JUMPDEST 00C2 80 DUP1 00C3 63 PUSH4 0x95d89b41 00C8 11 GT 00C9 61 PUSH2 0x0113 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0113, if 0x95d89b41 > stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x95d89b41 > stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x95d89b41 00D3 14 EQ 00D4 61 PUSH2 0x0622 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0622, if 0x95d89b41 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0x962ef00d 00DE 14 EQ 00DF 61 PUSH2 0x0637 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0637, if 0x962ef00d == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0x962ef00d == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0x9abc8320 00E9 14 EQ 00EA 61 PUSH2 0x064c 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x064c, if 0x9abc8320 == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0x9abc8320 == stack[-1] // Inputs[1] { @00EE stack[-1] } 00EE 80 DUP1 00EF 63 PUSH4 0xa10866ef 00F4 14 EQ 00F5 61 PUSH2 0x0661 00F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0661, if 0xa10866ef == stack[-1] label_00F9: // Incoming jump from 0x00F8, if not 0xa10866ef == stack[-1] // Inputs[1] { @00F9 stack[-1] } 00F9 80 DUP1 00FA 63 PUSH4 0xa22cb465 00FF 14 EQ 0100 61 PUSH2 0x0676 0103 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0676, if 0xa22cb465 == stack[-1] label_0104: // Incoming jump from 0x0103, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0104 stack[-1] } 0104 80 DUP1 0105 63 PUSH4 0xadfdeef9 010A 14 EQ 010B 61 PUSH2 0x0696 010E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0696, if 0xadfdeef9 == stack[-1] label_010F: // Incoming jump from 0x010E, if not 0xadfdeef9 == stack[-1] // Inputs[1] { @0112 memory[0x00:0x00] } 010F 60 PUSH1 0x00 0111 80 DUP1 0112 FD *REVERT // Stack delta = +0 // Outputs[1] { @0112 revert(memory[0x00:0x00]); } // Block terminates label_0113: // Incoming jump from 0x00CC, if 0x95d89b41 > stack[-1] // Inputs[1] { @0114 stack[-1] } 0113 5B JUMPDEST 0114 80 DUP1 0115 63 PUSH4 0x715018a6 011A 14 EQ 011B 61 PUSH2 0x0598 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0598, if 0x715018a6 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x715018a6 == stack[-1] // Inputs[1] { @011F stack[-1] } 011F 80 DUP1 0120 63 PUSH4 0x79b655d4 0125 14 EQ 0126 61 PUSH2 0x05ad 0129 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ad, if 0x79b655d4 == stack[-1] label_012A: // Incoming jump from 0x0129, if not 0x79b655d4 == stack[-1] // Inputs[1] { @012A stack[-1] } 012A 80 DUP1 012B 63 PUSH4 0x853828b6 0130 14 EQ 0131 61 PUSH2 0x05c0 0134 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c0, if 0x853828b6 == stack[-1] label_0135: // Incoming jump from 0x0134, if not 0x853828b6 == stack[-1] // Inputs[1] { @0135 stack[-1] } 0135 80 DUP1 0136 63 PUSH4 0x8b076b9b 013B 14 EQ 013C 61 PUSH2 0x05d5 013F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d5, if 0x8b076b9b == stack[-1] label_0140: // Incoming jump from 0x013F, if not 0x8b076b9b == stack[-1] // Inputs[1] { @0140 stack[-1] } 0140 80 DUP1 0141 63 PUSH4 0x8da5cb5b 0146 14 EQ 0147 61 PUSH2 0x05ef 014A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05ef, if 0x8da5cb5b == stack[-1] label_014B: // Incoming jump from 0x014A, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @014B stack[-1] } 014B 80 DUP1 014C 63 PUSH4 0x912af0ce 0151 14 EQ 0152 61 PUSH2 0x060d 0155 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x060d, if 0x912af0ce == stack[-1] label_0156: // Incoming jump from 0x0155, if not 0x912af0ce == stack[-1] // Inputs[1] { @0159 memory[0x00:0x00] } 0156 60 PUSH1 0x00 0158 80 DUP1 0159 FD *REVERT // Stack delta = +0 // Outputs[1] { @0159 revert(memory[0x00:0x00]); } // Block terminates label_015A: // Incoming jump from 0x001D, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @015B stack[-1] } 015A 5B JUMPDEST 015B 80 DUP1 015C 63 PUSH4 0x2f745c59 0161 11 GT 0162 61 PUSH2 0x01fe 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fe, if 0x2f745c59 > stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x2f745c59 > stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x4f6ccce7 016C 11 GT 016D 61 PUSH2 0x01b7 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b7, if 0x4f6ccce7 > stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @0171 stack[-1] } 0171 80 DUP1 0172 63 PUSH4 0x4f6ccce7 0177 14 EQ 0178 61 PUSH2 0x04cb 017B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04cb, if 0x4f6ccce7 == stack[-1] label_017C: // Incoming jump from 0x017B, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @017C stack[-1] } 017C 80 DUP1 017D 63 PUSH4 0x55f804b3 0182 14 EQ 0183 61 PUSH2 0x04eb 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04eb, if 0x55f804b3 == stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0187 stack[-1] } 0187 80 DUP1 0188 63 PUSH4 0x59b0d5b0 018D 14 EQ 018E 61 PUSH2 0x050b 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050b, if 0x59b0d5b0 == stack[-1] label_0192: // Incoming jump from 0x0191, if not 0x59b0d5b0 == stack[-1] // Inputs[1] { @0192 stack[-1] } 0192 80 DUP1 0193 63 PUSH4 0x5b7633d0 0198 14 EQ 0199 61 PUSH2 0x0538 019C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0538, if 0x5b7633d0 == stack[-1] label_019D: // Incoming jump from 0x019C, if not 0x5b7633d0 == stack[-1] // Inputs[1] { @019D stack[-1] } 019D 80 DUP1 019E 63 PUSH4 0x6352211e 01A3 14 EQ 01A4 61 PUSH2 0x0558 01A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0558, if 0x6352211e == stack[-1] label_01A8: // Incoming jump from 0x01A7, if not 0x6352211e == stack[-1] // Inputs[1] { @01A8 stack[-1] } 01A8 80 DUP1 01A9 63 PUSH4 0x70a08231 01AE 14 EQ 01AF 61 PUSH2 0x0578 01B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0578, if 0x70a08231 == stack[-1] label_01B3: // Incoming jump from 0x01B2, if not 0x70a08231 == stack[-1] // Inputs[1] { @01B6 memory[0x00:0x00] } 01B3 60 PUSH1 0x00 01B5 80 DUP1 01B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B6 revert(memory[0x00:0x00]); } // Block terminates label_01B7: // Incoming jump from 0x0170, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @01B8 stack[-1] } 01B7 5B JUMPDEST 01B8 80 DUP1 01B9 63 PUSH4 0x2f745c59 01BE 14 EQ 01BF 61 PUSH2 0x0414 01C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0414, if 0x2f745c59 == stack[-1] label_01C3: // Incoming jump from 0x01C2, if not 0x2f745c59 == stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C3 80 DUP1 01C4 63 PUSH4 0x38be8142 01C9 14 EQ 01CA 61 PUSH2 0x0434 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0434, if 0x38be8142 == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x38be8142 == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x3f2981cf 01D4 14 EQ 01D5 61 PUSH2 0x0449 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0449, if 0x3f2981cf == stack[-1] label_01D9: // Incoming jump from 0x01D8, if not 0x3f2981cf == stack[-1] // Inputs[1] { @01D9 stack[-1] } 01D9 80 DUP1 01DA 63 PUSH4 0x42842e0e 01DF 14 EQ 01E0 61 PUSH2 0x0468 01E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0468, if 0x42842e0e == stack[-1] label_01E4: // Incoming jump from 0x01E3, if not 0x42842e0e == stack[-1] // Inputs[1] { @01E4 stack[-1] } 01E4 80 DUP1 01E5 63 PUSH4 0x42c6355a 01EA 14 EQ 01EB 61 PUSH2 0x0488 01EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0488, if 0x42c6355a == stack[-1] label_01EF: // Incoming jump from 0x01EE, if not 0x42c6355a == stack[-1] // Inputs[1] { @01EF stack[-1] } 01EF 80 DUP1 01F0 63 PUSH4 0x449458cd 01F5 14 EQ 01F6 61 PUSH2 0x049e 01F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x049e, if 0x449458cd == stack[-1] label_01FA: // Incoming jump from 0x01F9, if not 0x449458cd == stack[-1] // Inputs[1] { @01FD memory[0x00:0x00] } 01FA 60 PUSH1 0x00 01FC 80 DUP1 01FD FD *REVERT // Stack delta = +0 // Outputs[1] { @01FD revert(memory[0x00:0x00]); } // Block terminates label_01FE: // Incoming jump from 0x0165, if 0x2f745c59 > 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 0x0369 0214 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0369, 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 0x207f3242 021B 14 EQ 021C 61 PUSH2 0x038c 021F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038c, if 0x207f3242 == stack[-1] label_0220: // Incoming jump from 0x021F, if not 0x207f3242 == stack[-1] // Inputs[1] { @0220 stack[-1] } 0220 80 DUP1 0221 63 PUSH4 0x23b872dd 0226 14 EQ 0227 61 PUSH2 0x03ac 022A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ac, 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 0x242877c5 0231 14 EQ 0232 61 PUSH2 0x03cc 0235 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03cc, if 0x242877c5 == stack[-1] label_0236: // Incoming jump from 0x0235, if not 0x242877c5 == stack[-1] // Inputs[1] { @0236 stack[-1] } 0236 80 DUP1 0237 63 PUSH4 0x2cfac6ec 023C 14 EQ 023D 61 PUSH2 0x03ec 0240 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ec, if 0x2cfac6ec == stack[-1] label_0241: // Incoming jump from 0x0240, if not 0x2cfac6ec == stack[-1] // Inputs[1] { @0241 stack[-1] } 0241 80 DUP1 0242 63 PUSH4 0x2db11544 0247 14 EQ 0248 61 PUSH2 0x0401 024B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0401, if 0x2db11544 == stack[-1] label_024C: // Incoming jump from 0x024B, if not 0x2db11544 == stack[-1] // Inputs[1] { @024F memory[0x00:0x00] } 024C 60 PUSH1 0x00 024E 80 DUP1 024F FD *REVERT // Stack delta = +0 // Outputs[1] { @024F revert(memory[0x00:0x00]); } // Block terminates label_0250: // Incoming jump from 0x0209, if 0x18160ddd > stack[-1] // Inputs[1] { @0251 stack[-1] } 0250 5B JUMPDEST 0251 80 DUP1 0252 63 PUSH4 0x01ffc9a7 0257 14 EQ 0258 61 PUSH2 0x0298 025B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0298, if 0x01ffc9a7 == stack[-1] label_025C: // Incoming jump from 0x025B, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @025C stack[-1] } 025C 80 DUP1 025D 63 PUSH4 0x046dc166 0262 14 EQ 0263 61 PUSH2 0x02cd 0266 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cd, if 0x046dc166 == stack[-1] label_0267: // Incoming jump from 0x0266, if not 0x046dc166 == stack[-1] // Inputs[1] { @0267 stack[-1] } 0267 80 DUP1 0268 63 PUSH4 0x06fdde03 026D 14 EQ 026E 61 PUSH2 0x02ef 0271 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ef, if 0x06fdde03 == stack[-1] label_0272: // Incoming jump from 0x0271, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0272 stack[-1] } 0272 80 DUP1 0273 63 PUSH4 0x081812fc 0278 14 EQ 0279 61 PUSH2 0x0311 027C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0311, if 0x081812fc == stack[-1] label_027D: // Incoming jump from 0x027C, if not 0x081812fc == stack[-1] // Inputs[1] { @027D stack[-1] } 027D 80 DUP1 027E 63 PUSH4 0x095ea7b3 0283 14 EQ 0284 61 PUSH2 0x0349 0287 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0349, if 0x095ea7b3 == stack[-1] label_0288: // Incoming jump from 0x0287, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @028B memory[0x00:0x00] } 0288 60 PUSH1 0x00 028A 80 DUP1 028B FD *REVERT // Stack delta = +0 // Outputs[1] { @028B revert(memory[0x00:0x00]); } // Block terminates label_028C: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @028D msg.data.length } 028C 5B JUMPDEST 028D 36 CALLDATASIZE 028E 61 PUSH2 0x0293 0291 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0293, if msg.data.length label_0292: // Incoming jump from 0x0291, if not msg.data.length 0292 00 *STOP // Stack delta = +0 // Outputs[1] { @0292 stop(); } // Block terminates label_0293: // Incoming jump from 0x0291, if msg.data.length // Inputs[1] { @0297 memory[0x00:0x00] } 0293 5B JUMPDEST 0294 60 PUSH1 0x00 0296 80 DUP1 0297 FD *REVERT // Stack delta = +0 // Outputs[1] { @0297 revert(memory[0x00:0x00]); } // Block terminates label_0298: // Incoming jump from 0x025B, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0299 msg.value } 0298 5B JUMPDEST 0299 34 CALLVALUE 029A 80 DUP1 029B 15 ISZERO 029C 61 PUSH2 0x02a4 029F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0299 stack[0] = msg.value } // Block ends with conditional jump to 0x02a4, if !msg.value label_02A0: // Incoming jump from 0x029F, if not !msg.value // Inputs[1] { @02A3 memory[0x00:0x00] } 02A0 60 PUSH1 0x00 02A2 80 DUP1 02A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02A3 revert(memory[0x00:0x00]); } // Block terminates label_02A4: // Incoming jump from 0x029F, if !msg.value // Inputs[1] { @02AC msg.data.length } 02A4 5B JUMPDEST 02A5 50 POP 02A6 61 PUSH2 0x02b8 02A9 61 PUSH2 0x02b3 02AC 36 CALLDATASIZE 02AD 60 PUSH1 0x04 02AF 61 PUSH2 0x2551 02B2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02A6 stack[-1] = 0x02b8 // @02A9 stack[0] = 0x02b3 // @02AC stack[1] = msg.data.length // @02AD stack[2] = 0x04 // } // Block ends with call to 0x2551, returns to 0x02B3 label_02B3: // Incoming return from call to 0x2551 at 0x02B2 02B3 5B JUMPDEST 02B4 61 PUSH2 0x0813 02B7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0813 label_02B8: // Incoming jump from 0x0467 // Incoming return from call to 0x02B3 at 0x02B2 // Incoming jump from 0x05EE // Inputs[2] // { // @02BB memory[0x40:0x60] // @02BC stack[-1] // } 02B8 5B JUMPDEST 02B9 60 PUSH1 0x40 02BB 51 MLOAD 02BC 90 SWAP1 02BD 15 ISZERO 02BE 15 ISZERO 02BF 81 DUP2 02C0 52 MSTORE 02C1 60 PUSH1 0x20 02C3 01 ADD // Stack delta = +0 // Outputs[2] // { // @02C0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @02C3 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_02C4: // Incoming jump from 0x0348 // Incoming jump from 0x02C3 // Incoming jump from 0x038B // Inputs[3] // { // @02C7 memory[0x40:0x60] // @02C9 stack[-1] // @02CC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 02C4 5B JUMPDEST 02C5 60 PUSH1 0x40 02C7 51 MLOAD 02C8 80 DUP1 02C9 91 SWAP2 02CA 03 SUB 02CB 90 SWAP1 02CC F3 *RETURN // Stack delta = -1 // Outputs[1] { @02CC return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02CD: // Incoming jump from 0x0266, if 0x046dc166 == stack[-1] // Inputs[1] { @02CE msg.value } 02CD 5B JUMPDEST 02CE 34 CALLVALUE 02CF 80 DUP1 02D0 15 ISZERO 02D1 61 PUSH2 0x02d9 02D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CE stack[0] = msg.value } // Block ends with conditional jump to 0x02d9, if !msg.value label_02D5: // Incoming jump from 0x02D4, if not !msg.value // Inputs[1] { @02D8 memory[0x00:0x00] } 02D5 60 PUSH1 0x00 02D7 80 DUP1 02D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D8 revert(memory[0x00:0x00]); } // Block terminates label_02D9: // Incoming jump from 0x02D4, if !msg.value // Inputs[1] { @02E1 msg.data.length } 02D9 5B JUMPDEST 02DA 50 POP 02DB 61 PUSH2 0x02ed 02DE 61 PUSH2 0x02e8 02E1 36 CALLDATASIZE 02E2 60 PUSH1 0x04 02E4 61 PUSH2 0x2583 02E7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02DB stack[-1] = 0x02ed // @02DE stack[0] = 0x02e8 // @02E1 stack[1] = msg.data.length // @02E2 stack[2] = 0x04 // } // Block ends with call to 0x2583, returns to 0x02E8 label_02E8: // Incoming return from call to 0x2583 at 0x02E7 02E8 5B JUMPDEST 02E9 61 PUSH2 0x0880 02EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0880 label_02ED: // Incoming return from call to 0x0F4D at 0x05AC // Incoming return from call to 0x02E8 at 0x02E7 // Incoming return from call to 0x13C2 at 0x0675 // Incoming return from call to 0x12A0 at 0x0621 // Incoming return from call to 0x0DFF at 0x0448 // Incoming return from call to 0x07DD at 0x07DC // Incoming return from call to 0x06B1 at 0x06B0 // Incoming return from call to 0x0691 at 0x0690 // Incoming return from call to 0x0751 at 0x0750 02ED 5B JUMPDEST 02EE 00 *STOP // Stack delta = +0 // Outputs[1] { @02EE stop(); } // Block terminates label_02EF: // Incoming jump from 0x0271, if 0x06fdde03 == stack[-1] // Inputs[1] { @02F0 msg.value } 02EF 5B JUMPDEST 02F0 34 CALLVALUE 02F1 80 DUP1 02F2 15 ISZERO 02F3 61 PUSH2 0x02fb 02F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02F0 stack[0] = msg.value } // Block ends with conditional jump to 0x02fb, if !msg.value label_02F7: // Incoming jump from 0x02F6, if not !msg.value // Inputs[1] { @02FA memory[0x00:0x00] } 02F7 60 PUSH1 0x00 02F9 80 DUP1 02FA FD *REVERT // Stack delta = +0 // Outputs[1] { @02FA revert(memory[0x00:0x00]); } // Block terminates label_02FB: // Incoming jump from 0x02F6, if !msg.value 02FB 5B JUMPDEST 02FC 50 POP 02FD 61 PUSH2 0x0304 0300 61 PUSH2 0x08ea 0303 56 *JUMP // Stack delta = +0 // Outputs[1] { @02FD stack[-1] = 0x0304 } // Block ends with call to 0x08ea, returns to 0x0304 label_0304: // Incoming return from call to 0x08EA at 0x0303 // Incoming return from call to 0x13B5 at 0x0660 // Incoming return from call to 0x1327 at 0x064B // Incoming return from call to 0x1318 at 0x0636 // Inputs[2] // { // @0307 memory[0x40:0x60] // @030B stack[-1] // } 0304 5B JUMPDEST 0305 60 PUSH1 0x40 0307 51 MLOAD 0308 61 PUSH2 0x02c4 030B 91 SWAP2 030C 90 SWAP1 030D 61 PUSH2 0x25f8 0310 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @030B stack[-1] = 0x02c4 // @030C stack[1] = memory[0x40:0x60] // @030C stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x25f8 label_0311: // Incoming jump from 0x027C, if 0x081812fc == stack[-1] // Inputs[1] { @0312 msg.value } 0311 5B JUMPDEST 0312 34 CALLVALUE 0313 80 DUP1 0314 15 ISZERO 0315 61 PUSH2 0x031d 0318 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0312 stack[0] = msg.value } // Block ends with conditional jump to 0x031d, if !msg.value label_0319: // Incoming jump from 0x0318, if not !msg.value // Inputs[1] { @031C memory[0x00:0x00] } 0319 60 PUSH1 0x00 031B 80 DUP1 031C FD *REVERT // Stack delta = +0 // Outputs[1] { @031C revert(memory[0x00:0x00]); } // Block terminates label_031D: // Incoming jump from 0x0318, if !msg.value // Inputs[1] { @0325 msg.data.length } 031D 5B JUMPDEST 031E 50 POP 031F 61 PUSH2 0x0331 0322 61 PUSH2 0x032c 0325 36 CALLDATASIZE 0326 60 PUSH1 0x04 0328 61 PUSH2 0x260b 032B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @031F stack[-1] = 0x0331 // @0322 stack[0] = 0x032c // @0325 stack[1] = msg.data.length // @0326 stack[2] = 0x04 // } // Block ends with call to 0x260b, returns to 0x032C label_032C: // Incoming return from call to 0x260B at 0x032B 032C 5B JUMPDEST 032D 61 PUSH2 0x097c 0330 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x097c label_0331: // Incoming return from call to 0x032C at 0x032B // Incoming jump from 0x060C // Incoming return from call to 0x0573 at 0x0572 // Incoming jump from 0x0557 // Incoming jump from 0x0735 // Inputs[2] // { // @0334 memory[0x40:0x60] // @033E stack[-1] // } 0331 5B JUMPDEST 0332 60 PUSH1 0x40 0334 51 MLOAD 0335 60 PUSH1 0x01 0337 60 PUSH1 0x01 0339 60 PUSH1 0xa0 033B 1B SHL 033C 03 SUB 033D 90 SWAP1 033E 91 SWAP2 033F 16 AND 0340 81 DUP2 0341 52 MSTORE 0342 60 PUSH1 0x20 0344 01 ADD 0345 61 PUSH2 0x02c4 0348 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0341 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0344 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02c4 label_0349: // Incoming jump from 0x0287, if 0x095ea7b3 == stack[-1] // Inputs[1] { @034A msg.value } 0349 5B JUMPDEST 034A 34 CALLVALUE 034B 80 DUP1 034C 15 ISZERO 034D 61 PUSH2 0x0355 0350 57 *JUMPI // Stack delta = +1 // Outputs[1] { @034A stack[0] = msg.value } // Block ends with conditional jump to 0x0355, if !msg.value label_0351: // Incoming jump from 0x0350, if not !msg.value // Inputs[1] { @0354 memory[0x00:0x00] } 0351 60 PUSH1 0x00 0353 80 DUP1 0354 FD *REVERT // Stack delta = +0 // Outputs[1] { @0354 revert(memory[0x00:0x00]); } // Block terminates label_0355: // Incoming jump from 0x0350, if !msg.value // Inputs[1] { @035D msg.data.length } 0355 5B JUMPDEST 0356 50 POP 0357 61 PUSH2 0x02ed 035A 61 PUSH2 0x0364 035D 36 CALLDATASIZE 035E 60 PUSH1 0x04 0360 61 PUSH2 0x2624 0363 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0357 stack[-1] = 0x02ed // @035A stack[0] = 0x0364 // @035D stack[1] = msg.data.length // @035E stack[2] = 0x04 // } // Block ends with call to 0x2624, returns to 0x0364 label_0364: // Incoming return from call to 0x2624 at 0x0363 0364 5B JUMPDEST 0365 61 PUSH2 0x09c0 0368 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09c0 label_0369: // Incoming jump from 0x0214, if 0x18160ddd == stack[-1] // Inputs[1] { @036A msg.value } 0369 5B JUMPDEST 036A 34 CALLVALUE 036B 80 DUP1 036C 15 ISZERO 036D 61 PUSH2 0x0375 0370 57 *JUMPI // Stack delta = +1 // Outputs[1] { @036A stack[0] = msg.value } // Block ends with conditional jump to 0x0375, if !msg.value label_0371: // Incoming jump from 0x0370, if not !msg.value // Inputs[1] { @0374 memory[0x00:0x00] } 0371 60 PUSH1 0x00 0373 80 DUP1 0374 FD *REVERT // Stack delta = +0 // Outputs[1] { @0374 revert(memory[0x00:0x00]); } // Block terminates label_0375: // Incoming jump from 0x0370, if !msg.value // Inputs[1] { @0379 storage[0x00] } 0375 5B JUMPDEST 0376 50 POP 0377 60 PUSH1 0x00 0379 54 SLOAD 037A 60 PUSH1 0x00 037C 19 NOT 037D 01 ADD // Stack delta = +0 // Outputs[1] { @037D stack[-1] = ~0x00 + storage[0x00] } // Block continues label_037E: // Incoming return from call to 0x04B9 at 0x04B8 // Incoming jump from 0x049D // Incoming jump from 0x07A1 // Incoming jump from 0x076B // Incoming jump from 0x0400 // Incoming return from call to 0x042F at 0x042E // Incoming jump from 0x037D // Incoming jump from 0x0786 // Incoming jump from 0x0812 // Incoming return from call to 0x0593 at 0x0592 // Incoming jump from 0x07FC // Incoming return from call to 0x04E6 at 0x04E5 // Incoming return from call to 0x0526 at 0x0525 // Inputs[2] // { // @0381 memory[0x40:0x60] // @0382 stack[-1] // } 037E 5B JUMPDEST 037F 60 PUSH1 0x40 0381 51 MLOAD 0382 90 SWAP1 0383 81 DUP2 0384 52 MSTORE 0385 60 PUSH1 0x20 0387 01 ADD 0388 61 PUSH2 0x02c4 038B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0384 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0387 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02c4 label_038C: // Incoming jump from 0x021F, if 0x207f3242 == stack[-1] // Inputs[1] { @038D msg.value } 038C 5B JUMPDEST 038D 34 CALLVALUE 038E 80 DUP1 038F 15 ISZERO 0390 61 PUSH2 0x0398 0393 57 *JUMPI // Stack delta = +1 // Outputs[1] { @038D stack[0] = msg.value } // Block ends with conditional jump to 0x0398, if !msg.value label_0394: // Incoming jump from 0x0393, if not !msg.value // Inputs[1] { @0397 memory[0x00:0x00] } 0394 60 PUSH1 0x00 0396 80 DUP1 0397 FD *REVERT // Stack delta = +0 // Outputs[1] { @0397 revert(memory[0x00:0x00]); } // Block terminates label_0398: // Incoming jump from 0x0393, if !msg.value // Inputs[1] { @03A0 msg.data.length } 0398 5B JUMPDEST 0399 50 POP 039A 61 PUSH2 0x02ed 039D 61 PUSH2 0x03a7 03A0 36 CALLDATASIZE 03A1 60 PUSH1 0x04 03A3 61 PUSH2 0x2650 03A6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @039A stack[-1] = 0x02ed // @039D stack[0] = 0x03a7 // @03A0 stack[1] = msg.data.length // @03A1 stack[2] = 0x04 // } // Block ends with call to 0x2650, returns to 0x03A7 label_03A7: // Incoming return from call to 0x2650 at 0x03A6 03A7 5B JUMPDEST 03A8 61 PUSH2 0x0a4e 03AB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a4e label_03AC: // Incoming jump from 0x022A, if 0x23b872dd == stack[-1] // Inputs[1] { @03AD msg.value } 03AC 5B JUMPDEST 03AD 34 CALLVALUE 03AE 80 DUP1 03AF 15 ISZERO 03B0 61 PUSH2 0x03b8 03B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03AD stack[0] = msg.value } // Block ends with conditional jump to 0x03b8, if !msg.value label_03B4: // Incoming jump from 0x03B3, if not !msg.value // Inputs[1] { @03B7 memory[0x00:0x00] } 03B4 60 PUSH1 0x00 03B6 80 DUP1 03B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03B7 revert(memory[0x00:0x00]); } // Block terminates label_03B8: // Incoming jump from 0x03B3, if !msg.value // Inputs[1] { @03C0 msg.data.length } 03B8 5B JUMPDEST 03B9 50 POP 03BA 61 PUSH2 0x02ed 03BD 61 PUSH2 0x03c7 03C0 36 CALLDATASIZE 03C1 60 PUSH1 0x04 03C3 61 PUSH2 0x26d0 03C6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03BA stack[-1] = 0x02ed // @03BD stack[0] = 0x03c7 // @03C0 stack[1] = msg.data.length // @03C1 stack[2] = 0x04 // } // Block ends with call to 0x26d0, returns to 0x03C7 label_03C7: // Incoming return from call to 0x26D0 at 0x03C6 03C7 5B JUMPDEST 03C8 61 PUSH2 0x0bb6 03CB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bb6 label_03CC: // Incoming jump from 0x0235, if 0x242877c5 == stack[-1] // Inputs[1] { @03CD msg.value } 03CC 5B JUMPDEST 03CD 34 CALLVALUE 03CE 80 DUP1 03CF 15 ISZERO 03D0 61 PUSH2 0x03d8 03D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03CD stack[0] = msg.value } // Block ends with conditional jump to 0x03d8, if !msg.value label_03D4: // Incoming jump from 0x03D3, if not !msg.value // Inputs[1] { @03D7 memory[0x00:0x00] } 03D4 60 PUSH1 0x00 03D6 80 DUP1 03D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D7 revert(memory[0x00:0x00]); } // Block terminates label_03D8: // Incoming jump from 0x03D3, if !msg.value // Inputs[1] { @03E0 msg.data.length } 03D8 5B JUMPDEST 03D9 50 POP 03DA 61 PUSH2 0x02ed 03DD 61 PUSH2 0x03e7 03E0 36 CALLDATASIZE 03E1 60 PUSH1 0x04 03E3 61 PUSH2 0x279d 03E6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03DA stack[-1] = 0x02ed // @03DD stack[0] = 0x03e7 // @03E0 stack[1] = msg.data.length // @03E1 stack[2] = 0x04 // } // Block ends with call to 0x279d, returns to 0x03E7 label_03E7: // Incoming return from call to 0x279D at 0x03E6 03E7 5B JUMPDEST 03E8 61 PUSH2 0x0bc1 03EB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bc1 label_03EC: // Incoming jump from 0x0240, if 0x2cfac6ec == stack[-1] // Inputs[1] { @03ED msg.value } 03EC 5B JUMPDEST 03ED 34 CALLVALUE 03EE 80 DUP1 03EF 15 ISZERO 03F0 61 PUSH2 0x03f8 03F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03ED stack[0] = msg.value } // Block ends with conditional jump to 0x03f8, if !msg.value label_03F4: // Incoming jump from 0x03F3, if not !msg.value // Inputs[1] { @03F7 memory[0x00:0x00] } 03F4 60 PUSH1 0x00 03F6 80 DUP1 03F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F7 revert(memory[0x00:0x00]); } // Block terminates label_03F8: // Incoming jump from 0x03F3, if !msg.value 03F8 5B JUMPDEST 03F9 50 POP 03FA 61 PUSH2 0x037e 03FD 60 PUSH1 0x64 03FF 81 DUP2 0400 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03FA stack[-1] = 0x037e // @03FD stack[0] = 0x64 // } // Block ends with unconditional jump to 0x037e label_0401: // Incoming jump from 0x024B, if 0x2db11544 == stack[-1] // Inputs[1] { @0408 msg.data.length } 0401 5B JUMPDEST 0402 61 PUSH2 0x02ed 0405 61 PUSH2 0x040f 0408 36 CALLDATASIZE 0409 60 PUSH1 0x04 040B 61 PUSH2 0x260b 040E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0402 stack[0] = 0x02ed // @0405 stack[1] = 0x040f // @0408 stack[2] = msg.data.length // @0409 stack[3] = 0x04 // } // Block ends with call to 0x260b, returns to 0x040F label_040F: // Incoming return from call to 0x260B at 0x040E 040F 5B JUMPDEST 0410 61 PUSH2 0x0c17 0413 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c17 label_0414: // Incoming jump from 0x01C2, if 0x2f745c59 == stack[-1] // Inputs[1] { @0415 msg.value } 0414 5B JUMPDEST 0415 34 CALLVALUE 0416 80 DUP1 0417 15 ISZERO 0418 61 PUSH2 0x0420 041B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0415 stack[0] = msg.value } // Block ends with conditional jump to 0x0420, if !msg.value label_041C: // Incoming jump from 0x041B, if not !msg.value // Inputs[1] { @041F memory[0x00:0x00] } 041C 60 PUSH1 0x00 041E 80 DUP1 041F FD *REVERT // Stack delta = +0 // Outputs[1] { @041F revert(memory[0x00:0x00]); } // Block terminates label_0420: // Incoming jump from 0x041B, if !msg.value // Inputs[1] { @0428 msg.data.length } 0420 5B JUMPDEST 0421 50 POP 0422 61 PUSH2 0x037e 0425 61 PUSH2 0x042f 0428 36 CALLDATASIZE 0429 60 PUSH1 0x04 042B 61 PUSH2 0x2624 042E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0422 stack[-1] = 0x037e // @0425 stack[0] = 0x042f // @0428 stack[1] = msg.data.length // @0429 stack[2] = 0x04 // } // Block ends with call to 0x2624, returns to 0x042F label_042F: // Incoming return from call to 0x2624 at 0x042E 042F 5B JUMPDEST 0430 61 PUSH2 0x0d29 0433 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d29 label_0434: // Incoming jump from 0x01CD, if 0x38be8142 == stack[-1] // Inputs[1] { @0435 msg.value } 0434 5B JUMPDEST 0435 34 CALLVALUE 0436 80 DUP1 0437 15 ISZERO 0438 61 PUSH2 0x0440 043B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0435 stack[0] = msg.value } // Block ends with conditional jump to 0x0440, if !msg.value label_043C: // Incoming jump from 0x043B, if not !msg.value // Inputs[1] { @043F memory[0x00:0x00] } 043C 60 PUSH1 0x00 043E 80 DUP1 043F FD *REVERT // Stack delta = +0 // Outputs[1] { @043F revert(memory[0x00:0x00]); } // Block terminates label_0440: // Incoming jump from 0x043B, if !msg.value 0440 5B JUMPDEST 0441 50 POP 0442 61 PUSH2 0x02ed 0445 61 PUSH2 0x0dff 0448 56 *JUMP // Stack delta = +0 // Outputs[1] { @0442 stack[-1] = 0x02ed } // Block ends with call to 0x0dff, returns to 0x02ED label_0449: // Incoming jump from 0x01D8, if 0x3f2981cf == stack[-1] // Inputs[1] { @044A msg.value } 0449 5B JUMPDEST 044A 34 CALLVALUE 044B 80 DUP1 044C 15 ISZERO 044D 61 PUSH2 0x0455 0450 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044A stack[0] = msg.value } // Block ends with conditional jump to 0x0455, if !msg.value label_0451: // Incoming jump from 0x0450, if not !msg.value // Inputs[1] { @0454 memory[0x00:0x00] } 0451 60 PUSH1 0x00 0453 80 DUP1 0454 FD *REVERT // Stack delta = +0 // Outputs[1] { @0454 revert(memory[0x00:0x00]); } // Block terminates label_0455: // Incoming jump from 0x0450, if !msg.value // Inputs[1] { @0459 storage[0x19] } 0455 5B JUMPDEST 0456 50 POP 0457 60 PUSH1 0x19 0459 54 SLOAD 045A 61 PUSH2 0x02b8 045D 90 SWAP1 045E 61 PUSH2 0x0100 0461 90 SWAP1 0462 04 DIV 0463 60 PUSH1 0xff 0465 16 AND 0466 81 DUP2 0467 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @045D stack[-1] = 0x02b8 // @0465 stack[0] = 0xff & storage[0x19] / 0x0100 // } // Block ends with unconditional jump to 0x02b8 label_0468: // Incoming jump from 0x01E3, if 0x42842e0e == stack[-1] // Inputs[1] { @0469 msg.value } 0468 5B JUMPDEST 0469 34 CALLVALUE 046A 80 DUP1 046B 15 ISZERO 046C 61 PUSH2 0x0474 046F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0469 stack[0] = msg.value } // Block ends with conditional jump to 0x0474, if !msg.value label_0470: // Incoming jump from 0x046F, if not !msg.value // Inputs[1] { @0473 memory[0x00:0x00] } 0470 60 PUSH1 0x00 0472 80 DUP1 0473 FD *REVERT // Stack delta = +0 // Outputs[1] { @0473 revert(memory[0x00:0x00]); } // Block terminates label_0474: // Incoming jump from 0x046F, if !msg.value // Inputs[1] { @047C msg.data.length } 0474 5B JUMPDEST 0475 50 POP 0476 61 PUSH2 0x02ed 0479 61 PUSH2 0x0483 047C 36 CALLDATASIZE 047D 60 PUSH1 0x04 047F 61 PUSH2 0x26d0 0482 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0476 stack[-1] = 0x02ed // @0479 stack[0] = 0x0483 // @047C stack[1] = msg.data.length // @047D stack[2] = 0x04 // } // Block ends with call to 0x26d0, returns to 0x0483 label_0483: // Incoming return from call to 0x26D0 at 0x0482 0483 5B JUMPDEST 0484 61 PUSH2 0x0e52 0487 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e52 label_0488: // Incoming jump from 0x01EE, if 0x42c6355a == stack[-1] // Inputs[1] { @0489 msg.value } 0488 5B JUMPDEST 0489 34 CALLVALUE 048A 80 DUP1 048B 15 ISZERO 048C 61 PUSH2 0x0494 048F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0489 stack[0] = msg.value } // Block ends with conditional jump to 0x0494, if !msg.value label_0490: // Incoming jump from 0x048F, if not !msg.value // Inputs[1] { @0493 memory[0x00:0x00] } 0490 60 PUSH1 0x00 0492 80 DUP1 0493 FD *REVERT // Stack delta = +0 // Outputs[1] { @0493 revert(memory[0x00:0x00]); } // Block terminates label_0494: // Incoming jump from 0x048F, if !msg.value // Inputs[1] { @049B storage[0x0b] } 0494 5B JUMPDEST 0495 50 POP 0496 61 PUSH2 0x037e 0499 60 PUSH1 0x0b 049B 54 SLOAD 049C 81 DUP2 049D 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0496 stack[-1] = 0x037e // @049B stack[0] = storage[0x0b] // } // Block ends with unconditional jump to 0x037e label_049E: // Incoming jump from 0x01F9, if 0x449458cd == stack[-1] // Inputs[1] { @049F msg.value } 049E 5B JUMPDEST 049F 34 CALLVALUE 04A0 80 DUP1 04A1 15 ISZERO 04A2 61 PUSH2 0x04aa 04A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @049F stack[0] = msg.value } // Block ends with conditional jump to 0x04aa, if !msg.value label_04A6: // Incoming jump from 0x04A5, if not !msg.value // Inputs[1] { @04A9 memory[0x00:0x00] } 04A6 60 PUSH1 0x00 04A8 80 DUP1 04A9 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A9 revert(memory[0x00:0x00]); } // Block terminates label_04AA: // Incoming jump from 0x04A5, if !msg.value // Inputs[1] { @04B2 msg.data.length } 04AA 5B JUMPDEST 04AB 50 POP 04AC 61 PUSH2 0x037e 04AF 61 PUSH2 0x04b9 04B2 36 CALLDATASIZE 04B3 60 PUSH1 0x04 04B5 61 PUSH2 0x2583 04B8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04AC stack[-1] = 0x037e // @04AF stack[0] = 0x04b9 // @04B2 stack[1] = msg.data.length // @04B3 stack[2] = 0x04 // } // Block ends with call to 0x2583, returns to 0x04B9 label_04B9: // Incoming return from call to 0x2583 at 0x04B8 // Inputs[4] // { // @04C1 stack[-1] // @04C7 memory[0x00:0x40] // @04C8 storage[keccak256(memory[0x00:0x40])] // @04C9 stack[-2] // } 04B9 5B JUMPDEST 04BA 60 PUSH1 0x08 04BC 60 PUSH1 0x20 04BE 52 MSTORE 04BF 60 PUSH1 0x00 04C1 90 SWAP1 04C2 81 DUP2 04C3 52 MSTORE 04C4 60 PUSH1 0x40 04C6 90 SWAP1 04C7 20 SHA3 04C8 54 SLOAD 04C9 81 DUP2 04CA 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04BE memory[0x20:0x40] = 0x08 // @04C3 memory[0x00:0x20] = stack[-1] // @04C8 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_04CB: // Incoming jump from 0x017B, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @04CC msg.value } 04CB 5B JUMPDEST 04CC 34 CALLVALUE 04CD 80 DUP1 04CE 15 ISZERO 04CF 61 PUSH2 0x04d7 04D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04CC stack[0] = msg.value } // Block ends with conditional jump to 0x04d7, if !msg.value label_04D3: // Incoming jump from 0x04D2, if not !msg.value // Inputs[1] { @04D6 memory[0x00:0x00] } 04D3 60 PUSH1 0x00 04D5 80 DUP1 04D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04D6 revert(memory[0x00:0x00]); } // Block terminates label_04D7: // Incoming jump from 0x04D2, if !msg.value // Inputs[1] { @04DF msg.data.length } 04D7 5B JUMPDEST 04D8 50 POP 04D9 61 PUSH2 0x037e 04DC 61 PUSH2 0x04e6 04DF 36 CALLDATASIZE 04E0 60 PUSH1 0x04 04E2 61 PUSH2 0x260b 04E5 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04D9 stack[-1] = 0x037e // @04DC stack[0] = 0x04e6 // @04DF stack[1] = msg.data.length // @04E0 stack[2] = 0x04 // } // Block ends with call to 0x260b, returns to 0x04E6 label_04E6: // Incoming return from call to 0x260B at 0x04E5 04E6 5B JUMPDEST 04E7 61 PUSH2 0x0e6d 04EA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e6d label_04EB: // Incoming jump from 0x0186, if 0x55f804b3 == stack[-1] // Inputs[1] { @04EC msg.value } 04EB 5B JUMPDEST 04EC 34 CALLVALUE 04ED 80 DUP1 04EE 15 ISZERO 04EF 61 PUSH2 0x04f7 04F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04EC stack[0] = msg.value } // Block ends with conditional jump to 0x04f7, if !msg.value label_04F3: // Incoming jump from 0x04F2, if not !msg.value // Inputs[1] { @04F6 memory[0x00:0x00] } 04F3 60 PUSH1 0x00 04F5 80 DUP1 04F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F6 revert(memory[0x00:0x00]); } // Block terminates label_04F7: // Incoming jump from 0x04F2, if !msg.value // Inputs[1] { @04FF msg.data.length } 04F7 5B JUMPDEST 04F8 50 POP 04F9 61 PUSH2 0x02ed 04FC 61 PUSH2 0x0506 04FF 36 CALLDATASIZE 0500 60 PUSH1 0x04 0502 61 PUSH2 0x279d 0505 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04F9 stack[-1] = 0x02ed // @04FC stack[0] = 0x0506 // @04FF stack[1] = msg.data.length // @0500 stack[2] = 0x04 // } // Block ends with call to 0x279d, returns to 0x0506 label_0506: // Incoming return from call to 0x279D at 0x0505 0506 5B JUMPDEST 0507 61 PUSH2 0x0e9b 050A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e9b label_050B: // Incoming jump from 0x0191, if 0x59b0d5b0 == stack[-1] // Inputs[1] { @050C msg.value } 050B 5B JUMPDEST 050C 34 CALLVALUE 050D 80 DUP1 050E 15 ISZERO 050F 61 PUSH2 0x0517 0512 57 *JUMPI // Stack delta = +1 // Outputs[1] { @050C stack[0] = msg.value } // Block ends with conditional jump to 0x0517, if !msg.value label_0513: // Incoming jump from 0x0512, if not !msg.value // Inputs[1] { @0516 memory[0x00:0x00] } 0513 60 PUSH1 0x00 0515 80 DUP1 0516 FD *REVERT // Stack delta = +0 // Outputs[1] { @0516 revert(memory[0x00:0x00]); } // Block terminates label_0517: // Incoming jump from 0x0512, if !msg.value // Inputs[1] { @051F msg.data.length } 0517 5B JUMPDEST 0518 50 POP 0519 61 PUSH2 0x037e 051C 61 PUSH2 0x0526 051F 36 CALLDATASIZE 0520 60 PUSH1 0x04 0522 61 PUSH2 0x2583 0525 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0519 stack[-1] = 0x037e // @051C stack[0] = 0x0526 // @051F stack[1] = msg.data.length // @0520 stack[2] = 0x04 // } // Block ends with call to 0x2583, returns to 0x0526 label_0526: // Incoming return from call to 0x2583 at 0x0525 // Inputs[4] // { // @052E stack[-1] // @0534 memory[0x00:0x40] // @0535 storage[keccak256(memory[0x00:0x40])] // @0536 stack[-2] // } 0526 5B JUMPDEST 0527 60 PUSH1 0x09 0529 60 PUSH1 0x20 052B 52 MSTORE 052C 60 PUSH1 0x00 052E 90 SWAP1 052F 81 DUP2 0530 52 MSTORE 0531 60 PUSH1 0x40 0533 90 SWAP1 0534 20 SHA3 0535 54 SLOAD 0536 81 DUP2 0537 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @052B memory[0x20:0x40] = 0x09 // @0530 memory[0x00:0x20] = stack[-1] // @0535 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0538: // Incoming jump from 0x019C, if 0x5b7633d0 == stack[-1] // Inputs[1] { @0539 msg.value } 0538 5B JUMPDEST 0539 34 CALLVALUE 053A 80 DUP1 053B 15 ISZERO 053C 61 PUSH2 0x0544 053F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0539 stack[0] = msg.value } // Block ends with conditional jump to 0x0544, if !msg.value label_0540: // Incoming jump from 0x053F, if not !msg.value // Inputs[1] { @0543 memory[0x00:0x00] } 0540 60 PUSH1 0x00 0542 80 DUP1 0543 FD *REVERT // Stack delta = +0 // Outputs[1] { @0543 revert(memory[0x00:0x00]); } // Block terminates label_0544: // Incoming jump from 0x053F, if !msg.value // Inputs[1] { @0548 storage[0x0c] } 0544 5B JUMPDEST 0545 50 POP 0546 60 PUSH1 0x0c 0548 54 SLOAD 0549 61 PUSH2 0x0331 054C 90 SWAP1 054D 60 PUSH1 0x01 054F 60 PUSH1 0x01 0551 60 PUSH1 0xa0 0553 1B SHL 0554 03 SUB 0555 16 AND 0556 81 DUP2 0557 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @054C stack[-1] = 0x0331 // @0555 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0c] // } // Block ends with unconditional jump to 0x0331 label_0558: // Incoming jump from 0x01A7, if 0x6352211e == stack[-1] // Inputs[1] { @0559 msg.value } 0558 5B JUMPDEST 0559 34 CALLVALUE 055A 80 DUP1 055B 15 ISZERO 055C 61 PUSH2 0x0564 055F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0559 stack[0] = msg.value } // Block ends with conditional jump to 0x0564, if !msg.value label_0560: // Incoming jump from 0x055F, if not !msg.value // 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.value // Inputs[1] { @056C msg.data.length } 0564 5B JUMPDEST 0565 50 POP 0566 61 PUSH2 0x0331 0569 61 PUSH2 0x0573 056C 36 CALLDATASIZE 056D 60 PUSH1 0x04 056F 61 PUSH2 0x260b 0572 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0566 stack[-1] = 0x0331 // @0569 stack[0] = 0x0573 // @056C stack[1] = msg.data.length // @056D stack[2] = 0x04 // } // Block ends with call to 0x260b, returns to 0x0573 label_0573: // Incoming return from call to 0x260B at 0x0572 0573 5B JUMPDEST 0574 61 PUSH2 0x0eed 0577 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eed label_0578: // Incoming jump from 0x01B2, if 0x70a08231 == stack[-1] // Inputs[1] { @0579 msg.value } 0578 5B JUMPDEST 0579 34 CALLVALUE 057A 80 DUP1 057B 15 ISZERO 057C 61 PUSH2 0x0584 057F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0579 stack[0] = msg.value } // Block ends with conditional jump to 0x0584, if !msg.value label_0580: // Incoming jump from 0x057F, if not !msg.value // Inputs[1] { @0583 memory[0x00:0x00] } 0580 60 PUSH1 0x00 0582 80 DUP1 0583 FD *REVERT // Stack delta = +0 // Outputs[1] { @0583 revert(memory[0x00:0x00]); } // Block terminates label_0584: // Incoming jump from 0x057F, if !msg.value // Inputs[1] { @058C msg.data.length } 0584 5B JUMPDEST 0585 50 POP 0586 61 PUSH2 0x037e 0589 61 PUSH2 0x0593 058C 36 CALLDATASIZE 058D 60 PUSH1 0x04 058F 61 PUSH2 0x2583 0592 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0586 stack[-1] = 0x037e // @0589 stack[0] = 0x0593 // @058C stack[1] = msg.data.length // @058D stack[2] = 0x04 // } // Block ends with call to 0x2583, returns to 0x0593 label_0593: // Incoming return from call to 0x2583 at 0x0592 0593 5B JUMPDEST 0594 61 PUSH2 0x0eff 0597 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eff label_0598: // Incoming jump from 0x011E, if 0x715018a6 == stack[-1] // Inputs[1] { @0599 msg.value } 0598 5B JUMPDEST 0599 34 CALLVALUE 059A 80 DUP1 059B 15 ISZERO 059C 61 PUSH2 0x05a4 059F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0599 stack[0] = msg.value } // Block ends with conditional jump to 0x05a4, if !msg.value label_05A0: // Incoming jump from 0x059F, if not !msg.value // Inputs[1] { @05A3 memory[0x00:0x00] } 05A0 60 PUSH1 0x00 05A2 80 DUP1 05A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @05A3 revert(memory[0x00:0x00]); } // Block terminates label_05A4: // Incoming jump from 0x059F, if !msg.value 05A4 5B JUMPDEST 05A5 50 POP 05A6 61 PUSH2 0x02ed 05A9 61 PUSH2 0x0f4d 05AC 56 *JUMP // Stack delta = +0 // Outputs[1] { @05A6 stack[-1] = 0x02ed } // Block ends with call to 0x0f4d, returns to 0x02ED label_05AD: // Incoming jump from 0x0129, if 0x79b655d4 == stack[-1] // Inputs[1] { @05B4 msg.data.length } 05AD 5B JUMPDEST 05AE 61 PUSH2 0x02ed 05B1 61 PUSH2 0x05bb 05B4 36 CALLDATASIZE 05B5 60 PUSH1 0x04 05B7 61 PUSH2 0x2650 05BA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05AE stack[0] = 0x02ed // @05B1 stack[1] = 0x05bb // @05B4 stack[2] = msg.data.length // @05B5 stack[3] = 0x04 // } // Block ends with call to 0x2650, returns to 0x05BB label_05BB: // Incoming return from call to 0x2650 at 0x05BA 05BB 5B JUMPDEST 05BC 61 PUSH2 0x0fb3 05BF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fb3 label_05C0: // Incoming jump from 0x0134, if 0x853828b6 == stack[-1] // Inputs[1] { @05C1 msg.value } 05C0 5B JUMPDEST 05C1 34 CALLVALUE 05C2 80 DUP1 05C3 15 ISZERO 05C4 61 PUSH2 0x05cc 05C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05C1 stack[0] = msg.value } // Block ends with conditional jump to 0x05cc, if !msg.value label_05C8: // Incoming jump from 0x05C7, if not !msg.value // Inputs[1] { @05CB memory[0x00:0x00] } 05C8 60 PUSH1 0x00 05CA 80 DUP1 05CB FD *REVERT // Stack delta = +0 // Outputs[1] { @05CB revert(memory[0x00:0x00]); } // Block terminates label_05CC: // Incoming jump from 0x05C7, if !msg.value 05CC 5B JUMPDEST 05CD 50 POP 05CE 61 PUSH2 0x02ed 05D1 61 PUSH2 0x116f 05D4 56 *JUMP // Stack delta = +0 // Outputs[1] { @05CE stack[-1] = 0x02ed } // Block ends with unconditional jump to 0x116f label_05D5: // Incoming jump from 0x013F, if 0x8b076b9b == stack[-1] // Inputs[1] { @05D6 msg.value } 05D5 5B JUMPDEST 05D6 34 CALLVALUE 05D7 80 DUP1 05D8 15 ISZERO 05D9 61 PUSH2 0x05e1 05DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D6 stack[0] = msg.value } // Block ends with conditional jump to 0x05e1, if !msg.value label_05DD: // Incoming jump from 0x05DC, if not !msg.value // Inputs[1] { @05E0 memory[0x00:0x00] } 05DD 60 PUSH1 0x00 05DF 80 DUP1 05E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @05E0 revert(memory[0x00:0x00]); } // Block terminates label_05E1: // Incoming jump from 0x05DC, if !msg.value // Inputs[1] { @05E5 storage[0x19] } 05E1 5B JUMPDEST 05E2 50 POP 05E3 60 PUSH1 0x19 05E5 54 SLOAD 05E6 61 PUSH2 0x02b8 05E9 90 SWAP1 05EA 60 PUSH1 0xff 05EC 16 AND 05ED 81 DUP2 05EE 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05E9 stack[-1] = 0x02b8 // @05EC stack[0] = 0xff & storage[0x19] // } // Block ends with unconditional jump to 0x02b8 label_05EF: // Incoming jump from 0x014A, if 0x8da5cb5b == stack[-1] // Inputs[1] { @05F0 msg.value } 05EF 5B JUMPDEST 05F0 34 CALLVALUE 05F1 80 DUP1 05F2 15 ISZERO 05F3 61 PUSH2 0x05fb 05F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F0 stack[0] = msg.value } // Block ends with conditional jump to 0x05fb, if !msg.value label_05F7: // Incoming jump from 0x05F6, if not !msg.value // Inputs[1] { @05FA memory[0x00:0x00] } 05F7 60 PUSH1 0x00 05F9 80 DUP1 05FA FD *REVERT // Stack delta = +0 // Outputs[1] { @05FA revert(memory[0x00:0x00]); } // Block terminates label_05FB: // Incoming jump from 0x05F6, if !msg.value // Inputs[1] { @05FF storage[0x07] } 05FB 5B JUMPDEST 05FC 50 POP 05FD 60 PUSH1 0x07 05FF 54 SLOAD 0600 60 PUSH1 0x01 0602 60 PUSH1 0x01 0604 60 PUSH1 0xa0 0606 1B SHL 0607 03 SUB 0608 16 AND 0609 61 PUSH2 0x0331 060C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0608 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with unconditional jump to 0x0331 label_060D: // Incoming jump from 0x0155, if 0x912af0ce == stack[-1] // Inputs[1] { @060E msg.value } 060D 5B JUMPDEST 060E 34 CALLVALUE 060F 80 DUP1 0610 15 ISZERO 0611 61 PUSH2 0x0619 0614 57 *JUMPI // Stack delta = +1 // Outputs[1] { @060E stack[0] = msg.value } // Block ends with conditional jump to 0x0619, if !msg.value label_0615: // Incoming jump from 0x0614, if not !msg.value // Inputs[1] { @0618 memory[0x00:0x00] } 0615 60 PUSH1 0x00 0617 80 DUP1 0618 FD *REVERT // Stack delta = +0 // Outputs[1] { @0618 revert(memory[0x00:0x00]); } // Block terminates label_0619: // Incoming jump from 0x0614, if !msg.value 0619 5B JUMPDEST 061A 50 POP 061B 61 PUSH2 0x02ed 061E 61 PUSH2 0x12a0 0621 56 *JUMP // Stack delta = +0 // Outputs[1] { @061B stack[-1] = 0x02ed } // Block ends with call to 0x12a0, returns to 0x02ED label_0622: // Incoming jump from 0x00D7, if 0x95d89b41 == stack[-1] // Inputs[1] { @0623 msg.value } 0622 5B JUMPDEST 0623 34 CALLVALUE 0624 80 DUP1 0625 15 ISZERO 0626 61 PUSH2 0x062e 0629 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0623 stack[0] = msg.value } // Block ends with conditional jump to 0x062e, if !msg.value label_062A: // Incoming jump from 0x0629, if not !msg.value // Inputs[1] { @062D memory[0x00:0x00] } 062A 60 PUSH1 0x00 062C 80 DUP1 062D FD *REVERT // Stack delta = +0 // Outputs[1] { @062D revert(memory[0x00:0x00]); } // Block terminates label_062E: // Incoming jump from 0x0629, if !msg.value 062E 5B JUMPDEST 062F 50 POP 0630 61 PUSH2 0x0304 0633 61 PUSH2 0x1318 0636 56 *JUMP // Stack delta = +0 // Outputs[1] { @0630 stack[-1] = 0x0304 } // Block ends with call to 0x1318, returns to 0x0304 label_0637: // Incoming jump from 0x00E2, if 0x962ef00d == stack[-1] // Inputs[1] { @0638 msg.value } 0637 5B JUMPDEST 0638 34 CALLVALUE 0639 80 DUP1 063A 15 ISZERO 063B 61 PUSH2 0x0643 063E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0638 stack[0] = msg.value } // Block ends with conditional jump to 0x0643, if !msg.value label_063F: // Incoming jump from 0x063E, if not !msg.value // Inputs[1] { @0642 memory[0x00:0x00] } 063F 60 PUSH1 0x00 0641 80 DUP1 0642 FD *REVERT // Stack delta = +0 // Outputs[1] { @0642 revert(memory[0x00:0x00]); } // Block terminates label_0643: // Incoming jump from 0x063E, if !msg.value 0643 5B JUMPDEST 0644 50 POP 0645 61 PUSH2 0x0304 0648 61 PUSH2 0x1327 064B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0645 stack[-1] = 0x0304 } // Block ends with call to 0x1327, returns to 0x0304 label_064C: // Incoming jump from 0x00ED, if 0x9abc8320 == stack[-1] // Inputs[1] { @064D msg.value } 064C 5B JUMPDEST 064D 34 CALLVALUE 064E 80 DUP1 064F 15 ISZERO 0650 61 PUSH2 0x0658 0653 57 *JUMPI // Stack delta = +1 // Outputs[1] { @064D stack[0] = msg.value } // Block ends with conditional jump to 0x0658, if !msg.value label_0654: // Incoming jump from 0x0653, if not !msg.value // Inputs[1] { @0657 memory[0x00:0x00] } 0654 60 PUSH1 0x00 0656 80 DUP1 0657 FD *REVERT // Stack delta = +0 // Outputs[1] { @0657 revert(memory[0x00:0x00]); } // Block terminates label_0658: // Incoming jump from 0x0653, if !msg.value 0658 5B JUMPDEST 0659 50 POP 065A 61 PUSH2 0x0304 065D 61 PUSH2 0x13b5 0660 56 *JUMP // Stack delta = +0 // Outputs[1] { @065A stack[-1] = 0x0304 } // Block ends with call to 0x13b5, returns to 0x0304 label_0661: // Incoming jump from 0x00F8, if 0xa10866ef == stack[-1] // Inputs[1] { @0662 msg.value } 0661 5B JUMPDEST 0662 34 CALLVALUE 0663 80 DUP1 0664 15 ISZERO 0665 61 PUSH2 0x066d 0668 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0662 stack[0] = msg.value } // Block ends with conditional jump to 0x066d, if !msg.value label_0669: // Incoming jump from 0x0668, if not !msg.value // Inputs[1] { @066C memory[0x00:0x00] } 0669 60 PUSH1 0x00 066B 80 DUP1 066C FD *REVERT // Stack delta = +0 // Outputs[1] { @066C revert(memory[0x00:0x00]); } // Block terminates label_066D: // Incoming jump from 0x0668, if !msg.value 066D 5B JUMPDEST 066E 50 POP 066F 61 PUSH2 0x02ed 0672 61 PUSH2 0x13c2 0675 56 *JUMP // Stack delta = +0 // Outputs[1] { @066F stack[-1] = 0x02ed } // Block ends with call to 0x13c2, returns to 0x02ED label_0676: // Incoming jump from 0x0103, if 0xa22cb465 == stack[-1] // Inputs[1] { @0677 msg.value } 0676 5B JUMPDEST 0677 34 CALLVALUE 0678 80 DUP1 0679 15 ISZERO 067A 61 PUSH2 0x0682 067D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0677 stack[0] = msg.value } // Block ends with conditional jump to 0x0682, if !msg.value label_067E: // Incoming jump from 0x067D, if not !msg.value // Inputs[1] { @0681 memory[0x00:0x00] } 067E 60 PUSH1 0x00 0680 80 DUP1 0681 FD *REVERT // Stack delta = +0 // Outputs[1] { @0681 revert(memory[0x00:0x00]); } // Block terminates label_0682: // Incoming jump from 0x067D, if !msg.value // Inputs[1] { @068A msg.data.length } 0682 5B JUMPDEST 0683 50 POP 0684 61 PUSH2 0x02ed 0687 61 PUSH2 0x0691 068A 36 CALLDATASIZE 068B 60 PUSH1 0x04 068D 61 PUSH2 0x27e6 0690 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0684 stack[-1] = 0x02ed // @0687 stack[0] = 0x0691 // @068A stack[1] = msg.data.length // @068B stack[2] = 0x04 // } // Block ends with call to 0x27e6, returns to 0x0691 label_0691: // Incoming return from call to 0x27E6 at 0x0690 0691 5B JUMPDEST 0692 61 PUSH2 0x141e 0695 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x141e label_0696: // Incoming jump from 0x010E, if 0xadfdeef9 == stack[-1] // Inputs[1] { @0697 msg.value } 0696 5B JUMPDEST 0697 34 CALLVALUE 0698 80 DUP1 0699 15 ISZERO 069A 61 PUSH2 0x06a2 069D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0697 stack[0] = msg.value } // Block ends with conditional jump to 0x06a2, if !msg.value label_069E: // Incoming jump from 0x069D, if not !msg.value // Inputs[1] { @06A1 memory[0x00:0x00] } 069E 60 PUSH1 0x00 06A0 80 DUP1 06A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A1 revert(memory[0x00:0x00]); } // Block terminates label_06A2: // Incoming jump from 0x069D, if !msg.value // Inputs[1] { @06AA msg.data.length } 06A2 5B JUMPDEST 06A3 50 POP 06A4 61 PUSH2 0x02ed 06A7 61 PUSH2 0x06b1 06AA 36 CALLDATASIZE 06AB 60 PUSH1 0x04 06AD 61 PUSH2 0x2583 06B0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06A4 stack[-1] = 0x02ed // @06A7 stack[0] = 0x06b1 // @06AA stack[1] = msg.data.length // @06AB stack[2] = 0x04 // } // Block ends with call to 0x2583, returns to 0x06B1 label_06B1: // Incoming return from call to 0x2583 at 0x06B0 06B1 5B JUMPDEST 06B2 61 PUSH2 0x14b4 06B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x14b4 label_06B6: // Incoming jump from 0x0085, if 0xb88d4fde == stack[-1] // Inputs[1] { @06B7 msg.value } 06B6 5B JUMPDEST 06B7 34 CALLVALUE 06B8 80 DUP1 06B9 15 ISZERO 06BA 61 PUSH2 0x06c2 06BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06B7 stack[0] = msg.value } // Block ends with conditional jump to 0x06c2, if !msg.value label_06BE: // Incoming jump from 0x06BD, if not !msg.value // Inputs[1] { @06C1 memory[0x00:0x00] } 06BE 60 PUSH1 0x00 06C0 80 DUP1 06C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @06C1 revert(memory[0x00:0x00]); } // Block terminates label_06C2: // Incoming jump from 0x06BD, if !msg.value // Inputs[1] { @06CA msg.data.length } 06C2 5B JUMPDEST 06C3 50 POP 06C4 61 PUSH2 0x02ed 06C7 61 PUSH2 0x06d1 06CA 36 CALLDATASIZE 06CB 60 PUSH1 0x04 06CD 61 PUSH2 0x2824 06D0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06C4 stack[-1] = 0x02ed // @06C7 stack[0] = 0x06d1 // @06CA stack[1] = msg.data.length // @06CB stack[2] = 0x04 // } // Block ends with call to 0x2824, returns to 0x06D1 label_06D1: // Incoming return from call to 0x2824 at 0x06D0 06D1 5B JUMPDEST 06D2 61 PUSH2 0x1515 06D5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1515 label_06D6: // Incoming jump from 0x0090, if 0xbfa457bc == stack[-1] // Inputs[1] { @06D7 msg.value } 06D6 5B JUMPDEST 06D7 34 CALLVALUE 06D8 80 DUP1 06D9 15 ISZERO 06DA 61 PUSH2 0x06e2 06DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06D7 stack[0] = msg.value } // Block ends with conditional jump to 0x06e2, if !msg.value label_06DE: // Incoming jump from 0x06DD, if not !msg.value // Inputs[1] { @06E1 memory[0x00:0x00] } 06DE 60 PUSH1 0x00 06E0 80 DUP1 06E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E1 revert(memory[0x00:0x00]); } // Block terminates label_06E2: // Incoming jump from 0x06DD, if !msg.value // Inputs[1] { @06EA msg.data.length } 06E2 5B JUMPDEST 06E3 50 POP 06E4 61 PUSH2 0x02ed 06E7 61 PUSH2 0x06f1 06EA 36 CALLDATASIZE 06EB 60 PUSH1 0x04 06ED 61 PUSH2 0x28a4 06F0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06E4 stack[-1] = 0x02ed // @06E7 stack[0] = 0x06f1 // @06EA stack[1] = msg.data.length // @06EB stack[2] = 0x04 // } // Block ends with call to 0x28a4, returns to 0x06F1 label_06F1: // Incoming return from call to 0x28A4 at 0x06F0 06F1 5B JUMPDEST 06F2 61 PUSH2 0x1549 06F5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1549 label_06F6: // Incoming jump from 0x009B, if 0xc87b56dd == stack[-1] // Inputs[1] { @06F7 msg.value } 06F6 5B JUMPDEST 06F7 34 CALLVALUE 06F8 80 DUP1 06F9 15 ISZERO 06FA 61 PUSH2 0x0702 06FD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06F7 stack[0] = msg.value } // Block ends with conditional jump to 0x0702, if !msg.value label_06FE: // Incoming jump from 0x06FD, if not !msg.value // Inputs[1] { @0701 memory[0x00:0x00] } 06FE 60 PUSH1 0x00 0700 80 DUP1 0701 FD *REVERT // Stack delta = +0 // Outputs[1] { @0701 revert(memory[0x00:0x00]); } // Block terminates label_0702: // Incoming jump from 0x06FD, if !msg.value // Inputs[1] { @070A msg.data.length } 0702 5B JUMPDEST 0703 50 POP 0704 61 PUSH2 0x0304 0707 61 PUSH2 0x0711 070A 36 CALLDATASIZE 070B 60 PUSH1 0x04 070D 61 PUSH2 0x260b 0710 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0704 stack[-1] = 0x0304 // @0707 stack[0] = 0x0711 // @070A stack[1] = msg.data.length // @070B stack[2] = 0x04 // } // Block ends with call to 0x260b, returns to 0x0711 label_0711: // Incoming return from call to 0x260B at 0x0710 0711 5B JUMPDEST 0712 61 PUSH2 0x1638 0715 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1638 label_0716: // Incoming jump from 0x00A6, if 0xcd7c0326 == stack[-1] // Inputs[1] { @0717 msg.value } 0716 5B JUMPDEST 0717 34 CALLVALUE 0718 80 DUP1 0719 15 ISZERO 071A 61 PUSH2 0x0722 071D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0717 stack[0] = msg.value } // Block ends with conditional jump to 0x0722, if !msg.value label_071E: // Incoming jump from 0x071D, if not !msg.value // 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 jump from 0x071D, if !msg.value // Inputs[1] { @0726 storage[0x0d] } 0722 5B JUMPDEST 0723 50 POP 0724 60 PUSH1 0x0d 0726 54 SLOAD 0727 61 PUSH2 0x0331 072A 90 SWAP1 072B 60 PUSH1 0x01 072D 60 PUSH1 0x01 072F 60 PUSH1 0xa0 0731 1B SHL 0732 03 SUB 0733 16 AND 0734 81 DUP2 0735 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @072A stack[-1] = 0x0331 // @0733 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // } // Block ends with unconditional jump to 0x0331 label_0736: // Incoming jump from 0x00B1, if 0xd0ebdbe7 == stack[-1] // Inputs[1] { @0737 msg.value } 0736 5B JUMPDEST 0737 34 CALLVALUE 0738 80 DUP1 0739 15 ISZERO 073A 61 PUSH2 0x0742 073D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0737 stack[0] = msg.value } // Block ends with conditional jump to 0x0742, if !msg.value label_073E: // Incoming jump from 0x073D, if not !msg.value // Inputs[1] { @0741 memory[0x00:0x00] } 073E 60 PUSH1 0x00 0740 80 DUP1 0741 FD *REVERT // Stack delta = +0 // Outputs[1] { @0741 revert(memory[0x00:0x00]); } // Block terminates label_0742: // Incoming jump from 0x073D, if !msg.value // Inputs[1] { @074A msg.data.length } 0742 5B JUMPDEST 0743 50 POP 0744 61 PUSH2 0x02ed 0747 61 PUSH2 0x0751 074A 36 CALLDATASIZE 074B 60 PUSH1 0x04 074D 61 PUSH2 0x2583 0750 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0744 stack[-1] = 0x02ed // @0747 stack[0] = 0x0751 // @074A stack[1] = msg.data.length // @074B stack[2] = 0x04 // } // Block ends with call to 0x2583, returns to 0x0751 label_0751: // Incoming return from call to 0x2583 at 0x0750 0751 5B JUMPDEST 0752 61 PUSH2 0x166c 0755 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x166c label_0756: // Incoming jump from 0x00BC, if 0xd5abeb01 == stack[-1] // Inputs[1] { @0757 msg.value } 0756 5B JUMPDEST 0757 34 CALLVALUE 0758 80 DUP1 0759 15 ISZERO 075A 61 PUSH2 0x0762 075D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0757 stack[0] = msg.value } // Block ends with conditional jump to 0x0762, if !msg.value label_075E: // Incoming jump from 0x075D, if not !msg.value // Inputs[1] { @0761 memory[0x00:0x00] } 075E 60 PUSH1 0x00 0760 80 DUP1 0761 FD *REVERT // Stack delta = +0 // Outputs[1] { @0761 revert(memory[0x00:0x00]); } // Block terminates label_0762: // Incoming jump from 0x075D, if !msg.value 0762 5B JUMPDEST 0763 50 POP 0764 61 PUSH2 0x037e 0767 61 PUSH2 0x2710 076A 81 DUP2 076B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0764 stack[-1] = 0x037e // @0767 stack[0] = 0x2710 // } // Block ends with unconditional jump to 0x037e label_076C: // Incoming jump from 0x003E, if 0xdc53fd92 == stack[-1] // Inputs[1] { @076D msg.value } 076C 5B JUMPDEST 076D 34 CALLVALUE 076E 80 DUP1 076F 15 ISZERO 0770 61 PUSH2 0x0778 0773 57 *JUMPI // Stack delta = +1 // Outputs[1] { @076D stack[0] = msg.value } // Block ends with conditional jump to 0x0778, if !msg.value label_0774: // Incoming jump from 0x0773, if not !msg.value // Inputs[1] { @0777 memory[0x00:0x00] } 0774 60 PUSH1 0x00 0776 80 DUP1 0777 FD *REVERT // Stack delta = +0 // Outputs[1] { @0777 revert(memory[0x00:0x00]); } // Block terminates label_0778: // Incoming jump from 0x0773, if !msg.value 0778 5B JUMPDEST 0779 50 POP 077A 61 PUSH2 0x037e 077D 66 PUSH7 0xd529ae9e860000 0785 81 DUP2 0786 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @077A stack[-1] = 0x037e // @077D stack[0] = 0xd529ae9e860000 // } // Block ends with unconditional jump to 0x037e label_0787: // Incoming jump from 0x0049, if 0xdca17145 == stack[-1] // Inputs[1] { @0788 msg.value } 0787 5B JUMPDEST 0788 34 CALLVALUE 0789 80 DUP1 078A 15 ISZERO 078B 61 PUSH2 0x0793 078E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0788 stack[0] = msg.value } // Block ends with conditional jump to 0x0793, if !msg.value label_078F: // Incoming jump from 0x078E, if not !msg.value // Inputs[1] { @0792 memory[0x00:0x00] } 078F 60 PUSH1 0x00 0791 80 DUP1 0792 FD *REVERT // Stack delta = +0 // Outputs[1] { @0792 revert(memory[0x00:0x00]); } // Block terminates label_0793: // Incoming jump from 0x078E, if !msg.value 0793 5B JUMPDEST 0794 50 POP 0795 61 PUSH2 0x037e 0798 66 PUSH7 0x8e1bc9bf040000 07A0 81 DUP2 07A1 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0795 stack[-1] = 0x037e // @0798 stack[0] = 0x8e1bc9bf040000 // } // Block ends with unconditional jump to 0x037e label_07A2: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @07A3 msg.value } 07A2 5B JUMPDEST 07A3 34 CALLVALUE 07A4 80 DUP1 07A5 15 ISZERO 07A6 61 PUSH2 0x07ae 07A9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07A3 stack[0] = msg.value } // Block ends with conditional jump to 0x07ae, if !msg.value label_07AA: // Incoming jump from 0x07A9, if not !msg.value // Inputs[1] { @07AD memory[0x00:0x00] } 07AA 60 PUSH1 0x00 07AC 80 DUP1 07AD FD *REVERT // Stack delta = +0 // Outputs[1] { @07AD revert(memory[0x00:0x00]); } // Block terminates label_07AE: // Incoming jump from 0x07A9, if !msg.value // Inputs[1] { @07B6 msg.data.length } 07AE 5B JUMPDEST 07AF 50 POP 07B0 61 PUSH2 0x02b8 07B3 61 PUSH2 0x07bd 07B6 36 CALLDATASIZE 07B7 60 PUSH1 0x04 07B9 61 PUSH2 0x28c9 07BC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07B0 stack[-1] = 0x02b8 // @07B3 stack[0] = 0x07bd // @07B6 stack[1] = msg.data.length // @07B7 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x28c9 07BD 5B JUMPDEST 07BE 61 PUSH2 0x16cd 07C1 56 *JUMP label_07C2: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @07C3 msg.value } 07C2 5B JUMPDEST 07C3 34 CALLVALUE 07C4 80 DUP1 07C5 15 ISZERO 07C6 61 PUSH2 0x07ce 07C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07C3 stack[0] = msg.value } // Block ends with conditional jump to 0x07ce, if !msg.value label_07CA: // Incoming jump from 0x07C9, if not !msg.value // Inputs[1] { @07CD memory[0x00:0x00] } 07CA 60 PUSH1 0x00 07CC 80 DUP1 07CD FD *REVERT // Stack delta = +0 // Outputs[1] { @07CD revert(memory[0x00:0x00]); } // Block terminates label_07CE: // Incoming jump from 0x07C9, if !msg.value // Inputs[1] { @07D6 msg.data.length } 07CE 5B JUMPDEST 07CF 50 POP 07D0 61 PUSH2 0x02ed 07D3 61 PUSH2 0x07dd 07D6 36 CALLDATASIZE 07D7 60 PUSH1 0x04 07D9 61 PUSH2 0x2583 07DC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @07D0 stack[-1] = 0x02ed // @07D3 stack[0] = 0x07dd // @07D6 stack[1] = msg.data.length // @07D7 stack[2] = 0x04 // } // Block ends with call to 0x2583, returns to 0x07DD label_07DD: // Incoming return from call to 0x2583 at 0x07DC 07DD 5B JUMPDEST 07DE 61 PUSH2 0x178e 07E1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x178e label_07E2: // Incoming jump from 0x006A, if 0xf8dc92c6 == stack[-1] // Inputs[1] { @07E3 msg.value } 07E2 5B JUMPDEST 07E3 34 CALLVALUE 07E4 80 DUP1 07E5 15 ISZERO 07E6 61 PUSH2 0x07ee 07E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07E3 stack[0] = msg.value } // Block ends with conditional jump to 0x07ee, if !msg.value label_07EA: // Incoming jump from 0x07E9, if not !msg.value // Inputs[1] { @07ED memory[0x00:0x00] } 07EA 60 PUSH1 0x00 07EC 80 DUP1 07ED FD *REVERT // Stack delta = +0 // Outputs[1] { @07ED revert(memory[0x00:0x00]); } // Block terminates label_07EE: // Incoming jump from 0x07E9, if !msg.value 07EE 5B JUMPDEST 07EF 50 POP 07F0 61 PUSH2 0x037e 07F3 66 PUSH7 0xb1a2bc2ec50000 07FB 81 DUP2 07FC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @07F0 stack[-1] = 0x037e // @07F3 stack[0] = 0xb1a2bc2ec50000 // } // Block ends with unconditional jump to 0x037e label_07FD: // Incoming jump from 0x0075, if 0xf968adbe == stack[-1] // Inputs[1] { @07FE msg.value } 07FD 5B JUMPDEST 07FE 34 CALLVALUE 07FF 80 DUP1 0800 15 ISZERO 0801 61 PUSH2 0x0809 0804 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07FE stack[0] = msg.value } // Block ends with conditional jump to 0x0809, if !msg.value label_0805: // Incoming jump from 0x0804, if not !msg.value // Inputs[1] { @0808 memory[0x00:0x00] } 0805 60 PUSH1 0x00 0807 80 DUP1 0808 FD *REVERT // Stack delta = +0 // Outputs[1] { @0808 revert(memory[0x00:0x00]); } // Block terminates label_0809: // Incoming jump from 0x0804, if !msg.value // Inputs[1] { @0810 storage[0x0a] } 0809 5B JUMPDEST 080A 50 POP 080B 61 PUSH2 0x037e 080E 60 PUSH1 0x0a 0810 54 SLOAD 0811 81 DUP2 0812 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @080B stack[-1] = 0x037e // @0810 stack[0] = storage[0x0a] // } // Block ends with unconditional jump to 0x037e label_0813: // Incoming jump from 0x02B7 // Inputs[1] { @081F stack[-1] } 0813 5B JUMPDEST 0814 60 PUSH1 0x00 0816 60 PUSH1 0x01 0818 60 PUSH1 0x01 081A 60 PUSH1 0xe0 081C 1B SHL 081D 03 SUB 081E 19 NOT 081F 82 DUP3 0820 16 AND 0821 63 PUSH4 0x80ac58cd 0826 60 PUSH1 0xe0 0828 1B SHL 0829 14 EQ 082A 80 DUP1 082B 61 PUSH2 0x0844 082E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0814 stack[0] = 0x00 // @0829 stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0844, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_082F: // Incoming jump from 0x082E, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0839 stack[-3] } 082F 50 POP 0830 60 PUSH1 0x01 0832 60 PUSH1 0x01 0834 60 PUSH1 0xe0 0836 1B SHL 0837 03 SUB 0838 19 NOT 0839 82 DUP3 083A 16 AND 083B 63 PUSH4 0x5b5e139f 0840 60 PUSH1 0xe0 0842 1B SHL 0843 14 EQ 0844 5B JUMPDEST 0845 80 DUP1 0846 61 PUSH2 0x085f 0849 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0843 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x085f, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_084A: // Incoming jump from 0x0849, if not stack[-1] // Incoming jump from 0x0849, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0854 stack[-3] } 084A 50 POP 084B 60 PUSH1 0x01 084D 60 PUSH1 0x01 084F 60 PUSH1 0xe0 0851 1B SHL 0852 03 SUB 0853 19 NOT 0854 82 DUP3 0855 16 AND 0856 63 PUSH4 0x780e9d63 085B 60 PUSH1 0xe0 085D 1B SHL 085E 14 EQ 085F 5B JUMPDEST 0860 80 DUP1 0861 61 PUSH2 0x087a 0864 57 *JUMPI // Stack delta = +0 // Outputs[1] { @085E stack[-1] = 0x780e9d63 << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x087a, if 0x780e9d63 << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0865: // Incoming jump from 0x0864, if not 0x780e9d63 << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0864, if not stack[-1] // Inputs[1] { @0877 stack[-3] } 0865 50 POP 0866 63 PUSH4 0x01ffc9a7 086B 60 PUSH1 0xe0 086D 1B SHL 086E 60 PUSH1 0x01 0870 60 PUSH1 0x01 0872 60 PUSH1 0xe0 0874 1B SHL 0875 03 SUB 0876 19 NOT 0877 83 DUP4 0878 16 AND 0879 14 EQ // Stack delta = +0 // Outputs[1] { @0879 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block continues label_087A: // Incoming jump from 0x0864, if 0x780e9d63 << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x1862, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x0DDC // Incoming jump from 0x0879 // Incoming jump from 0x0864, if stack[-1] // Inputs[3] // { // @087B stack[-4] // @087B stack[-1] // @087C stack[-3] // } 087A 5B JUMPDEST 087B 92 SWAP3 087C 91 SWAP2 087D 50 POP 087E 50 POP 087F 56 *JUMP // Stack delta = -3 // Outputs[1] { @087B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0880: // Incoming jump from 0x02EC // Inputs[2] // { // @0883 storage[0x07] // @088D msg.sender // } 0880 5B JUMPDEST 0881 60 PUSH1 0x07 0883 54 SLOAD 0884 60 PUSH1 0x01 0886 60 PUSH1 0x01 0888 60 PUSH1 0xa0 088A 1B SHL 088B 03 SUB 088C 16 AND 088D 33 CALLER 088E 14 EQ 088F 80 DUP1 0890 61 PUSH2 0x08a3 0893 57 *JUMPI // Stack delta = +1 // Outputs[1] { @088E stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x08a3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0894: // Incoming jump from 0x0893, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @0897 storage[0x0e] // @08A1 msg.sender // } 0894 50 POP 0895 60 PUSH1 0x0e 0897 54 SLOAD 0898 60 PUSH1 0x01 089A 60 PUSH1 0x01 089C 60 PUSH1 0xa0 089E 1B SHL 089F 03 SUB 08A0 16 AND 08A1 33 CALLER 08A2 14 EQ 08A3 5B JUMPDEST 08A4 61 PUSH2 0x08c8 08A7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08c8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_08A8: // Incoming jump from 0x08A7, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x08A7, if not stack[-1] // Inputs[1] { @08AA memory[0x40:0x60] } 08A8 60 PUSH1 0x40 08AA 51 MLOAD 08AB 62 PUSH3 0x461bcd 08AF 60 PUSH1 0xe5 08B1 1B SHL 08B2 81 DUP2 08B3 52 MSTORE 08B4 60 PUSH1 0x04 08B6 01 ADD 08B7 61 PUSH2 0x08bf 08BA 90 SWAP1 08BB 61 PUSH2 0x28f7 08BE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08BA stack[0] = 0x08bf // @08BA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_08BF: // Incoming return from call to 0x28F7 at 0x1587 // Incoming return from call to 0x28F7 at 0x0ED9 // Incoming jump from 0x0FA6 // Incoming jump from 0x10E3 // Incoming jump from 0x0B2A // Incoming return from call to 0x2969 at 0x0FD4 // Incoming return from call to 0x29B9 at 0x0AA8 // Incoming jump from 0x2236 // Incoming jump from 0x0CB3 // Incoming return from call to 0x28F7 at 0x1400 // Incoming return from call to 0x28F7 at 0x0BFF // Incoming return from call to 0x2A10 at 0x0D1B // Incoming return from call to 0x28F7 at 0x0E3D // Incoming jump from 0x215C // Incoming jump from 0x108D // Incoming jump from 0x21C9 // Incoming return from call to 0x28F7 at 0x12DE // Incoming jump from 0x1615 // Incoming jump from 0x17E7 // Incoming jump from 0x1CBA // Incoming jump from 0x20FA // Incoming jump from 0x0C7A // Incoming jump from 0x184C // Incoming return from call to 0x28F7 at 0x11AD // Incoming return from call to 0x2A10 at 0x114F // Incoming return from call to 0x29B9 at 0x15C0 // Incoming return from call to 0x2A10 at 0x111B // Incoming jump from 0x0B80 // Incoming return from call to 0x2969 at 0x0A6F // Incoming return from call to 0x2969 at 0x0C3D // Incoming return from call to 0x28F7 at 0x16AA // Incoming return from call to 0x28F7 at 0x14F2 // Incoming return from call to 0x29B9 at 0x0CEC // Incoming return from call to 0x28F7 at 0x08BE // Incoming return from call to 0x29B9 at 0x100D // Inputs[3] // { // @08C2 memory[0x40:0x60] // @08C4 stack[-1] // @08C7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 08BF 5B JUMPDEST 08C0 60 PUSH1 0x40 08C2 51 MLOAD 08C3 80 DUP1 08C4 91 SWAP2 08C5 03 SUB 08C6 90 SWAP1 08C7 FD *REVERT // Stack delta = -1 // Outputs[1] { @08C7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_08C8: // Incoming jump from 0x08A7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x08A7, if stack[-1] // Inputs[3] // { // @08CC storage[0x0c] // @08DF stack[-1] // @08E9 stack[-2] // } 08C8 5B JUMPDEST 08C9 60 PUSH1 0x0c 08CB 80 DUP1 08CC 54 SLOAD 08CD 60 PUSH1 0x01 08CF 60 PUSH1 0x01 08D1 60 PUSH1 0xa0 08D3 1B SHL 08D4 03 SUB 08D5 19 NOT 08D6 16 AND 08D7 60 PUSH1 0x01 08D9 60 PUSH1 0x01 08DB 60 PUSH1 0xa0 08DD 1B SHL 08DE 03 SUB 08DF 92 SWAP3 08E0 90 SWAP1 08E1 92 SWAP3 08E2 16 AND 08E3 91 SWAP2 08E4 90 SWAP1 08E5 91 SWAP2 08E6 17 OR 08E7 90 SWAP1 08E8 55 SSTORE 08E9 56 *JUMP // Stack delta = -2 // Outputs[1] { @08E8 storage[0x0c] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x0c]) } // Block ends with unconditional jump to stack[-2] label_08EA: // Incoming call from 0x0303, returns to 0x0304 // Inputs[1] { @08F0 storage[0x01] } 08EA 5B JUMPDEST 08EB 60 PUSH1 0x60 08ED 60 PUSH1 0x01 08EF 80 DUP1 08F0 54 SLOAD 08F1 61 PUSH2 0x08f9 08F4 90 SWAP1 08F5 61 PUSH2 0x292e 08F8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08EB stack[0] = 0x60 // @08ED stack[1] = 0x01 // @08F4 stack[2] = 0x08f9 // @08F4 stack[3] = storage[0x01] // } // Block ends with call to 0x292e, returns to 0x08F9 label_08F9: // Incoming return from call to 0x292E at 0x1F0D // Incoming return from call to 0x292E at 0x1326 // Incoming return from call to 0x292E at 0x08F8 // Inputs[4] // { // @08FA stack[-1] // @0909 memory[0x40:0x60] // @0911 stack[-2] // @091C storage[stack[-2]] // } 08F9 5B JUMPDEST 08FA 80 DUP1 08FB 60 PUSH1 0x1f 08FD 01 ADD 08FE 60 PUSH1 0x20 0900 80 DUP1 0901 91 SWAP2 0902 04 DIV 0903 02 MUL 0904 60 PUSH1 0x20 0906 01 ADD 0907 60 PUSH1 0x40 0909 51 MLOAD 090A 90 SWAP1 090B 81 DUP2 090C 01 ADD 090D 60 PUSH1 0x40 090F 52 MSTORE 0910 80 DUP1 0911 92 SWAP3 0912 91 SWAP2 0913 90 SWAP1 0914 81 DUP2 0915 81 DUP2 0916 52 MSTORE 0917 60 PUSH1 0x20 0919 01 ADD 091A 82 DUP3 091B 80 DUP1 091C 54 SLOAD 091D 61 PUSH2 0x0925 0920 90 SWAP1 0921 61 PUSH2 0x292e 0924 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @090F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0911 stack[-2] = memory[0x40:0x60] // @0912 stack[-1] = stack[-2] // @0913 stack[0] = stack[-1] // @0916 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0919 stack[1] = 0x20 + memory[0x40:0x60] // @091A stack[2] = stack[-2] // @0920 stack[4] = storage[stack[-2]] // @0920 stack[3] = 0x0925 // } // Block ends with call to 0x292e, returns to 0x0925 label_0925: // Incoming return from call to 0x292E at 0x0924 // Inputs[1] { @0926 stack[-1] } 0925 5B JUMPDEST 0926 80 DUP1 0927 15 ISZERO 0928 61 PUSH2 0x0972 092B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0972, if !stack[-1] label_092C: // Incoming jump from 0x092B, if not !stack[-1] // Inputs[1] { @092C stack[-1] } 092C 80 DUP1 092D 60 PUSH1 0x1f 092F 10 LT 0930 61 PUSH2 0x0947 0933 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0947, if 0x1f < stack[-1] label_0934: // Incoming jump from 0x0933, if not 0x1f < stack[-1] // Inputs[4] // { // @0938 stack[-2] // @0939 storage[stack[-2]] // @093C stack[-3] // @093E stack[-1] // } 0934 61 PUSH2 0x0100 0937 80 DUP1 0938 83 DUP4 0939 54 SLOAD 093A 04 DIV 093B 02 MUL 093C 83 DUP4 093D 52 MSTORE 093E 91 SWAP2 093F 60 PUSH1 0x20 0941 01 ADD 0942 91 SWAP2 0943 61 PUSH2 0x0972 0946 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @093D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0942 stack[-1] = stack[-1] // @0942 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0972 label_0947: // Incoming jump from 0x0933, if 0x1f < stack[-1] // Inputs[5] // { // @0948 stack[-3] // @0949 stack[-1] // @094B stack[-2] // @0953 memory[0x00:0x20] // @0957 storage[keccak256(memory[0x00:0x20])] // } 0947 5B JUMPDEST 0948 82 DUP3 0949 01 ADD 094A 91 SWAP2 094B 90 SWAP1 094C 60 PUSH1 0x00 094E 52 MSTORE 094F 60 PUSH1 0x20 0951 60 PUSH1 0x00 0953 20 SHA3 0954 90 SWAP1 0955 5B JUMPDEST 0956 81 DUP2 0957 54 SLOAD 0958 81 DUP2 0959 52 MSTORE 095A 90 SWAP1 095B 60 PUSH1 0x01 095D 01 ADD 095E 90 SWAP1 095F 60 PUSH1 0x20 0961 01 ADD 0962 80 DUP1 0963 83 DUP4 0964 11 GT 0965 61 PUSH2 0x0955 0968 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @094A stack[-3] = stack[-3] + stack[-1] // @094E memory[0x00:0x20] = stack[-2] // @0959 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @095E stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0961 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0955, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0969: // Incoming jump from 0x0968, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0968, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0969 stack[-3] // @096A stack[-1] // } 0969 82 DUP3 096A 90 SWAP1 096B 03 SUB 096C 60 PUSH1 0x1f 096E 16 AND 096F 82 DUP3 0970 01 ADD 0971 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0971 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0971 stack[-1] = stack[-3] // } // Block continues label_0972: // Incoming jump from 0x092B, if !stack[-1] // Incoming jump from 0x0946 // Incoming jump from 0x0971 // Inputs[3] // { // @0978 stack[-6] // @0978 stack[-7] // @097A stack[-8] // } 0972 5B JUMPDEST 0973 50 POP 0974 50 POP 0975 50 POP 0976 50 POP 0977 50 POP 0978 90 SWAP1 0979 50 POP 097A 90 SWAP1 097B 56 *JUMP // Stack delta = -7 // Outputs[1] { @097A stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_097C: // Incoming jump from 0x0330 // Incoming call from 0x194D, returns to 0x194E // Inputs[1] { @0982 stack[-1] } 097C 5B JUMPDEST 097D 60 PUSH1 0x00 097F 61 PUSH2 0x0987 0982 82 DUP3 0983 61 PUSH2 0x1856 0986 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @097D stack[0] = 0x00 // @097F stack[1] = 0x0987 // @0982 stack[2] = stack[-1] // } // Block ends with call to 0x1856, returns to 0x0987 label_0987: // Incoming return from call to 0x1856 at 0x0986 // Inputs[1] { @098B stack[-1] } 0987 5B JUMPDEST 0988 61 PUSH2 0x09a4 098B 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x09a4, if stack[-1] label_098C: // Incoming jump from 0x098B, if not stack[-1] // Inputs[3] // { // @098E memory[0x40:0x60] // @099E memory[0x40:0x60] // @09A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 098C 60 PUSH1 0x40 098E 51 MLOAD 098F 63 PUSH4 0x33d1c039 0994 60 PUSH1 0xe2 0996 1B SHL 0997 81 DUP2 0998 52 MSTORE 0999 60 PUSH1 0x04 099B 01 ADD 099C 60 PUSH1 0x40 099E 51 MLOAD 099F 80 DUP1 09A0 91 SWAP2 09A1 03 SUB 09A2 90 SWAP1 09A3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0998 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x33d1c039 << 0xe2 // @09A3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_09A4: // Incoming jump from 0x098B, if stack[-1] // Inputs[4] // { // @09A8 stack[-2] // @09B3 memory[0x00:0x40] // @09B4 storage[keccak256(memory[0x00:0x40])] // @09BE stack[-3] // } 09A4 5B JUMPDEST 09A5 50 POP 09A6 60 PUSH1 0x00 09A8 90 SWAP1 09A9 81 DUP2 09AA 52 MSTORE 09AB 60 PUSH1 0x05 09AD 60 PUSH1 0x20 09AF 52 MSTORE 09B0 60 PUSH1 0x40 09B2 90 SWAP1 09B3 20 SHA3 09B4 54 SLOAD 09B5 60 PUSH1 0x01 09B7 60 PUSH1 0x01 09B9 60 PUSH1 0xa0 09BB 1B SHL 09BC 03 SUB 09BD 16 AND 09BE 90 SWAP1 09BF 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @09AA memory[0x00:0x20] = stack[-2] // @09AF memory[0x20:0x40] = 0x05 // @09BE stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_09C0: // Incoming jump from 0x0368 // Inputs[1] { @09C6 stack[-1] } 09C0 5B JUMPDEST 09C1 60 PUSH1 0x00 09C3 61 PUSH2 0x09cb 09C6 82 DUP3 09C7 61 PUSH2 0x0eed 09CA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09C1 stack[0] = 0x00 // @09C3 stack[1] = 0x09cb // @09C6 stack[2] = stack[-1] // } // Block ends with call to 0x0eed, returns to 0x09CB label_09CB: // Incoming return from call to 0x0EED at 0x09CA // Inputs[3] // { // @09CC stack[-2] // @09CC stack[-1] // @09D8 stack[-4] // } 09CB 5B JUMPDEST 09CC 90 SWAP1 09CD 50 POP 09CE 80 DUP1 09CF 60 PUSH1 0x01 09D1 60 PUSH1 0x01 09D3 60 PUSH1 0xa0 09D5 1B SHL 09D6 03 SUB 09D7 16 AND 09D8 83 DUP4 09D9 60 PUSH1 0x01 09DB 60 PUSH1 0x01 09DD 60 PUSH1 0xa0 09DF 1B SHL 09E0 03 SUB 09E1 16 AND 09E2 14 EQ 09E3 15 ISZERO 09E4 61 PUSH2 0x0a00 09E7 57 *JUMPI // Stack delta = -1 // Outputs[1] { @09CC stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0a00, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_09E8: // Incoming jump from 0x09E7, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @09EA memory[0x40:0x60] // @09FA memory[0x40:0x60] // @09FF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09E8 60 PUSH1 0x40 09EA 51 MLOAD 09EB 63 PUSH4 0x250fdee3 09F0 60 PUSH1 0xe2 09F2 1B SHL 09F3 81 DUP2 09F4 52 MSTORE 09F5 60 PUSH1 0x04 09F7 01 ADD 09F8 60 PUSH1 0x40 09FA 51 MLOAD 09FB 80 DUP1 09FC 91 SWAP2 09FD 03 SUB 09FE 90 SWAP1 09FF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @09F4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x250fdee3 << 0xe2 // @09FF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A00: // Incoming jump from 0x09E7, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @0A01 msg.sender // @0A0A stack[-1] // } 0A00 5B JUMPDEST 0A01 33 CALLER 0A02 60 PUSH1 0x01 0A04 60 PUSH1 0x01 0A06 60 PUSH1 0xa0 0A08 1B SHL 0A09 03 SUB 0A0A 82 DUP3 0A0B 16 AND 0A0C 14 EQ 0A0D 80 DUP1 0A0E 15 ISZERO 0A0F 90 SWAP1 0A10 61 PUSH2 0x0a20 0A13 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A0F stack[0] = !(stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender) } // Block ends with conditional jump to 0x0a20, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0A14: // Incoming jump from 0x0A13, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0A18 stack[-2] // @0A19 msg.sender // } 0A14 50 POP 0A15 61 PUSH2 0x0a1e 0A18 81 DUP2 0A19 33 CALLER 0A1A 61 PUSH2 0x16cd 0A1D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A15 stack[-1] = 0x0a1e // @0A18 stack[0] = stack[-2] // @0A19 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x16cd 0A1E 5B JUMPDEST 0A1F 15 ISZERO label_0A20: // Incoming jump from 0x0A13, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[1] { @0A21 stack[-1] } 0A20 5B JUMPDEST 0A21 15 ISZERO 0A22 61 PUSH2 0x0a3e 0A25 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a3e, if !stack[-1] label_0A26: // Incoming jump from 0x0A25, if not !stack[-1] // Inputs[3] // { // @0A28 memory[0x40:0x60] // @0A38 memory[0x40:0x60] // @0A3D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A26 60 PUSH1 0x40 0A28 51 MLOAD 0A29 63 PUSH4 0x67d9dca1 0A2E 60 PUSH1 0xe1 0A30 1B SHL 0A31 81 DUP2 0A32 52 MSTORE 0A33 60 PUSH1 0x04 0A35 01 ADD 0A36 60 PUSH1 0x40 0A38 51 MLOAD 0A39 80 DUP1 0A3A 91 SWAP2 0A3B 03 SUB 0A3C 90 SWAP1 0A3D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A32 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x67d9dca1 << 0xe1 // @0A3D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0A3E: // Incoming jump from 0x0A25, if !stack[-1] // Inputs[3] // { // @0A42 stack[-3] // @0A43 stack[-2] // @0A44 stack[-1] // } 0A3E 5B JUMPDEST 0A3F 61 PUSH2 0x0a49 0A42 83 DUP4 0A43 83 DUP4 0A44 83 DUP4 0A45 61 PUSH2 0x186b 0A48 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A3F stack[0] = 0x0a49 // @0A42 stack[1] = stack[-3] // @0A43 stack[2] = stack[-2] // @0A44 stack[3] = stack[-1] // } // Block ends with call to 0x186b, returns to 0x0A49 label_0A49: // Incoming return from call to 0x186B at 0x0A48 // Incoming jump from 0x1C81, if stack[-3] // Incoming jump from 0x1C81, if stack[-3] // Incoming return from call to 0x2237 at 0x1EFE // Inputs[1] { @0A4D stack[-4] } 0A49 5B JUMPDEST 0A4A 50 POP 0A4B 50 POP 0A4C 50 POP 0A4D 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0A4E: // Incoming jump from 0x03AB // Inputs[1] { @0A51 storage[0x19] } 0A4E 5B JUMPDEST 0A4F 60 PUSH1 0x19 0A51 54 SLOAD 0A52 60 PUSH1 0xff 0A54 16 AND 0A55 61 PUSH2 0x0a70 0A58 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a70, if 0xff & storage[0x19] label_0A59: // Incoming jump from 0x0A58, if not 0xff & storage[0x19] // Inputs[1] { @0A5B memory[0x40:0x60] } 0A59 60 PUSH1 0x40 0A5B 51 MLOAD 0A5C 62 PUSH3 0x461bcd 0A60 60 PUSH1 0xe5 0A62 1B SHL 0A63 81 DUP2 0A64 52 MSTORE 0A65 60 PUSH1 0x04 0A67 01 ADD 0A68 61 PUSH2 0x08bf 0A6B 90 SWAP1 0A6C 61 PUSH2 0x2969 0A6F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A6B stack[0] = 0x08bf // @0A6B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2969, returns to 0x08BF label_0A70: // Incoming jump from 0x0A58, if 0xff & storage[0x19] // Inputs[2] // { // @0A74 stack[-4] // @0A7A storage[0x00] // } 0A70 5B JUMPDEST 0A71 61 PUSH2 0x2710 0A74 84 DUP5 0A75 61 PUSH2 0x0a81 0A78 60 PUSH1 0x00 0A7A 54 SLOAD 0A7B 60 PUSH1 0x00 0A7D 19 NOT 0A7E 01 ADD 0A7F 90 SWAP1 0A80 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A71 stack[0] = 0x2710 // @0A74 stack[1] = stack[-4] // @0A7F stack[2] = ~0x00 + storage[0x00] // } // Block ends with unconditional jump to 0x0a81 label_0A81: // Incoming jump from 0x0A80 // Inputs[2] // { // @0A85 stack[-2] // @0A86 stack[-1] // } 0A81 5B JUMPDEST 0A82 61 PUSH2 0x0a8b 0A85 91 SWAP2 0A86 90 SWAP1 0A87 61 PUSH2 0x29a1 0A8A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0A85 stack[-2] = 0x0a8b // @0A86 stack[-1] = stack[-2] // @0A86 stack[0] = stack[-1] // } // Block ends with call to 0x29a1, returns to 0x0A8B label_0A8B: // Incoming return from call to 0x29A1 at 0x0A8A // Inputs[2] // { // @0A8C stack[-2] // @0A8C stack[-1] // } 0A8B 5B JUMPDEST 0A8C 11 GT 0A8D 15 ISZERO 0A8E 61 PUSH2 0x0aa9 0A91 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0aa9, if !(stack[-1] > stack[-2]) label_0A92: // Incoming jump from 0x0A91, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0A94 memory[0x40:0x60] } 0A92 60 PUSH1 0x40 0A94 51 MLOAD 0A95 62 PUSH3 0x461bcd 0A99 60 PUSH1 0xe5 0A9B 1B SHL 0A9C 81 DUP2 0A9D 52 MSTORE 0A9E 60 PUSH1 0x04 0AA0 01 ADD 0AA1 61 PUSH2 0x08bf 0AA4 90 SWAP1 0AA5 61 PUSH2 0x29b9 0AA8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AA4 stack[0] = 0x08bf // @0AA4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29b9, returns to 0x08BF label_0AA9: // Incoming jump from 0x0A91, if !(stack[-1] > stack[-2]) // Inputs[5] // { // @0AAD stack[-2] // @0AAE stack[-1] // @0ABF memory[0x40:0x60] // @0AD6 msg.data[stack[-2]:stack[-2] + stack[-1]] // @0ADF stack[-3] // } 0AA9 5B JUMPDEST 0AAA 61 PUSH2 0x0aef 0AAD 82 DUP3 0AAE 82 DUP3 0AAF 80 DUP1 0AB0 80 DUP1 0AB1 60 PUSH1 0x1f 0AB3 01 ADD 0AB4 60 PUSH1 0x20 0AB6 80 DUP1 0AB7 91 SWAP2 0AB8 04 DIV 0AB9 02 MUL 0ABA 60 PUSH1 0x20 0ABC 01 ADD 0ABD 60 PUSH1 0x40 0ABF 51 MLOAD 0AC0 90 SWAP1 0AC1 81 DUP2 0AC2 01 ADD 0AC3 60 PUSH1 0x40 0AC5 52 MSTORE 0AC6 80 DUP1 0AC7 93 SWAP4 0AC8 92 SWAP3 0AC9 91 SWAP2 0ACA 90 SWAP1 0ACB 81 DUP2 0ACC 81 DUP2 0ACD 52 MSTORE 0ACE 60 PUSH1 0x20 0AD0 01 ADD 0AD1 83 DUP4 0AD2 83 DUP4 0AD3 80 DUP1 0AD4 82 DUP3 0AD5 84 DUP5 0AD6 37 CALLDATACOPY 0AD7 60 PUSH1 0x00 0AD9 92 SWAP3 0ADA 01 ADD 0ADB 82 DUP3 0ADC 90 SWAP1 0ADD 52 MSTORE 0ADE 50 POP 0ADF 88 DUP9 0AE0 93 SWAP4 0AE1 50 POP 0AE2 91 SWAP2 0AE3 50 POP 0AE4 61 PUSH2 0x0aea 0AE7 90 SWAP1 0AE8 50 POP 0AE9 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @0AAA stack[0] = 0x0aef // @0AC5 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0AC7 stack[1] = memory[0x40:0x60] // @0ACD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0AD6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @0ADD memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // @0AE0 stack[2] = stack[-3] // @0AE2 stack[3] = 0x00 // } // Block ends with call to 0x0aea, returns to 0x0AEF label_0AEA: // Incoming call from 0x1051, returns to 0x1052 // Incoming call from 0x0AE9, returns to 0x0AEF 0AEA 5B JUMPDEST 0AEB 61 PUSH2 0x18c7 0AEE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x18c7 label_0AEF: // Incoming return from call to 0x0AEA at 0x0AE9 // Inputs[1] { @0AF3 stack[-1] } 0AEF 5B JUMPDEST 0AF0 61 PUSH2 0x0b2b 0AF3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b2b, if stack[-1] label_0AF4: // Incoming jump from 0x0AF3, if not stack[-1] // Inputs[1] { @0AF6 memory[0x40:0x60] } 0AF4 60 PUSH1 0x40 0AF6 51 MLOAD 0AF7 62 PUSH3 0x461bcd 0AFB 60 PUSH1 0xe5 0AFD 1B SHL 0AFE 81 DUP2 0AFF 52 MSTORE 0B00 60 PUSH1 0x20 0B02 60 PUSH1 0x04 0B04 82 DUP3 0B05 01 ADD 0B06 52 MSTORE 0B07 60 PUSH1 0x0d 0B09 60 PUSH1 0x24 0B0B 82 DUP3 0B0C 01 ADD 0B0D 52 MSTORE 0B0E 6C PUSH13 0x626164207369676e6174757265 0B1C 60 PUSH1 0x98 0B1E 1B SHL 0B1F 60 PUSH1 0x44 0B21 82 DUP3 0B22 01 ADD 0B23 52 MSTORE 0B24 60 PUSH1 0x64 0B26 01 ADD 0B27 61 PUSH2 0x08bf 0B2A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0AFF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B06 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B0D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @0B23 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x626164207369676e6174757265 << 0x98 // @0B26 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_0B2B: // Incoming jump from 0x0AF3, if stack[-1] // Inputs[5] // { // @0B2C msg.sender // @0B3A memory[0x00:0x40] // @0B3B storage[keccak256(memory[0x00:0x40])] // @0B3C stack[-3] // @0B42 stack[-4] // } 0B2B 5B JUMPDEST 0B2C 33 CALLER 0B2D 60 PUSH1 0x00 0B2F 90 SWAP1 0B30 81 DUP2 0B31 52 MSTORE 0B32 60 PUSH1 0x09 0B34 60 PUSH1 0x20 0B36 52 MSTORE 0B37 60 PUSH1 0x40 0B39 90 SWAP1 0B3A 20 SHA3 0B3B 54 SLOAD 0B3C 83 DUP4 0B3D 90 SWAP1 0B3E 61 PUSH2 0x0b48 0B41 90 SWAP1 0B42 86 DUP7 0B43 90 SWAP1 0B44 61 PUSH2 0x29a1 0B47 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0B31 memory[0x00:0x20] = msg.sender // @0B36 memory[0x20:0x40] = 0x09 // @0B3D stack[0] = stack[-3] // @0B41 stack[1] = 0x0b48 // @0B43 stack[2] = stack[-4] // @0B43 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x29a1, returns to 0x0B48 label_0B48: // Incoming return from call to 0x29A1 at 0x0B47 // Inputs[2] // { // @0B49 stack[-2] // @0B49 stack[-1] // } 0B48 5B JUMPDEST 0B49 11 GT 0B4A 15 ISZERO 0B4B 61 PUSH2 0x0b81 0B4E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0b81, if !(stack[-1] > stack[-2]) label_0B4F: // Incoming jump from 0x0B4E, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0B51 memory[0x40:0x60] } 0B4F 60 PUSH1 0x40 0B51 51 MLOAD 0B52 62 PUSH3 0x461bcd 0B56 60 PUSH1 0xe5 0B58 1B SHL 0B59 81 DUP2 0B5A 52 MSTORE 0B5B 60 PUSH1 0x20 0B5D 60 PUSH1 0x04 0B5F 82 DUP3 0B60 01 ADD 0B61 52 MSTORE 0B62 60 PUSH1 0x08 0B64 60 PUSH1 0x24 0B66 82 DUP3 0B67 01 ADD 0B68 52 MSTORE 0B69 67 PUSH8 0x1b585e081d5cd959 0B72 60 PUSH1 0xc2 0B74 1B SHL 0B75 60 PUSH1 0x44 0B77 82 DUP3 0B78 01 ADD 0B79 52 MSTORE 0B7A 60 PUSH1 0x64 0B7C 01 ADD 0B7D 61 PUSH2 0x08bf 0B80 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B5A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B61 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B68 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @0B79 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b585e081d5cd959 << 0xc2 // @0B7C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_0B81: // Incoming jump from 0x0B4E, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @0B82 msg.sender // @0B90 memory[0x00:0x40] // @0B92 storage[keccak256(memory[0x00:0x40])] // @0B93 stack[-4] // } 0B81 5B JUMPDEST 0B82 33 CALLER 0B83 60 PUSH1 0x00 0B85 90 SWAP1 0B86 81 DUP2 0B87 52 MSTORE 0B88 60 PUSH1 0x09 0B8A 60 PUSH1 0x20 0B8C 52 MSTORE 0B8D 60 PUSH1 0x40 0B8F 81 DUP2 0B90 20 SHA3 0B91 80 DUP1 0B92 54 SLOAD 0B93 86 DUP7 0B94 92 SWAP3 0B95 90 SWAP1 0B96 61 PUSH2 0x0ba0 0B99 90 SWAP1 0B9A 84 DUP5 0B9B 90 SWAP1 0B9C 61 PUSH2 0x29a1 0B9F 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @0B87 memory[0x00:0x20] = msg.sender // @0B8C memory[0x20:0x40] = 0x09 // @0B90 stack[1] = keccak256(memory[0x00:0x40]) // @0B94 stack[0] = stack[-4] // @0B95 stack[2] = 0x00 // @0B99 stack[3] = 0x0ba0 // @0B9B stack[4] = stack[-4] // @0B9B stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x29a1, returns to 0x0BA0 label_0BA0: // Incoming return from call to 0x29A1 at 0x116E // Incoming return from call to 0x29A1 at 0x0B9F // Inputs[6] // { // @0BA1 stack[-2] // @0BA1 stack[-1] // @0BA2 stack[-3] // @0BA8 stack[-4] // @0BAA msg.sender // @0BAB stack[-8] // } 0BA0 5B JUMPDEST 0BA1 90 SWAP1 0BA2 91 SWAP2 0BA3 55 SSTORE 0BA4 50 POP 0BA5 61 PUSH2 0x0bb0 0BA8 90 SWAP1 0BA9 50 POP 0BAA 33 CALLER 0BAB 85 DUP6 0BAC 61 PUSH2 0x18fd 0BAF 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0BA3 storage[stack[-3]] = stack[-1] // @0BA8 stack[-4] = 0x0bb0 // @0BAA stack[-3] = msg.sender // @0BAB stack[-2] = stack[-8] // } // Block ends with unconditional jump to 0x18fd label_0BB0: // Incoming jump from 0x25C3, if !(stack[-1] > stack[-4]) // Inputs[1] { @0BB5 stack[-5] } 0BB0 5B JUMPDEST 0BB1 50 POP 0BB2 50 POP 0BB3 50 POP 0BB4 50 POP 0BB5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0BB6: // Incoming jump from 0x03CB // Inputs[3] // { // @0BBA stack[-3] // @0BBB stack[-2] // @0BBC stack[-1] // } 0BB6 5B JUMPDEST 0BB7 61 PUSH2 0x0a49 0BBA 83 DUP4 0BBB 83 DUP4 0BBC 83 DUP4 0BBD 61 PUSH2 0x1917 0BC0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0BB7 stack[0] = 0x0a49 // @0BBA stack[1] = stack[-3] // @0BBB stack[2] = stack[-2] // @0BBC stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1917 label_0BC1: // Incoming jump from 0x03EB // Inputs[2] // { // @0BC4 storage[0x07] // @0BCE msg.sender // } 0BC1 5B JUMPDEST 0BC2 60 PUSH1 0x07 0BC4 54 SLOAD 0BC5 60 PUSH1 0x01 0BC7 60 PUSH1 0x01 0BC9 60 PUSH1 0xa0 0BCB 1B SHL 0BCC 03 SUB 0BCD 16 AND 0BCE 33 CALLER 0BCF 14 EQ 0BD0 80 DUP1 0BD1 61 PUSH2 0x0be4 0BD4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BCF stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x0be4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0BD5: // Incoming jump from 0x0BD4, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @0BD8 storage[0x0e] // @0BE2 msg.sender // } 0BD5 50 POP 0BD6 60 PUSH1 0x0e 0BD8 54 SLOAD 0BD9 60 PUSH1 0x01 0BDB 60 PUSH1 0x01 0BDD 60 PUSH1 0xa0 0BDF 1B SHL 0BE0 03 SUB 0BE1 16 AND 0BE2 33 CALLER 0BE3 14 EQ 0BE4 5B JUMPDEST 0BE5 61 PUSH2 0x0c00 0BE8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c00, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_0BE9: // Incoming jump from 0x0BE8, if not stack[-1] // Incoming jump from 0x0BE8, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @0BEB memory[0x40:0x60] } 0BE9 60 PUSH1 0x40 0BEB 51 MLOAD 0BEC 62 PUSH3 0x461bcd 0BF0 60 PUSH1 0xe5 0BF2 1B SHL 0BF3 81 DUP2 0BF4 52 MSTORE 0BF5 60 PUSH1 0x04 0BF7 01 ADD 0BF8 61 PUSH2 0x08bf 0BFB 90 SWAP1 0BFC 61 PUSH2 0x28f7 0BFF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BFB stack[0] = 0x08bf // @0BFB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_0C00: // Incoming jump from 0x0BE8, if stack[-1] // Incoming jump from 0x0BE8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[2] // { // @0C01 stack[-1] // @0C02 memory[stack[-1]:stack[-1] + 0x20] // } 0C00 5B JUMPDEST 0C01 80 DUP1 0C02 51 MLOAD 0C03 61 PUSH2 0x0c13 0C06 90 SWAP1 0C07 60 PUSH1 0x18 0C09 90 SWAP1 0C0A 60 PUSH1 0x20 0C0C 84 DUP5 0C0D 01 ADD 0C0E 90 SWAP1 0C0F 61 PUSH2 0x24a2 0C12 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C06 stack[0] = 0x0c13 // @0C09 stack[1] = 0x18 // @0C0E stack[2] = stack[-1] + 0x20 // @0C0E stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x24a2 0C13 5B JUMPDEST 0C14 50 POP 0C15 50 POP 0C16 56 *JUMP label_0C17: // Incoming jump from 0x0413 // Inputs[1] { @0C1A storage[0x19] } 0C17 5B JUMPDEST 0C18 60 PUSH1 0x19 0C1A 54 SLOAD 0C1B 61 PUSH2 0x0100 0C1E 90 SWAP1 0C1F 04 DIV 0C20 60 PUSH1 0xff 0C22 16 AND 0C23 61 PUSH2 0x0c3e 0C26 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c3e, if 0xff & storage[0x19] / 0x0100 label_0C27: // Incoming jump from 0x0C26, if not 0xff & storage[0x19] / 0x0100 // Inputs[1] { @0C29 memory[0x40:0x60] } 0C27 60 PUSH1 0x40 0C29 51 MLOAD 0C2A 62 PUSH3 0x461bcd 0C2E 60 PUSH1 0xe5 0C30 1B SHL 0C31 81 DUP2 0C32 52 MSTORE 0C33 60 PUSH1 0x04 0C35 01 ADD 0C36 61 PUSH2 0x08bf 0C39 90 SWAP1 0C3A 61 PUSH2 0x2969 0C3D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C32 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C39 stack[0] = 0x08bf // @0C39 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2969, returns to 0x08BF label_0C3E: // Incoming jump from 0x0C26, if 0xff & storage[0x19] / 0x0100 // Inputs[2] // { // @0C41 storage[0x0a] // @0C42 stack[-1] // } 0C3E 5B JUMPDEST 0C3F 60 PUSH1 0x0a 0C41 54 SLOAD 0C42 81 DUP2 0C43 11 GT 0C44 15 ISZERO 0C45 61 PUSH2 0x0c7b 0C48 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c7b, if !(stack[-1] > storage[0x0a]) label_0C49: // Incoming jump from 0x0C48, if not !(stack[-1] > storage[0x0a]) // Inputs[1] { @0C4B memory[0x40:0x60] } 0C49 60 PUSH1 0x40 0C4B 51 MLOAD 0C4C 62 PUSH3 0x461bcd 0C50 60 PUSH1 0xe5 0C52 1B SHL 0C53 81 DUP2 0C54 52 MSTORE 0C55 60 PUSH1 0x20 0C57 60 PUSH1 0x04 0C59 82 DUP3 0C5A 01 ADD 0C5B 52 MSTORE 0C5C 60 PUSH1 0x08 0C5E 60 PUSH1 0x24 0C60 82 DUP3 0C61 01 ADD 0C62 52 MSTORE 0C63 67 PUSH8 0x746f6f206d616e79 0C6C 60 PUSH1 0xc0 0C6E 1B SHL 0C6F 60 PUSH1 0x44 0C71 82 DUP3 0C72 01 ADD 0C73 52 MSTORE 0C74 60 PUSH1 0x64 0C76 01 ADD 0C77 61 PUSH2 0x08bf 0C7A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C54 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C5B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C62 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @0C73 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x746f6f206d616e79 << 0xc0 // @0C76 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_0C7B: // Incoming jump from 0x0C48, if !(stack[-1] > storage[0x0a]) // Inputs[2] // { // @0C7C msg.sender // @0C7D tx.origin // } 0C7B 5B JUMPDEST 0C7C 33 CALLER 0C7D 32 ORIGIN 0C7E 14 EQ 0C7F 61 PUSH2 0x0cb4 0C82 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cb4, if tx.origin == msg.sender label_0C83: // Incoming jump from 0x0C82, if not tx.origin == msg.sender // Inputs[1] { @0C85 memory[0x40:0x60] } 0C83 60 PUSH1 0x40 0C85 51 MLOAD 0C86 62 PUSH3 0x461bcd 0C8A 60 PUSH1 0xe5 0C8C 1B SHL 0C8D 81 DUP2 0C8E 52 MSTORE 0C8F 60 PUSH1 0x20 0C91 60 PUSH1 0x04 0C93 82 DUP3 0C94 01 ADD 0C95 52 MSTORE 0C96 60 PUSH1 0x07 0C98 60 PUSH1 0x24 0C9A 82 DUP3 0C9B 01 ADD 0C9C 52 MSTORE 0C9D 66 PUSH7 0x6e6f20626f7473 0CA5 60 PUSH1 0xc8 0CA7 1B SHL 0CA8 60 PUSH1 0x44 0CAA 82 DUP3 0CAB 01 ADD 0CAC 52 MSTORE 0CAD 60 PUSH1 0x64 0CAF 01 ADD 0CB0 61 PUSH2 0x08bf 0CB3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C8E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C95 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C9C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x07 // @0CAC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x6e6f20626f7473 << 0xc8 // @0CAF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_0CB4: // Incoming jump from 0x0C82, if tx.origin == msg.sender // Inputs[2] // { // @0CB8 stack[-1] // @0CBE storage[0x00] // } 0CB4 5B JUMPDEST 0CB5 61 PUSH2 0x2710 0CB8 81 DUP2 0CB9 61 PUSH2 0x0cc5 0CBC 60 PUSH1 0x00 0CBE 54 SLOAD 0CBF 60 PUSH1 0x00 0CC1 19 NOT 0CC2 01 ADD 0CC3 90 SWAP1 0CC4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CB5 stack[0] = 0x2710 // @0CB8 stack[1] = stack[-1] // @0CC3 stack[2] = ~0x00 + storage[0x00] // } // Block ends with unconditional jump to 0x0cc5 label_0CC5: // Incoming jump from 0x0CC4 // Inputs[2] // { // @0CC9 stack[-2] // @0CCA stack[-1] // } 0CC5 5B JUMPDEST 0CC6 61 PUSH2 0x0ccf 0CC9 91 SWAP2 0CCA 90 SWAP1 0CCB 61 PUSH2 0x29a1 0CCE 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0CC9 stack[-2] = 0x0ccf // @0CCA stack[-1] = stack[-2] // @0CCA stack[0] = stack[-1] // } // Block ends with call to 0x29a1, returns to 0x0CCF label_0CCF: // Incoming return from call to 0x29A1 at 0x0CCE // Inputs[2] // { // @0CD0 stack[-2] // @0CD0 stack[-1] // } 0CCF 5B JUMPDEST 0CD0 11 GT 0CD1 15 ISZERO 0CD2 61 PUSH2 0x0ced 0CD5 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0ced, if !(stack[-1] > stack[-2]) label_0CD6: // Incoming jump from 0x0CD5, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0CD8 memory[0x40:0x60] } 0CD6 60 PUSH1 0x40 0CD8 51 MLOAD 0CD9 62 PUSH3 0x461bcd 0CDD 60 PUSH1 0xe5 0CDF 1B SHL 0CE0 81 DUP2 0CE1 52 MSTORE 0CE2 60 PUSH1 0x04 0CE4 01 ADD 0CE5 61 PUSH2 0x08bf 0CE8 90 SWAP1 0CE9 61 PUSH2 0x29b9 0CEC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0CE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CE8 stack[0] = 0x08bf // @0CE8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29b9, returns to 0x08BF label_0CED: // Incoming jump from 0x0CD5, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0CEE msg.value // @0CF2 stack[-1] // } 0CED 5B JUMPDEST 0CEE 34 CALLVALUE 0CEF 61 PUSH2 0x0cff 0CF2 82 DUP3 0CF3 66 PUSH7 0xd529ae9e860000 0CFB 61 PUSH2 0x29f1 0CFE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0CEE stack[0] = msg.value // @0CEF stack[1] = 0x0cff // @0CF2 stack[2] = stack[-1] // @0CF3 stack[3] = 0xd529ae9e860000 // } // Block ends with call to 0x29f1, returns to 0x0CFF label_0CFF: // Incoming return from call to 0x29F1 at 0x0CFE // Inputs[2] // { // @0D00 stack[-1] // @0D00 stack[-2] // } 0CFF 5B JUMPDEST 0D00 14 EQ 0D01 61 PUSH2 0x0d1c 0D04 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0d1c, if stack[-1] == stack[-2] label_0D05: // Incoming jump from 0x0D04, if not stack[-1] == stack[-2] // Inputs[1] { @0D07 memory[0x40:0x60] } 0D05 60 PUSH1 0x40 0D07 51 MLOAD 0D08 62 PUSH3 0x461bcd 0D0C 60 PUSH1 0xe5 0D0E 1B SHL 0D0F 81 DUP2 0D10 52 MSTORE 0D11 60 PUSH1 0x04 0D13 01 ADD 0D14 61 PUSH2 0x08bf 0D17 90 SWAP1 0D18 61 PUSH2 0x2a10 0D1B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D17 stack[0] = 0x08bf // @0D17 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a10, returns to 0x08BF label_0D1C: // Incoming jump from 0x0D04, if stack[-1] == stack[-2] // Inputs[2] // { // @0D20 msg.sender // @0D21 stack[-1] // } 0D1C 5B JUMPDEST 0D1D 61 PUSH2 0x0d26 0D20 33 CALLER 0D21 82 DUP3 0D22 61 PUSH2 0x18fd 0D25 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D1D stack[0] = 0x0d26 // @0D20 stack[1] = msg.sender // @0D21 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x18fd label_0D26: // Incoming return from call to 0x1C26 at 0x129F // Incoming return from call to 0x1BD4 at 0x1855 // Incoming jump from 0x130E, if !!address(storage[0x16] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming jump from 0x21E4, if !(stack[-1] == stack[-2]) // Incoming jump from 0x257E, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x254C, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0D28 stack[-2] } 0D26 5B JUMPDEST 0D27 50 POP 0D28 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0D29: // Incoming jump from 0x0433 // Inputs[1] { @0D2F stack[-2] } 0D29 5B JUMPDEST 0D2A 60 PUSH1 0x00 0D2C 61 PUSH2 0x0d34 0D2F 83 DUP4 0D30 61 PUSH2 0x0eff 0D33 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D2A stack[0] = 0x00 // @0D2C stack[1] = 0x0d34 // @0D2F stack[2] = stack[-2] // } // Block ends with call to 0x0eff, returns to 0x0D34 label_0D34: // Incoming return from call to 0x0EFF at 0x0D33 // Inputs[2] // { // @0D35 stack[-3] // @0D36 stack[-1] // } 0D34 5B JUMPDEST 0D35 82 DUP3 0D36 10 LT 0D37 61 PUSH2 0x0d53 0D3A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d53, if stack[-3] < stack[-1] label_0D3B: // Incoming jump from 0x0D3A, if not stack[-3] < stack[-1] // Inputs[3] // { // @0D3D memory[0x40:0x60] // @0D4D memory[0x40:0x60] // @0D52 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0D3B 60 PUSH1 0x40 0D3D 51 MLOAD 0D3E 63 PUSH4 0x06ed6187 0D43 60 PUSH1 0xe1 0D45 1B SHL 0D46 81 DUP2 0D47 52 MSTORE 0D48 60 PUSH1 0x04 0D4A 01 ADD 0D4B 60 PUSH1 0x40 0D4D 51 MLOAD 0D4E 80 DUP1 0D4F 91 SWAP2 0D50 03 SUB 0D51 90 SWAP1 0D52 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x06ed6187 << 0xe1 // @0D52 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0D53: // Incoming jump from 0x0D3A, if stack[-3] < stack[-1] // Inputs[1] { @0D57 storage[0x00] } 0D53 5B JUMPDEST 0D54 60 PUSH1 0x00 0D56 80 DUP1 0D57 54 SLOAD 0D58 81 DUP2 0D59 90 SWAP1 0D5A 60 PUSH1 0x01 0D5C 5B JUMPDEST 0D5D 81 DUP2 0D5E 81 DUP2 0D5F 10 LT 0D60 15 ISZERO 0D61 61 PUSH2 0x0ded 0D64 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0D54 stack[0] = 0x00 // @0D59 stack[1] = 0x00 // @0D59 stack[2] = storage[0x00] // @0D5A stack[3] = 0x01 // } // Block ends with conditional jump to 0x0ded, if !(0x01 < storage[0x00]) label_0D65: // Incoming jump from 0x0D64, if not !(0x01 < storage[0x00]) // Incoming jump from 0x0D64, if not !(stack[-1] < stack[-2]) // Inputs[4] // { // @0D67 stack[-1] // @0D76 memory[0x00:0x40] // @0D78 memory[0x40:0x60] // @0D7F storage[keccak256(memory[0x00:0x40])] // } 0D65 60 PUSH1 0x00 0D67 81 DUP2 0D68 81 DUP2 0D69 52 MSTORE 0D6A 60 PUSH1 0x03 0D6C 60 PUSH1 0x20 0D6E 90 SWAP1 0D6F 81 DUP2 0D70 52 MSTORE 0D71 60 PUSH1 0x40 0D73 91 SWAP2 0D74 82 DUP3 0D75 90 SWAP1 0D76 20 SHA3 0D77 82 DUP3 0D78 51 MLOAD 0D79 80 DUP1 0D7A 84 DUP5 0D7B 01 ADD 0D7C 90 SWAP1 0D7D 93 SWAP4 0D7E 52 MSTORE 0D7F 54 SLOAD 0D80 60 PUSH1 0x01 0D82 60 PUSH1 0x01 0D84 60 PUSH1 0xa0 0D86 1B SHL 0D87 03 SUB 0D88 81 DUP2 0D89 16 AND 0D8A 80 DUP1 0D8B 84 DUP5 0D8C 52 MSTORE 0D8D 60 PUSH1 0x01 0D8F 60 PUSH1 0xa0 0D91 1B SHL 0D92 90 SWAP1 0D93 91 SWAP2 0D94 04 DIV 0D95 67 PUSH8 0xffffffffffffffff 0D9E 16 AND 0D9F 91 SWAP2 0DA0 83 DUP4 0DA1 01 ADD 0DA2 91 SWAP2 0DA3 90 SWAP1 0DA4 91 SWAP2 0DA5 52 MSTORE 0DA6 15 ISZERO 0DA7 61 PUSH2 0x0daf 0DAA 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0D69 memory[0x00:0x20] = stack[-1] // @0D70 memory[0x20:0x40] = 0x03 // @0D7D stack[0] = memory[0x40:0x60] // @0D7E memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0D8C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0DA5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // } // Block ends with conditional jump to 0x0daf, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_0DAB: // Incoming jump from 0x0DAA, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[4] // { // @0DAB stack[-1] // @0DAC memory[stack[-1]:stack[-1] + 0x20] // @0DAD stack[-4] // @0DB0 stack[-8] // } 0DAB 80 DUP1 0DAC 51 MLOAD 0DAD 93 SWAP4 0DAE 50 POP 0DAF 5B JUMPDEST 0DB0 87 DUP8 0DB1 60 PUSH1 0x01 0DB3 60 PUSH1 0x01 0DB5 60 PUSH1 0xa0 0DB7 1B SHL 0DB8 03 SUB 0DB9 16 AND 0DBA 84 DUP5 0DBB 60 PUSH1 0x01 0DBD 60 PUSH1 0x01 0DBF 60 PUSH1 0xa0 0DC1 1B SHL 0DC2 03 SUB 0DC3 16 AND 0DC4 14 EQ 0DC5 15 ISZERO 0DC6 61 PUSH2 0x0de4 0DC9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0DAD stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0de4, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) label_0DCA: // Incoming jump from 0x0DC9, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0DC9, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[2] // { // @0DCA stack[-7] // @0DCB stack[-5] // } 0DCA 86 DUP7 0DCB 85 DUP6 0DCC 14 EQ 0DCD 15 ISZERO 0DCE 61 PUSH2 0x0ddd 0DD1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ddd, if !(stack[-5] == stack[-7]) label_0DD2: // Incoming jump from 0x0DD1, if not !(stack[-5] == stack[-7]) // Inputs[3] // { // @0DD3 stack[-2] // @0DD3 stack[-6] // @0DD8 stack[-5] // } 0DD2 50 POP 0DD3 93 SWAP4 0DD4 50 POP 0DD5 61 PUSH2 0x087a 0DD8 92 SWAP3 0DD9 50 POP 0DDA 50 POP 0DDB 50 POP 0DDC 56 *JUMP // Stack delta = -5 // Outputs[1] { @0DD3 stack[-6] = stack[-2] } // Block ends with unconditional jump to 0x087a label_0DDD: // Incoming jump from 0x0DD1, if !(stack[-5] == stack[-7]) // Inputs[2] // { // @0DE0 stack[-1] // @0DE1 stack[-5] // } 0DDD 5B JUMPDEST 0DDE 60 PUSH1 0x01 0DE0 90 SWAP1 0DE1 94 SWAP5 0DE2 01 ADD 0DE3 93 SWAP4 // Stack delta = +0 // Outputs[2] // { // @0DE3 stack[-5] = stack[-5] + 0x01 // @0DE3 stack[-1] = stack[-1] // } // Block continues label_0DE4: // Incoming jump from 0x0DE3 // Incoming jump from 0x0DC9, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Incoming jump from 0x0DC9, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-8]) // Inputs[1] { @0DE8 stack[-2] } 0DE4 5B JUMPDEST 0DE5 50 POP 0DE6 60 PUSH1 0x01 0DE8 01 ADD 0DE9 61 PUSH2 0x0d5c 0DEC 56 *JUMP // Stack delta = -1 // Outputs[1] { @0DE8 stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x0d5c label_0DED: // Incoming jump from 0x0D64, if !(0x01 < storage[0x00]) // Incoming jump from 0x0D64, if !(stack[-1] < stack[-2]) 0DED 5B JUMPDEST 0DEE 50 POP 0DEF 61 PUSH2 0x0df6 0DF2 61 PUSH2 0x2a38 0DF5 56 *JUMP // Stack delta = +0 // Outputs[1] { @0DEF stack[-1] = 0x0df6 } // Block ends with unconditional jump to 0x2a38 0DF6 5B JUMPDEST 0DF7 50 POP 0DF8 50 POP 0DF9 50 POP 0DFA 92 SWAP3 0DFB 91 SWAP2 0DFC 50 POP 0DFD 50 POP 0DFE 56 *JUMP label_0DFF: // Incoming call from 0x0448, returns to 0x02ED // Inputs[2] // { // @0E02 storage[0x07] // @0E0C msg.sender // } 0DFF 5B JUMPDEST 0E00 60 PUSH1 0x07 0E02 54 SLOAD 0E03 60 PUSH1 0x01 0E05 60 PUSH1 0x01 0E07 60 PUSH1 0xa0 0E09 1B SHL 0E0A 03 SUB 0E0B 16 AND 0E0C 33 CALLER 0E0D 14 EQ 0E0E 80 DUP1 0E0F 61 PUSH2 0x0e22 0E12 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E0D stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x0e22, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0E13: // Incoming jump from 0x0E12, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @0E16 storage[0x0e] // @0E20 msg.sender // } 0E13 50 POP 0E14 60 PUSH1 0x0e 0E16 54 SLOAD 0E17 60 PUSH1 0x01 0E19 60 PUSH1 0x01 0E1B 60 PUSH1 0xa0 0E1D 1B SHL 0E1E 03 SUB 0E1F 16 AND 0E20 33 CALLER 0E21 14 EQ 0E22 5B JUMPDEST 0E23 61 PUSH2 0x0e3e 0E26 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e3e, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_0E27: // Incoming jump from 0x0E26, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x0E26, if not stack[-1] // Inputs[1] { @0E29 memory[0x40:0x60] } 0E27 60 PUSH1 0x40 0E29 51 MLOAD 0E2A 62 PUSH3 0x461bcd 0E2E 60 PUSH1 0xe5 0E30 1B SHL 0E31 81 DUP2 0E32 52 MSTORE 0E33 60 PUSH1 0x04 0E35 01 ADD 0E36 61 PUSH2 0x08bf 0E39 90 SWAP1 0E3A 61 PUSH2 0x28f7 0E3D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E32 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E39 stack[0] = 0x08bf // @0E39 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_0E3E: // Incoming jump from 0x0E26, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x0E26, if stack[-1] // Inputs[2] // { // @0E42 storage[0x19] // @0E51 stack[-1] // } 0E3E 5B JUMPDEST 0E3F 60 PUSH1 0x19 0E41 80 DUP1 0E42 54 SLOAD 0E43 60 PUSH1 0xff 0E45 19 NOT 0E46 81 DUP2 0E47 16 AND 0E48 60 PUSH1 0xff 0E4A 90 SWAP1 0E4B 91 SWAP2 0E4C 16 AND 0E4D 15 ISZERO 0E4E 17 OR 0E4F 90 SWAP1 0E50 55 SSTORE 0E51 56 *JUMP // Stack delta = -1 // Outputs[1] { @0E50 storage[0x19] = !(storage[0x19] & 0xff) | (storage[0x19] & ~0xff) } // Block ends with unconditional jump to stack[-1] label_0E52: // Incoming jump from 0x0487 // Inputs[4] // { // @0E56 stack[-3] // @0E57 stack[-2] // @0E58 stack[-1] // @0E5B memory[0x40:0x60] // } 0E52 5B JUMPDEST 0E53 61 PUSH2 0x0a49 0E56 83 DUP4 0E57 83 DUP4 0E58 83 DUP4 0E59 60 PUSH1 0x40 0E5B 51 MLOAD 0E5C 80 DUP1 0E5D 60 PUSH1 0x20 0E5F 01 ADD 0E60 60 PUSH1 0x40 0E62 52 MSTORE 0E63 80 DUP1 0E64 60 PUSH1 0x00 0E66 81 DUP2 0E67 52 MSTORE 0E68 50 POP 0E69 61 PUSH2 0x1515 0E6C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0E53 stack[0] = 0x0a49 // @0E56 stack[1] = stack[-3] // @0E57 stack[2] = stack[-2] // @0E58 stack[3] = stack[-1] // @0E5B stack[4] = memory[0x40:0x60] // @0E62 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0E67 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1515 label_0E6D: // Incoming jump from 0x04EA // Inputs[2] // { // @0E71 storage[0x00] // @0E76 stack[-1] // } 0E6D 5B JUMPDEST 0E6E 60 PUSH1 0x00 0E70 80 DUP1 0E71 54 SLOAD 0E72 60 PUSH1 0x00 0E74 19 NOT 0E75 01 ADD 0E76 82 DUP3 0E77 10 LT 0E78 61 PUSH2 0x0e94 0E7B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E6E stack[0] = 0x00 } // Block ends with conditional jump to 0x0e94, if stack[-1] < ~0x00 + storage[0x00] label_0E7C: // Incoming jump from 0x0E7B, if not stack[-1] < ~0x00 + storage[0x00] // Inputs[3] // { // @0E7E memory[0x40:0x60] // @0E8E memory[0x40:0x60] // @0E93 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E7C 60 PUSH1 0x40 0E7E 51 MLOAD 0E7F 63 PUSH4 0x29c8c007 0E84 60 PUSH1 0xe2 0E86 1B SHL 0E87 81 DUP2 0E88 52 MSTORE 0E89 60 PUSH1 0x04 0E8B 01 ADD 0E8C 60 PUSH1 0x40 0E8E 51 MLOAD 0E8F 80 DUP1 0E90 91 SWAP2 0E91 03 SUB 0E92 90 SWAP1 0E93 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E88 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x29c8c007 << 0xe2 // @0E93 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E94: // Incoming jump from 0x0E7B, if stack[-1] < ~0x00 + storage[0x00] // Inputs[2] // { // @0E98 stack[-2] // @0E99 stack[-3] // } 0E94 5B JUMPDEST 0E95 50 POP 0E96 60 PUSH1 0x01 0E98 01 ADD 0E99 90 SWAP1 0E9A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E99 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_0E9B: // Incoming jump from 0x050A // Inputs[2] // { // @0E9E storage[0x07] // @0EA8 msg.sender // } 0E9B 5B JUMPDEST 0E9C 60 PUSH1 0x07 0E9E 54 SLOAD 0E9F 60 PUSH1 0x01 0EA1 60 PUSH1 0x01 0EA3 60 PUSH1 0xa0 0EA5 1B SHL 0EA6 03 SUB 0EA7 16 AND 0EA8 33 CALLER 0EA9 14 EQ 0EAA 80 DUP1 0EAB 61 PUSH2 0x0ebe 0EAE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EA9 stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x0ebe, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0EAF: // Incoming jump from 0x0EAE, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @0EB2 storage[0x0e] // @0EBC msg.sender // } 0EAF 50 POP 0EB0 60 PUSH1 0x0e 0EB2 54 SLOAD 0EB3 60 PUSH1 0x01 0EB5 60 PUSH1 0x01 0EB7 60 PUSH1 0xa0 0EB9 1B SHL 0EBA 03 SUB 0EBB 16 AND 0EBC 33 CALLER 0EBD 14 EQ 0EBE 5B JUMPDEST 0EBF 61 PUSH2 0x0eda 0EC2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0eda, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_0EC3: // Incoming jump from 0x0EC2, if not stack[-1] // Incoming jump from 0x0EC2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @0EC5 memory[0x40:0x60] } 0EC3 60 PUSH1 0x40 0EC5 51 MLOAD 0EC6 62 PUSH3 0x461bcd 0ECA 60 PUSH1 0xe5 0ECC 1B SHL 0ECD 81 DUP2 0ECE 52 MSTORE 0ECF 60 PUSH1 0x04 0ED1 01 ADD 0ED2 61 PUSH2 0x08bf 0ED5 90 SWAP1 0ED6 61 PUSH2 0x28f7 0ED9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0ECE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0ED5 stack[0] = 0x08bf // @0ED5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_0EDA: // Incoming jump from 0x0EC2, if stack[-1] // Incoming jump from 0x0EC2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[2] // { // @0EDB stack[-1] // @0EDC memory[stack[-1]:stack[-1] + 0x20] // } 0EDA 5B JUMPDEST 0EDB 80 DUP1 0EDC 51 MLOAD 0EDD 61 PUSH2 0x0c13 0EE0 90 SWAP1 0EE1 60 PUSH1 0x17 0EE3 90 SWAP1 0EE4 60 PUSH1 0x20 0EE6 84 DUP5 0EE7 01 ADD 0EE8 90 SWAP1 0EE9 61 PUSH2 0x24a2 0EEC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EE0 stack[0] = 0x0c13 // @0EE3 stack[1] = 0x17 // @0EE8 stack[2] = stack[-1] + 0x20 // @0EE8 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x24a2 label_0EED: // Incoming jump from 0x0577 // Incoming call from 0x09CA, returns to 0x09CB // Inputs[1] { @0EF3 stack[-1] } 0EED 5B JUMPDEST 0EEE 60 PUSH1 0x00 0EF0 61 PUSH2 0x0ef8 0EF3 82 DUP3 0EF4 61 PUSH2 0x1b30 0EF7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0EEE stack[0] = 0x00 // @0EF0 stack[1] = 0x0ef8 // @0EF3 stack[2] = stack[-1] // } // Block ends with call to 0x1b30, returns to 0x0EF8 label_0EF8: // Incoming return from call to 0x1B30 at 0x0EF7 // Inputs[4] // { // @0EF9 memory[stack[-1]:stack[-1] + 0x20] // @0EF9 stack[-1] // @0EFA stack[-4] // @0EFB stack[-3] // } 0EF8 5B JUMPDEST 0EF9 51 MLOAD 0EFA 92 SWAP3 0EFB 91 SWAP2 0EFC 50 POP 0EFD 50 POP 0EFE 56 *JUMP // Stack delta = -3 // Outputs[1] { @0EFA stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0EFF: // Incoming call from 0x0D33, returns to 0x0D34 // Incoming jump from 0x0597 // Inputs[1] { @0F0A stack[-1] } 0EFF 5B JUMPDEST 0F00 60 PUSH1 0x00 0F02 60 PUSH1 0x01 0F04 60 PUSH1 0x01 0F06 60 PUSH1 0xa0 0F08 1B SHL 0F09 03 SUB 0F0A 82 DUP3 0F0B 16 AND 0F0C 61 PUSH2 0x0f28 0F0F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F00 stack[0] = 0x00 } // Block ends with conditional jump to 0x0f28, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0F10: // Incoming jump from 0x0F0F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0F12 memory[0x40:0x60] // @0F22 memory[0x40:0x60] // @0F27 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F10 60 PUSH1 0x40 0F12 51 MLOAD 0F13 63 PUSH4 0x23d3ad81 0F18 60 PUSH1 0xe2 0F1A 1B SHL 0F1B 81 DUP2 0F1C 52 MSTORE 0F1D 60 PUSH1 0x04 0F1F 01 ADD 0F20 60 PUSH1 0x40 0F22 51 MLOAD 0F23 80 DUP1 0F24 91 SWAP2 0F25 03 SUB 0F26 90 SWAP1 0F27 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x23d3ad81 << 0xe2 // @0F27 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F28: // Incoming jump from 0x0F0F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0F32 stack[-2] // @0F40 memory[0x00:0x40] // @0F41 storage[keccak256(memory[0x00:0x40])] // @0F4B stack[-3] // } 0F28 5B JUMPDEST 0F29 50 POP 0F2A 60 PUSH1 0x01 0F2C 60 PUSH1 0x01 0F2E 60 PUSH1 0xa0 0F30 1B SHL 0F31 03 SUB 0F32 16 AND 0F33 60 PUSH1 0x00 0F35 90 SWAP1 0F36 81 DUP2 0F37 52 MSTORE 0F38 60 PUSH1 0x04 0F3A 60 PUSH1 0x20 0F3C 52 MSTORE 0F3D 60 PUSH1 0x40 0F3F 90 SWAP1 0F40 20 SHA3 0F41 54 SLOAD 0F42 60 PUSH1 0x01 0F44 60 PUSH1 0x01 0F46 60 PUSH1 0x80 0F48 1B SHL 0F49 03 SUB 0F4A 16 AND 0F4B 90 SWAP1 0F4C 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0F37 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0F3C memory[0x20:0x40] = 0x04 // @0F4B stack[-3] = (0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0F4D: // Incoming call from 0x05AC, returns to 0x02ED // Inputs[2] // { // @0F50 storage[0x07] // @0F5A msg.sender // } 0F4D 5B JUMPDEST 0F4E 60 PUSH1 0x07 0F50 54 SLOAD 0F51 60 PUSH1 0x01 0F53 60 PUSH1 0x01 0F55 60 PUSH1 0xa0 0F57 1B SHL 0F58 03 SUB 0F59 16 AND 0F5A 33 CALLER 0F5B 14 EQ 0F5C 61 PUSH2 0x0fa7 0F5F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fa7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_0F60: // Incoming jump from 0x0F5F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @0F62 memory[0x40:0x60] } 0F60 60 PUSH1 0x40 0F62 51 MLOAD 0F63 62 PUSH3 0x461bcd 0F67 60 PUSH1 0xe5 0F69 1B SHL 0F6A 81 DUP2 0F6B 52 MSTORE 0F6C 60 PUSH1 0x20 0F6E 60 PUSH1 0x04 0F70 82 DUP3 0F71 01 ADD 0F72 81 DUP2 0F73 90 SWAP1 0F74 52 MSTORE 0F75 60 PUSH1 0x24 0F77 82 DUP3 0F78 01 ADD 0F79 52 MSTORE 0F7A 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0F9B 60 PUSH1 0x44 0F9D 82 DUP3 0F9E 01 ADD 0F9F 52 MSTORE 0FA0 60 PUSH1 0x64 0FA2 01 ADD 0FA3 61 PUSH2 0x08bf 0FA6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F6B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F74 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F79 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0F9F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0FA2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_0FA7: // Incoming jump from 0x0F5F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] 0FA7 5B JUMPDEST 0FA8 61 PUSH2 0x0fb1 0FAB 60 PUSH1 0x00 0FAD 61 PUSH2 0x1bd4 0FB0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FA8 stack[0] = 0x0fb1 // @0FAB stack[1] = 0x00 // } // Block ends with call to 0x1bd4, returns to 0x0FB1 label_0FB1: // Incoming return from call to 0x1BD4 at 0x0FB0 // Inputs[1] { @0FB2 stack[-1] } 0FB1 5B JUMPDEST 0FB2 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0FB3: // Incoming jump from 0x05BF // Inputs[1] { @0FB6 storage[0x19] } 0FB3 5B JUMPDEST 0FB4 60 PUSH1 0x19 0FB6 54 SLOAD 0FB7 60 PUSH1 0xff 0FB9 16 AND 0FBA 61 PUSH2 0x0fd5 0FBD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fd5, if 0xff & storage[0x19] label_0FBE: // Incoming jump from 0x0FBD, if not 0xff & storage[0x19] // Inputs[1] { @0FC0 memory[0x40:0x60] } 0FBE 60 PUSH1 0x40 0FC0 51 MLOAD 0FC1 62 PUSH3 0x461bcd 0FC5 60 PUSH1 0xe5 0FC7 1B SHL 0FC8 81 DUP2 0FC9 52 MSTORE 0FCA 60 PUSH1 0x04 0FCC 01 ADD 0FCD 61 PUSH2 0x08bf 0FD0 90 SWAP1 0FD1 61 PUSH2 0x2969 0FD4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FD0 stack[0] = 0x08bf // @0FD0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2969, returns to 0x08BF label_0FD5: // Incoming jump from 0x0FBD, if 0xff & storage[0x19] // Inputs[2] // { // @0FD9 stack[-4] // @0FDF storage[0x00] // } 0FD5 5B JUMPDEST 0FD6 61 PUSH2 0x2710 0FD9 84 DUP5 0FDA 61 PUSH2 0x0fe6 0FDD 60 PUSH1 0x00 0FDF 54 SLOAD 0FE0 60 PUSH1 0x00 0FE2 19 NOT 0FE3 01 ADD 0FE4 90 SWAP1 0FE5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FD6 stack[0] = 0x2710 // @0FD9 stack[1] = stack[-4] // @0FE4 stack[2] = ~0x00 + storage[0x00] // } // Block ends with unconditional jump to 0x0fe6 label_0FE6: // Incoming jump from 0x0FE5 // Inputs[2] // { // @0FEA stack[-2] // @0FEB stack[-1] // } 0FE6 5B JUMPDEST 0FE7 61 PUSH2 0x0ff0 0FEA 91 SWAP2 0FEB 90 SWAP1 0FEC 61 PUSH2 0x29a1 0FEF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0FEA stack[-2] = 0x0ff0 // @0FEB stack[-1] = stack[-2] // @0FEB stack[0] = stack[-1] // } // Block ends with call to 0x29a1, returns to 0x0FF0 label_0FF0: // Incoming return from call to 0x29A1 at 0x0FEF // Inputs[2] // { // @0FF1 stack[-1] // @0FF1 stack[-2] // } 0FF0 5B JUMPDEST 0FF1 11 GT 0FF2 15 ISZERO 0FF3 61 PUSH2 0x100e 0FF6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x100e, if !(stack[-1] > stack[-2]) label_0FF7: // Incoming jump from 0x0FF6, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0FF9 memory[0x40:0x60] } 0FF7 60 PUSH1 0x40 0FF9 51 MLOAD 0FFA 62 PUSH3 0x461bcd 0FFE 60 PUSH1 0xe5 1000 1B SHL 1001 81 DUP2 1002 52 MSTORE 1003 60 PUSH1 0x04 1005 01 ADD 1006 61 PUSH2 0x08bf 1009 90 SWAP1 100A 61 PUSH2 0x29b9 100D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1002 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1009 stack[0] = 0x08bf // @1009 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29b9, returns to 0x08BF label_100E: // Incoming jump from 0x0FF6, if !(stack[-1] > stack[-2]) // Inputs[5] // { // @1012 stack[-2] // @1013 stack[-1] // @1024 memory[0x40:0x60] // @103B msg.data[stack[-2]:stack[-2] + stack[-1]] // @1045 stack[-3] // } 100E 5B JUMPDEST 100F 61 PUSH2 0x1052 1012 82 DUP3 1013 82 DUP3 1014 80 DUP1 1015 80 DUP1 1016 60 PUSH1 0x1f 1018 01 ADD 1019 60 PUSH1 0x20 101B 80 DUP1 101C 91 SWAP2 101D 04 DIV 101E 02 MUL 101F 60 PUSH1 0x20 1021 01 ADD 1022 60 PUSH1 0x40 1024 51 MLOAD 1025 90 SWAP1 1026 81 DUP2 1027 01 ADD 1028 60 PUSH1 0x40 102A 52 MSTORE 102B 80 DUP1 102C 93 SWAP4 102D 92 SWAP3 102E 91 SWAP2 102F 90 SWAP1 1030 81 DUP2 1031 81 DUP2 1032 52 MSTORE 1033 60 PUSH1 0x20 1035 01 ADD 1036 83 DUP4 1037 83 DUP4 1038 80 DUP1 1039 82 DUP3 103A 84 DUP5 103B 37 CALLDATACOPY 103C 60 PUSH1 0x00 103E 92 SWAP3 103F 01 ADD 1040 91 SWAP2 1041 90 SWAP1 1042 91 SWAP2 1043 52 MSTORE 1044 50 POP 1045 87 DUP8 1046 92 SWAP3 1047 50 POP 1048 60 PUSH1 0x01 104A 91 SWAP2 104B 50 POP 104C 61 PUSH2 0x0aea 104F 90 SWAP1 1050 50 POP 1051 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @100F stack[0] = 0x1052 // @102A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @102C stack[1] = memory[0x40:0x60] // @1032 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @103B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @1043 memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // @1046 stack[2] = stack[-3] // @104A stack[3] = 0x01 // } // Block ends with call to 0x0aea, returns to 0x1052 label_1052: // Incoming return from call to 0x0AEA at 0x1051 // Inputs[1] { @1056 stack[-1] } 1052 5B JUMPDEST 1053 61 PUSH2 0x108e 1056 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x108e, if stack[-1] label_1057: // Incoming jump from 0x1056, if not stack[-1] // Inputs[1] { @1059 memory[0x40:0x60] } 1057 60 PUSH1 0x40 1059 51 MLOAD 105A 62 PUSH3 0x461bcd 105E 60 PUSH1 0xe5 1060 1B SHL 1061 81 DUP2 1062 52 MSTORE 1063 60 PUSH1 0x20 1065 60 PUSH1 0x04 1067 82 DUP3 1068 01 ADD 1069 52 MSTORE 106A 60 PUSH1 0x0d 106C 60 PUSH1 0x24 106E 82 DUP3 106F 01 ADD 1070 52 MSTORE 1071 6C PUSH13 0x626164207369676e6174757265 107F 60 PUSH1 0x98 1081 1B SHL 1082 60 PUSH1 0x44 1084 82 DUP3 1085 01 ADD 1086 52 MSTORE 1087 60 PUSH1 0x64 1089 01 ADD 108A 61 PUSH2 0x08bf 108D 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1062 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1069 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1070 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0d // @1086 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x626164207369676e6174757265 << 0x98 // @1089 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_108E: // Incoming jump from 0x1056, if stack[-1] // Inputs[5] // { // @108F msg.sender // @109D memory[0x00:0x40] // @109E storage[keccak256(memory[0x00:0x40])] // @109F stack[-3] // @10A5 stack[-4] // } 108E 5B JUMPDEST 108F 33 CALLER 1090 60 PUSH1 0x00 1092 90 SWAP1 1093 81 DUP2 1094 52 MSTORE 1095 60 PUSH1 0x08 1097 60 PUSH1 0x20 1099 52 MSTORE 109A 60 PUSH1 0x40 109C 90 SWAP1 109D 20 SHA3 109E 54 SLOAD 109F 83 DUP4 10A0 90 SWAP1 10A1 61 PUSH2 0x10ab 10A4 90 SWAP1 10A5 86 DUP7 10A6 90 SWAP1 10A7 61 PUSH2 0x29a1 10AA 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1094 memory[0x00:0x20] = msg.sender // @1099 memory[0x20:0x40] = 0x08 // @10A0 stack[0] = stack[-3] // @10A4 stack[1] = 0x10ab // @10A6 stack[2] = stack[-4] // @10A6 stack[3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x29a1, returns to 0x10AB label_10AB: // Incoming return from call to 0x29A1 at 0x10AA // Inputs[2] // { // @10AC stack[-1] // @10AC stack[-2] // } 10AB 5B JUMPDEST 10AC 11 GT 10AD 15 ISZERO 10AE 61 PUSH2 0x10e4 10B1 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x10e4, if !(stack[-1] > stack[-2]) label_10B2: // Incoming jump from 0x10B1, if not !(stack[-1] > stack[-2]) // Inputs[1] { @10B4 memory[0x40:0x60] } 10B2 60 PUSH1 0x40 10B4 51 MLOAD 10B5 62 PUSH3 0x461bcd 10B9 60 PUSH1 0xe5 10BB 1B SHL 10BC 81 DUP2 10BD 52 MSTORE 10BE 60 PUSH1 0x20 10C0 60 PUSH1 0x04 10C2 82 DUP3 10C3 01 ADD 10C4 52 MSTORE 10C5 60 PUSH1 0x08 10C7 60 PUSH1 0x24 10C9 82 DUP3 10CA 01 ADD 10CB 52 MSTORE 10CC 67 PUSH8 0x1b585e081d5cd959 10D5 60 PUSH1 0xc2 10D7 1B SHL 10D8 60 PUSH1 0x44 10DA 82 DUP3 10DB 01 ADD 10DC 52 MSTORE 10DD 60 PUSH1 0x64 10DF 01 ADD 10E0 61 PUSH2 0x08bf 10E3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @10BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10C4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10CB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x08 // @10DC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1b585e081d5cd959 << 0xc2 // @10DF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_10E4: // Incoming jump from 0x10B1, if !(stack[-1] > stack[-2]) // Inputs[1] { @10E5 stack[-3] } 10E4 5B JUMPDEST 10E5 82 DUP3 10E6 60 PUSH1 0x03 10E8 14 EQ 10E9 15 ISZERO 10EA 61 PUSH2 0x1121 10ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1121, if !(0x03 == stack[-3]) label_10EE: // Incoming jump from 0x10ED, if not !(0x03 == stack[-3]) // Inputs[2] // { // @10EE msg.value // @10F2 stack[-4] // } 10EE 34 CALLVALUE 10EF 61 PUSH2 0x10ff 10F2 85 DUP6 10F3 66 PUSH7 0x8e1bc9bf040000 10FB 61 PUSH2 0x29f1 10FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @10EE stack[0] = msg.value // @10EF stack[1] = 0x10ff // @10F2 stack[2] = stack[-4] // @10F3 stack[3] = 0x8e1bc9bf040000 // } // Block ends with call to 0x29f1, returns to 0x10FF label_10FF: // Incoming return from call to 0x29F1 at 0x10FE // Inputs[2] // { // @1100 stack[-1] // @1100 stack[-2] // } 10FF 5B JUMPDEST 1100 14 EQ 1101 61 PUSH2 0x111c 1104 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x111c, if stack[-1] == stack[-2] label_1105: // Incoming jump from 0x1104, if not stack[-1] == stack[-2] // Inputs[1] { @1107 memory[0x40:0x60] } 1105 60 PUSH1 0x40 1107 51 MLOAD 1108 62 PUSH3 0x461bcd 110C 60 PUSH1 0xe5 110E 1B SHL 110F 81 DUP2 1110 52 MSTORE 1111 60 PUSH1 0x04 1113 01 ADD 1114 61 PUSH2 0x08bf 1117 90 SWAP1 1118 61 PUSH2 0x2a10 111B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1110 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1117 stack[0] = 0x08bf // @1117 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a10, returns to 0x08BF label_111C: // Incoming jump from 0x1104, if stack[-1] == stack[-2] 111C 5B JUMPDEST 111D 61 PUSH2 0x1150 1120 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1150 label_1121: // Incoming jump from 0x10ED, if !(0x03 == stack[-3]) // Inputs[2] // { // @1122 msg.value // @1126 stack[-4] // } 1121 5B JUMPDEST 1122 34 CALLVALUE 1123 61 PUSH2 0x1133 1126 85 DUP6 1127 66 PUSH7 0xb1a2bc2ec50000 112F 61 PUSH2 0x29f1 1132 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1122 stack[0] = msg.value // @1123 stack[1] = 0x1133 // @1126 stack[2] = stack[-4] // @1127 stack[3] = 0xb1a2bc2ec50000 // } // Block ends with call to 0x29f1, returns to 0x1133 label_1133: // Incoming return from call to 0x29F1 at 0x1132 // Inputs[2] // { // @1134 stack[-1] // @1134 stack[-2] // } 1133 5B JUMPDEST 1134 14 EQ 1135 61 PUSH2 0x1150 1138 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1150, if stack[-1] == stack[-2] label_1139: // Incoming jump from 0x1138, if not stack[-1] == stack[-2] // Inputs[1] { @113B memory[0x40:0x60] } 1139 60 PUSH1 0x40 113B 51 MLOAD 113C 62 PUSH3 0x461bcd 1140 60 PUSH1 0xe5 1142 1B SHL 1143 81 DUP2 1144 52 MSTORE 1145 60 PUSH1 0x04 1147 01 ADD 1148 61 PUSH2 0x08bf 114B 90 SWAP1 114C 61 PUSH2 0x2a10 114F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1144 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @114B stack[0] = 0x08bf // @114B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2a10, returns to 0x08BF label_1150: // Incoming jump from 0x1138, if stack[-1] == stack[-2] // Incoming jump from 0x1120 // Inputs[4] // { // @1151 msg.sender // @115F memory[0x00:0x40] // @1161 storage[keccak256(memory[0x00:0x40])] // @1162 stack[-4] // } 1150 5B JUMPDEST 1151 33 CALLER 1152 60 PUSH1 0x00 1154 90 SWAP1 1155 81 DUP2 1156 52 MSTORE 1157 60 PUSH1 0x08 1159 60 PUSH1 0x20 115B 52 MSTORE 115C 60 PUSH1 0x40 115E 81 DUP2 115F 20 SHA3 1160 80 DUP1 1161 54 SLOAD 1162 86 DUP7 1163 92 SWAP3 1164 90 SWAP1 1165 61 PUSH2 0x0ba0 1168 90 SWAP1 1169 84 DUP5 116A 90 SWAP1 116B 61 PUSH2 0x29a1 116E 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1156 memory[0x00:0x20] = msg.sender // @115B memory[0x20:0x40] = 0x08 // @115F stack[1] = keccak256(memory[0x00:0x40]) // @1163 stack[0] = stack[-4] // @1164 stack[2] = 0x00 // @1168 stack[3] = 0x0ba0 // @116A stack[4] = stack[-4] // @116A stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x29a1, returns to 0x0BA0 label_116F: // Incoming jump from 0x05D4 // Inputs[2] // { // @1172 storage[0x07] // @117C msg.sender // } 116F 5B JUMPDEST 1170 60 PUSH1 0x07 1172 54 SLOAD 1173 60 PUSH1 0x01 1175 60 PUSH1 0x01 1177 60 PUSH1 0xa0 1179 1B SHL 117A 03 SUB 117B 16 AND 117C 33 CALLER 117D 14 EQ 117E 80 DUP1 117F 61 PUSH2 0x1192 1182 57 *JUMPI // Stack delta = +1 // Outputs[1] { @117D stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x1192, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_1183: // Incoming jump from 0x1182, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @1186 storage[0x0e] // @1190 msg.sender // } 1183 50 POP 1184 60 PUSH1 0x0e 1186 54 SLOAD 1187 60 PUSH1 0x01 1189 60 PUSH1 0x01 118B 60 PUSH1 0xa0 118D 1B SHL 118E 03 SUB 118F 16 AND 1190 33 CALLER 1191 14 EQ 1192 5B JUMPDEST 1193 61 PUSH2 0x11ae 1196 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11ae, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_1197: // Incoming jump from 0x1196, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x1196, if not stack[-1] // Inputs[1] { @1199 memory[0x40:0x60] } 1197 60 PUSH1 0x40 1199 51 MLOAD 119A 62 PUSH3 0x461bcd 119E 60 PUSH1 0xe5 11A0 1B SHL 11A1 81 DUP2 11A2 52 MSTORE 11A3 60 PUSH1 0x04 11A5 01 ADD 11A6 61 PUSH2 0x08bf 11A9 90 SWAP1 11AA 61 PUSH2 0x28f7 11AD 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @11A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11A9 stack[0] = 0x08bf // @11A9 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_11AE: // Incoming jump from 0x1196, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x1196, if stack[-1] // Inputs[3] // { // @11B1 storage[0x0f] // @11B2 address(this).balance // @11B2 address(this) // } 11AE 5B JUMPDEST 11AF 60 PUSH1 0x0f 11B1 54 SLOAD 11B2 47 SELFBALANCE 11B3 90 SWAP1 11B4 61 PUSH2 0x11dc 11B7 90 SWAP1 11B8 60 PUSH1 0x01 11BA 60 PUSH1 0x01 11BC 60 PUSH1 0xa0 11BE 1B SHL 11BF 03 SUB 11C0 16 AND 11C1 60 PUSH1 0x64 11C3 61 PUSH2 0x11cd 11C6 84 DUP5 11C7 60 PUSH1 0x19 11C9 61 PUSH2 0x29f1 11CC 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @11B3 stack[0] = address(this).balance // @11B7 stack[1] = 0x11dc // @11C0 stack[2] = (0x01 << 0xa0) - 0x01 & storage[0x0f] // @11C1 stack[3] = 0x64 // @11C3 stack[4] = 0x11cd // @11C6 stack[5] = address(this).balance // @11C7 stack[6] = 0x19 // } // Block ends with call to 0x29f1, returns to 0x11CD label_11CD: // Incoming return from call to 0x29F1 at 0x1215 // Incoming return from call to 0x29F1 at 0x1289 // Incoming return from call to 0x29F1 at 0x126C // Incoming return from call to 0x29F1 at 0x11F8 // Incoming return from call to 0x29F1 at 0x124F // Incoming return from call to 0x29F1 at 0x1232 // Incoming return from call to 0x29F1 at 0x11CC // Inputs[2] // { // @11D1 stack[-2] // @11D2 stack[-1] // } 11CD 5B JUMPDEST 11CE 61 PUSH2 0x11d7 11D1 91 SWAP2 11D2 90 SWAP1 11D3 61 PUSH2 0x2a64 11D6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @11D1 stack[-2] = 0x11d7 // @11D2 stack[-1] = stack[-2] // @11D2 stack[0] = stack[-1] // } // Block ends with call to 0x2a64, returns to 0x11D7 label_11D7: // Incoming return from call to 0x2A64 at 0x11D6 11D7 5B JUMPDEST 11D8 61 PUSH2 0x1c26 11DB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1c26 label_11DC: // Incoming return from call to 0x11CD at 0x11CC // Inputs[2] // { // @11DF storage[0x10] // @11F2 stack[-1] // } 11DC 5B JUMPDEST 11DD 60 PUSH1 0x10 11DF 54 SLOAD 11E0 61 PUSH2 0x11f9 11E3 90 SWAP1 11E4 60 PUSH1 0x01 11E6 60 PUSH1 0x01 11E8 60 PUSH1 0xa0 11EA 1B SHL 11EB 03 SUB 11EC 16 AND 11ED 60 PUSH1 0x64 11EF 61 PUSH2 0x11cd 11F2 84 DUP5 11F3 60 PUSH1 0x19 11F5 61 PUSH2 0x29f1 11F8 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @11E3 stack[0] = 0x11f9 // @11EC stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x10] // @11ED stack[2] = 0x64 // @11EF stack[3] = 0x11cd // @11F2 stack[4] = stack[-1] // @11F3 stack[5] = 0x19 // } // Block ends with call to 0x29f1, returns to 0x11CD label_11F9: // Incoming return from call to 0x11CD at 0x11F8 // Inputs[2] // { // @11FC storage[0x11] // @120F stack[-1] // } 11F9 5B JUMPDEST 11FA 60 PUSH1 0x11 11FC 54 SLOAD 11FD 61 PUSH2 0x1216 1200 90 SWAP1 1201 60 PUSH1 0x01 1203 60 PUSH1 0x01 1205 60 PUSH1 0xa0 1207 1B SHL 1208 03 SUB 1209 16 AND 120A 60 PUSH1 0x64 120C 61 PUSH2 0x11cd 120F 84 DUP5 1210 60 PUSH1 0x0f 1212 61 PUSH2 0x29f1 1215 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1200 stack[0] = 0x1216 // @1209 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x11] // @120A stack[2] = 0x64 // @120C stack[3] = 0x11cd // @120F stack[4] = stack[-1] // @1210 stack[5] = 0x0f // } // Block ends with call to 0x29f1, returns to 0x11CD label_1216: // Incoming return from call to 0x11CD at 0x1215 // Inputs[2] // { // @1219 storage[0x12] // @122C stack[-1] // } 1216 5B JUMPDEST 1217 60 PUSH1 0x12 1219 54 SLOAD 121A 61 PUSH2 0x1233 121D 90 SWAP1 121E 60 PUSH1 0x01 1220 60 PUSH1 0x01 1222 60 PUSH1 0xa0 1224 1B SHL 1225 03 SUB 1226 16 AND 1227 60 PUSH1 0x64 1229 61 PUSH2 0x11cd 122C 84 DUP5 122D 60 PUSH1 0x09 122F 61 PUSH2 0x29f1 1232 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @121D stack[0] = 0x1233 // @1226 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x12] // @1227 stack[2] = 0x64 // @1229 stack[3] = 0x11cd // @122C stack[4] = stack[-1] // @122D stack[5] = 0x09 // } // Block ends with call to 0x29f1, returns to 0x11CD label_1233: // Incoming return from call to 0x11CD at 0x1232 // Inputs[2] // { // @1236 storage[0x13] // @1249 stack[-1] // } 1233 5B JUMPDEST 1234 60 PUSH1 0x13 1236 54 SLOAD 1237 61 PUSH2 0x1250 123A 90 SWAP1 123B 60 PUSH1 0x01 123D 60 PUSH1 0x01 123F 60 PUSH1 0xa0 1241 1B SHL 1242 03 SUB 1243 16 AND 1244 60 PUSH1 0x64 1246 61 PUSH2 0x11cd 1249 84 DUP5 124A 60 PUSH1 0x09 124C 61 PUSH2 0x29f1 124F 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @123A stack[0] = 0x1250 // @1243 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x13] // @1244 stack[2] = 0x64 // @1246 stack[3] = 0x11cd // @1249 stack[4] = stack[-1] // @124A stack[5] = 0x09 // } // Block ends with call to 0x29f1, returns to 0x11CD label_1250: // Incoming return from call to 0x11CD at 0x124F // Inputs[2] // { // @1253 storage[0x14] // @1266 stack[-1] // } 1250 5B JUMPDEST 1251 60 PUSH1 0x14 1253 54 SLOAD 1254 61 PUSH2 0x126d 1257 90 SWAP1 1258 60 PUSH1 0x01 125A 60 PUSH1 0x01 125C 60 PUSH1 0xa0 125E 1B SHL 125F 03 SUB 1260 16 AND 1261 60 PUSH1 0x64 1263 61 PUSH2 0x11cd 1266 84 DUP5 1267 60 PUSH1 0x09 1269 61 PUSH2 0x29f1 126C 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1257 stack[0] = 0x126d // @1260 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x14] // @1261 stack[2] = 0x64 // @1263 stack[3] = 0x11cd // @1266 stack[4] = stack[-1] // @1267 stack[5] = 0x09 // } // Block ends with call to 0x29f1, returns to 0x11CD label_126D: // Incoming return from call to 0x11CD at 0x126C // Inputs[2] // { // @1270 storage[0x15] // @1283 stack[-1] // } 126D 5B JUMPDEST 126E 60 PUSH1 0x15 1270 54 SLOAD 1271 61 PUSH2 0x128a 1274 90 SWAP1 1275 60 PUSH1 0x01 1277 60 PUSH1 0x01 1279 60 PUSH1 0xa0 127B 1B SHL 127C 03 SUB 127D 16 AND 127E 60 PUSH1 0x64 1280 61 PUSH2 0x11cd 1283 84 DUP5 1284 60 PUSH1 0x08 1286 61 PUSH2 0x29f1 1289 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1274 stack[0] = 0x128a // @127D stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x15] // @127E stack[2] = 0x64 // @1280 stack[3] = 0x11cd // @1283 stack[4] = stack[-1] // @1284 stack[5] = 0x08 // } // Block ends with call to 0x29f1, returns to 0x11CD label_128A: // Incoming return from call to 0x11CD at 0x1289 // Inputs[3] // { // @128D storage[0x15] // @129B address(this).balance // @129B address(this) // } 128A 5B JUMPDEST 128B 60 PUSH1 0x15 128D 54 SLOAD 128E 61 PUSH2 0x0d26 1291 90 SWAP1 1292 60 PUSH1 0x01 1294 60 PUSH1 0x01 1296 60 PUSH1 0xa0 1298 1B SHL 1299 03 SUB 129A 16 AND 129B 47 SELFBALANCE 129C 61 PUSH2 0x1c26 129F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1291 stack[0] = 0x0d26 // @129A stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x15] // @129B stack[2] = address(this).balance // } // Block ends with call to 0x1c26, returns to 0x0D26 label_12A0: // Incoming call from 0x0621, returns to 0x02ED // Inputs[2] // { // @12A3 storage[0x07] // @12AD msg.sender // } 12A0 5B JUMPDEST 12A1 60 PUSH1 0x07 12A3 54 SLOAD 12A4 60 PUSH1 0x01 12A6 60 PUSH1 0x01 12A8 60 PUSH1 0xa0 12AA 1B SHL 12AB 03 SUB 12AC 16 AND 12AD 33 CALLER 12AE 14 EQ 12AF 80 DUP1 12B0 61 PUSH2 0x12c3 12B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12AE stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x12c3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_12B4: // Incoming jump from 0x12B3, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @12B7 storage[0x0e] // @12C1 msg.sender // } 12B4 50 POP 12B5 60 PUSH1 0x0e 12B7 54 SLOAD 12B8 60 PUSH1 0x01 12BA 60 PUSH1 0x01 12BC 60 PUSH1 0xa0 12BE 1B SHL 12BF 03 SUB 12C0 16 AND 12C1 33 CALLER 12C2 14 EQ 12C3 5B JUMPDEST 12C4 61 PUSH2 0x12df 12C7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12df, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_12C8: // Incoming jump from 0x12C7, if not stack[-1] // Incoming jump from 0x12C7, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @12CA memory[0x40:0x60] } 12C8 60 PUSH1 0x40 12CA 51 MLOAD 12CB 62 PUSH3 0x461bcd 12CF 60 PUSH1 0xe5 12D1 1B SHL 12D2 81 DUP2 12D3 52 MSTORE 12D4 60 PUSH1 0x04 12D6 01 ADD 12D7 61 PUSH2 0x08bf 12DA 90 SWAP1 12DB 61 PUSH2 0x28f7 12DE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12DA stack[0] = 0x08bf // @12DA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_12DF: // Incoming jump from 0x12C7, if stack[-1] // Incoming jump from 0x12C7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[6] // { // @12E2 storage[0x16] // @12E5 memory[0x40:0x60] // @12F2 address(this) // @12F2 address(this).balance // @1302 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1302 address(storage[0x16] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 12DF 5B JUMPDEST 12E0 60 PUSH1 0x16 12E2 54 SLOAD 12E3 60 PUSH1 0x40 12E5 51 MLOAD 12E6 60 PUSH1 0x01 12E8 60 PUSH1 0x01 12EA 60 PUSH1 0xa0 12EC 1B SHL 12ED 03 SUB 12EE 90 SWAP1 12EF 91 SWAP2 12F0 16 AND 12F1 90 SWAP1 12F2 47 SELFBALANCE 12F3 80 DUP1 12F4 15 ISZERO 12F5 61 PUSH2 0x08fc 12F8 02 MUL 12F9 91 SWAP2 12FA 60 PUSH1 0x00 12FC 81 DUP2 12FD 81 DUP2 12FE 81 DUP2 12FF 85 DUP6 1300 88 DUP9 1301 88 DUP9 1302 F1 CALL 1303 93 SWAP4 1304 50 POP 1305 50 POP 1306 50 POP 1307 50 POP 1308 15 ISZERO 1309 80 DUP1 130A 15 ISZERO 130B 61 PUSH2 0x0d26 130E 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1302 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(storage[0x16] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @1308 stack[0] = !address(storage[0x16] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0d26, if !!address(storage[0x16] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_130F: // Incoming jump from 0x130E, if not !!address(storage[0x16] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @130F returndata.length // @1313 returndata[0x00:0x00 + returndata.length] // @1314 returndata.length // @1317 memory[0x00:0x00 + returndata.length] // } 130F 3D RETURNDATASIZE 1310 60 PUSH1 0x00 1312 80 DUP1 1313 3E RETURNDATACOPY 1314 3D RETURNDATASIZE 1315 60 PUSH1 0x00 1317 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1313 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1317 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1318: // Incoming call from 0x0636, returns to 0x0304 // Inputs[1] { @131E storage[0x02] } 1318 5B JUMPDEST 1319 60 PUSH1 0x60 131B 60 PUSH1 0x02 131D 80 DUP1 131E 54 SLOAD 131F 61 PUSH2 0x08f9 1322 90 SWAP1 1323 61 PUSH2 0x292e 1326 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1319 stack[0] = 0x60 // @131B stack[1] = 0x02 // @1322 stack[2] = 0x08f9 // @1322 stack[3] = storage[0x02] // } // Block ends with call to 0x292e, returns to 0x08F9 label_1327: // Incoming call from 0x064B, returns to 0x0304 // Inputs[1] { @132B storage[0x18] } 1327 5B JUMPDEST 1328 60 PUSH1 0x18 132A 80 DUP1 132B 54 SLOAD 132C 61 PUSH2 0x1334 132F 90 SWAP1 1330 61 PUSH2 0x292e 1333 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1328 stack[0] = 0x18 // @132F stack[1] = 0x1334 // @132F stack[2] = storage[0x18] // } // Block ends with call to 0x292e, returns to 0x1334 label_1334: // Incoming return from call to 0x292E at 0x1333 // Incoming return from call to 0x292E at 0x13C1 // Inputs[4] // { // @1335 stack[-1] // @1344 memory[0x40:0x60] // @134C stack[-2] // @1357 storage[stack[-2]] // } 1334 5B JUMPDEST 1335 80 DUP1 1336 60 PUSH1 0x1f 1338 01 ADD 1339 60 PUSH1 0x20 133B 80 DUP1 133C 91 SWAP2 133D 04 DIV 133E 02 MUL 133F 60 PUSH1 0x20 1341 01 ADD 1342 60 PUSH1 0x40 1344 51 MLOAD 1345 90 SWAP1 1346 81 DUP2 1347 01 ADD 1348 60 PUSH1 0x40 134A 52 MSTORE 134B 80 DUP1 134C 92 SWAP3 134D 91 SWAP2 134E 90 SWAP1 134F 81 DUP2 1350 81 DUP2 1351 52 MSTORE 1352 60 PUSH1 0x20 1354 01 ADD 1355 82 DUP3 1356 80 DUP1 1357 54 SLOAD 1358 61 PUSH2 0x1360 135B 90 SWAP1 135C 61 PUSH2 0x292e 135F 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @134A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @134C stack[-2] = memory[0x40:0x60] // @134D stack[-1] = stack[-2] // @134E stack[0] = stack[-1] // @1351 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1354 stack[1] = 0x20 + memory[0x40:0x60] // @1355 stack[2] = stack[-2] // @135B stack[4] = storage[stack[-2]] // @135B stack[3] = 0x1360 // } // Block ends with call to 0x292e, returns to 0x1360 label_1360: // Incoming return from call to 0x292E at 0x135F // Inputs[1] { @1361 stack[-1] } 1360 5B JUMPDEST 1361 80 DUP1 1362 15 ISZERO 1363 61 PUSH2 0x13ad 1366 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13ad, if !stack[-1] label_1367: // Incoming jump from 0x1366, if not !stack[-1] // Inputs[1] { @1367 stack[-1] } 1367 80 DUP1 1368 60 PUSH1 0x1f 136A 10 LT 136B 61 PUSH2 0x1382 136E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1382, if 0x1f < stack[-1] label_136F: // Incoming jump from 0x136E, if not 0x1f < stack[-1] // Inputs[4] // { // @1373 stack[-2] // @1374 storage[stack[-2]] // @1377 stack[-3] // @1379 stack[-1] // } 136F 61 PUSH2 0x0100 1372 80 DUP1 1373 83 DUP4 1374 54 SLOAD 1375 04 DIV 1376 02 MUL 1377 83 DUP4 1378 52 MSTORE 1379 91 SWAP2 137A 60 PUSH1 0x20 137C 01 ADD 137D 91 SWAP2 137E 61 PUSH2 0x13ad 1381 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1378 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @137D stack[-1] = stack[-1] // @137D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x13ad label_1382: // Incoming jump from 0x136E, if 0x1f < stack[-1] // Inputs[5] // { // @1383 stack[-3] // @1384 stack[-1] // @1386 stack[-2] // @138E memory[0x00:0x20] // @1392 storage[keccak256(memory[0x00:0x20])] // } 1382 5B JUMPDEST 1383 82 DUP3 1384 01 ADD 1385 91 SWAP2 1386 90 SWAP1 1387 60 PUSH1 0x00 1389 52 MSTORE 138A 60 PUSH1 0x20 138C 60 PUSH1 0x00 138E 20 SHA3 138F 90 SWAP1 1390 5B JUMPDEST 1391 81 DUP2 1392 54 SLOAD 1393 81 DUP2 1394 52 MSTORE 1395 90 SWAP1 1396 60 PUSH1 0x01 1398 01 ADD 1399 90 SWAP1 139A 60 PUSH1 0x20 139C 01 ADD 139D 80 DUP1 139E 83 DUP4 139F 11 GT 13A0 61 PUSH2 0x1390 13A3 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1385 stack[-3] = stack[-3] + stack[-1] // @1389 memory[0x00:0x20] = stack[-2] // @1394 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1399 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @139C stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1390, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_13A4: // Incoming jump from 0x13A3, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x13A3, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @13A4 stack[-3] // @13A5 stack[-1] // } 13A4 82 DUP3 13A5 90 SWAP1 13A6 03 SUB 13A7 60 PUSH1 0x1f 13A9 16 AND 13AA 82 DUP3 13AB 01 ADD 13AC 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @13AC stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @13AC stack[-1] = stack[-3] // } // Block continues label_13AD: // Incoming jump from 0x1366, if !stack[-1] // Incoming jump from 0x1381 // Incoming jump from 0x13AC // Inputs[1] { @13B3 stack[-7] } 13AD 5B JUMPDEST 13AE 50 POP 13AF 50 POP 13B0 50 POP 13B1 50 POP 13B2 50 POP 13B3 81 DUP2 13B4 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_13B5: // Incoming call from 0x0660, returns to 0x0304 // Inputs[1] { @13B9 storage[0x17] } 13B5 5B JUMPDEST 13B6 60 PUSH1 0x17 13B8 80 DUP1 13B9 54 SLOAD 13BA 61 PUSH2 0x1334 13BD 90 SWAP1 13BE 61 PUSH2 0x292e 13C1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13B6 stack[0] = 0x17 // @13BD stack[1] = 0x1334 // @13BD stack[2] = storage[0x17] // } // Block ends with call to 0x292e, returns to 0x1334 label_13C2: // Incoming call from 0x0675, returns to 0x02ED // Inputs[2] // { // @13C5 storage[0x07] // @13CF msg.sender // } 13C2 5B JUMPDEST 13C3 60 PUSH1 0x07 13C5 54 SLOAD 13C6 60 PUSH1 0x01 13C8 60 PUSH1 0x01 13CA 60 PUSH1 0xa0 13CC 1B SHL 13CD 03 SUB 13CE 16 AND 13CF 33 CALLER 13D0 14 EQ 13D1 80 DUP1 13D2 61 PUSH2 0x13e5 13D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13D0 stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x13e5, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_13D6: // Incoming jump from 0x13D5, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @13D9 storage[0x0e] // @13E3 msg.sender // } 13D6 50 POP 13D7 60 PUSH1 0x0e 13D9 54 SLOAD 13DA 60 PUSH1 0x01 13DC 60 PUSH1 0x01 13DE 60 PUSH1 0xa0 13E0 1B SHL 13E1 03 SUB 13E2 16 AND 13E3 33 CALLER 13E4 14 EQ 13E5 5B JUMPDEST 13E6 61 PUSH2 0x1401 13E9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1401, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_13EA: // Incoming jump from 0x13E9, if not stack[-1] // Incoming jump from 0x13E9, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @13EC memory[0x40:0x60] } 13EA 60 PUSH1 0x40 13EC 51 MLOAD 13ED 62 PUSH3 0x461bcd 13F1 60 PUSH1 0xe5 13F3 1B SHL 13F4 81 DUP2 13F5 52 MSTORE 13F6 60 PUSH1 0x04 13F8 01 ADD 13F9 61 PUSH2 0x08bf 13FC 90 SWAP1 13FD 61 PUSH2 0x28f7 1400 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @13F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13FC stack[0] = 0x08bf // @13FC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_1401: // Incoming jump from 0x13E9, if stack[-1] // Incoming jump from 0x13E9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[2] // { // @1405 storage[0x19] // @141D stack[-1] // } 1401 5B JUMPDEST 1402 60 PUSH1 0x19 1404 80 DUP1 1405 54 SLOAD 1406 61 PUSH2 0xff00 1409 19 NOT 140A 81 DUP2 140B 16 AND 140C 61 PUSH2 0x0100 140F 91 SWAP2 1410 82 DUP3 1411 90 SWAP1 1412 04 DIV 1413 60 PUSH1 0xff 1415 16 AND 1416 15 ISZERO 1417 90 SWAP1 1418 91 SWAP2 1419 02 MUL 141A 17 OR 141B 90 SWAP1 141C 55 SSTORE 141D 56 *JUMP // Stack delta = -1 // Outputs[1] { @141C storage[0x19] = 0x0100 * !(0xff & storage[0x19] / 0x0100) | (storage[0x19] & ~0xff00) } // Block ends with unconditional jump to stack[-1] label_141E: // Incoming jump from 0x0695 // Inputs[2] // { // @1427 stack[-2] // @1429 msg.sender // } 141E 5B JUMPDEST 141F 60 PUSH1 0x01 1421 60 PUSH1 0x01 1423 60 PUSH1 0xa0 1425 1B SHL 1426 03 SUB 1427 82 DUP3 1428 16 AND 1429 33 CALLER 142A 14 EQ 142B 15 ISZERO 142C 61 PUSH2 0x1448 142F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1448, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_1430: // Incoming jump from 0x142F, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1432 memory[0x40:0x60] // @1442 memory[0x40:0x60] // @1447 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1430 60 PUSH1 0x40 1432 51 MLOAD 1433 63 PUSH4 0xb06307db 1438 60 PUSH1 0xe0 143A 1B SHL 143B 81 DUP2 143C 52 MSTORE 143D 60 PUSH1 0x04 143F 01 ADD 1440 60 PUSH1 0x40 1442 51 MLOAD 1443 80 DUP1 1444 91 SWAP2 1445 03 SUB 1446 90 SWAP1 1447 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @143C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb06307db << 0xe0 // @1447 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1448: // Incoming jump from 0x142F, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @1449 msg.sender // @145A memory[0x00:0x40] // @1463 stack[-2] // @146E memory[0x00:0x40] // @1470 storage[keccak256(memory[0x00:0x40])] // @1475 stack[-1] // @147F memory[0x40:0x60] // @14AB memory[0x40:0x60] // @14B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @14B3 stack[-3] // } 1448 5B JUMPDEST 1449 33 CALLER 144A 60 PUSH1 0x00 144C 81 DUP2 144D 81 DUP2 144E 52 MSTORE 144F 60 PUSH1 0x06 1451 60 PUSH1 0x20 1453 90 SWAP1 1454 81 DUP2 1455 52 MSTORE 1456 60 PUSH1 0x40 1458 80 DUP1 1459 83 DUP4 145A 20 SHA3 145B 60 PUSH1 0x01 145D 60 PUSH1 0x01 145F 60 PUSH1 0xa0 1461 1B SHL 1462 03 SUB 1463 87 DUP8 1464 16 AND 1465 80 DUP1 1466 85 DUP6 1467 52 MSTORE 1468 90 SWAP1 1469 83 DUP4 146A 52 MSTORE 146B 92 SWAP3 146C 81 DUP2 146D 90 SWAP1 146E 20 SHA3 146F 80 DUP1 1470 54 SLOAD 1471 60 PUSH1 0xff 1473 19 NOT 1474 16 AND 1475 86 DUP7 1476 15 ISZERO 1477 15 ISZERO 1478 90 SWAP1 1479 81 DUP2 147A 17 OR 147B 90 SWAP1 147C 91 SWAP2 147D 55 SSTORE 147E 90 SWAP1 147F 51 MLOAD 1480 90 SWAP1 1481 81 DUP2 1482 52 MSTORE 1483 91 SWAP2 1484 92 SWAP3 1485 91 SWAP2 1486 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 14A7 91 SWAP2 14A8 01 ADD 14A9 60 PUSH1 0x40 14AB 51 MLOAD 14AC 80 DUP1 14AD 91 SWAP2 14AE 03 SUB 14AF 90 SWAP1 14B0 A3 LOG3 14B1 50 POP 14B2 50 POP 14B3 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @144E memory[0x00:0x20] = msg.sender // @1455 memory[0x20:0x40] = 0x06 // @1467 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @146A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @147D storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1482 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @14B0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_14B4: // Incoming jump from 0x06B5 // Inputs[2] // { // @14B7 storage[0x07] // @14C1 msg.sender // } 14B4 5B JUMPDEST 14B5 60 PUSH1 0x07 14B7 54 SLOAD 14B8 60 PUSH1 0x01 14BA 60 PUSH1 0x01 14BC 60 PUSH1 0xa0 14BE 1B SHL 14BF 03 SUB 14C0 16 AND 14C1 33 CALLER 14C2 14 EQ 14C3 80 DUP1 14C4 61 PUSH2 0x14d7 14C7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @14C2 stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x14d7, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_14C8: // Incoming jump from 0x14C7, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @14CB storage[0x0e] // @14D5 msg.sender // } 14C8 50 POP 14C9 60 PUSH1 0x0e 14CB 54 SLOAD 14CC 60 PUSH1 0x01 14CE 60 PUSH1 0x01 14D0 60 PUSH1 0xa0 14D2 1B SHL 14D3 03 SUB 14D4 16 AND 14D5 33 CALLER 14D6 14 EQ 14D7 5B JUMPDEST 14D8 61 PUSH2 0x14f3 14DB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x14f3, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_14DC: // Incoming jump from 0x14DB, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x14DB, if not stack[-1] // Inputs[1] { @14DE memory[0x40:0x60] } 14DC 60 PUSH1 0x40 14DE 51 MLOAD 14DF 62 PUSH3 0x461bcd 14E3 60 PUSH1 0xe5 14E5 1B SHL 14E6 81 DUP2 14E7 52 MSTORE 14E8 60 PUSH1 0x04 14EA 01 ADD 14EB 61 PUSH2 0x08bf 14EE 90 SWAP1 14EF 61 PUSH2 0x28f7 14F2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @14E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14EE stack[0] = 0x08bf // @14EE stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_14F3: // Incoming jump from 0x14DB, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x14DB, if stack[-1] // Inputs[3] // { // @14F7 storage[0x0d] // @150A stack[-1] // @1514 stack[-2] // } 14F3 5B JUMPDEST 14F4 60 PUSH1 0x0d 14F6 80 DUP1 14F7 54 SLOAD 14F8 60 PUSH1 0x01 14FA 60 PUSH1 0x01 14FC 60 PUSH1 0xa0 14FE 1B SHL 14FF 03 SUB 1500 19 NOT 1501 16 AND 1502 60 PUSH1 0x01 1504 60 PUSH1 0x01 1506 60 PUSH1 0xa0 1508 1B SHL 1509 03 SUB 150A 92 SWAP3 150B 90 SWAP1 150C 92 SWAP3 150D 16 AND 150E 91 SWAP2 150F 90 SWAP1 1510 91 SWAP2 1511 17 OR 1512 90 SWAP1 1513 55 SSTORE 1514 56 *JUMP // Stack delta = -2 // Outputs[1] { @1513 storage[0x0d] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x0d]) } // Block ends with unconditional jump to stack[-2] label_1515: // Incoming jump from 0x06D5 // Incoming jump from 0x0E6C // Inputs[3] // { // @1519 stack[-4] // @151A stack[-3] // @151B stack[-2] // } 1515 5B JUMPDEST 1516 61 PUSH2 0x1520 1519 84 DUP5 151A 84 DUP5 151B 84 DUP5 151C 61 PUSH2 0x1917 151F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1516 stack[0] = 0x1520 // @1519 stack[1] = stack[-4] // @151A stack[2] = stack[-3] // @151B stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1917 1520 5B JUMPDEST 1521 61 PUSH2 0x152c 1524 84 DUP5 1525 84 DUP5 1526 84 DUP5 1527 84 DUP5 1528 61 PUSH2 0x1cbb 152B 56 *JUMP 152C 5B JUMPDEST 152D 61 PUSH2 0x0bb0 1530 57 *JUMPI 1531 60 PUSH1 0x40 1533 51 MLOAD 1534 63 PUSH4 0x68d2bf6b 1539 60 PUSH1 0xe1 153B 1B SHL 153C 81 DUP2 153D 52 MSTORE 153E 60 PUSH1 0x04 1540 01 ADD 1541 60 PUSH1 0x40 1543 51 MLOAD 1544 80 DUP1 1545 91 SWAP2 1546 03 SUB 1547 90 SWAP1 1548 FD *REVERT label_1549: // Incoming jump from 0x06F5 // Inputs[2] // { // @154C storage[0x07] // @1556 msg.sender // } 1549 5B JUMPDEST 154A 60 PUSH1 0x07 154C 54 SLOAD 154D 60 PUSH1 0x01 154F 60 PUSH1 0x01 1551 60 PUSH1 0xa0 1553 1B SHL 1554 03 SUB 1555 16 AND 1556 33 CALLER 1557 14 EQ 1558 80 DUP1 1559 61 PUSH2 0x156c 155C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1557 stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x156c, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_155D: // Incoming jump from 0x155C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @1560 storage[0x0e] // @156A msg.sender // } 155D 50 POP 155E 60 PUSH1 0x0e 1560 54 SLOAD 1561 60 PUSH1 0x01 1563 60 PUSH1 0x01 1565 60 PUSH1 0xa0 1567 1B SHL 1568 03 SUB 1569 16 AND 156A 33 CALLER 156B 14 EQ 156C 5B JUMPDEST 156D 61 PUSH2 0x1588 1570 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1588, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_1571: // Incoming jump from 0x1570, if not stack[-1] // Incoming jump from 0x1570, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[1] { @1573 memory[0x40:0x60] } 1571 60 PUSH1 0x40 1573 51 MLOAD 1574 62 PUSH3 0x461bcd 1578 60 PUSH1 0xe5 157A 1B SHL 157B 81 DUP2 157C 52 MSTORE 157D 60 PUSH1 0x04 157F 01 ADD 1580 61 PUSH2 0x08bf 1583 90 SWAP1 1584 61 PUSH2 0x28f7 1587 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @157C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1583 stack[0] = 0x08bf // @1583 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_1588: // Incoming jump from 0x1570, if stack[-1] // Incoming jump from 0x1570, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Inputs[2] // { // @158C stack[-2] // @1592 storage[0x00] // } 1588 5B JUMPDEST 1589 61 PUSH2 0x2710 158C 82 DUP3 158D 61 PUSH2 0x1599 1590 60 PUSH1 0x00 1592 54 SLOAD 1593 60 PUSH1 0x00 1595 19 NOT 1596 01 ADD 1597 90 SWAP1 1598 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1589 stack[0] = 0x2710 // @158C stack[1] = stack[-2] // @1597 stack[2] = ~0x00 + storage[0x00] // } // Block ends with unconditional jump to 0x1599 label_1599: // Incoming jump from 0x1598 // Inputs[2] // { // @159D stack[-2] // @159E stack[-1] // } 1599 5B JUMPDEST 159A 61 PUSH2 0x15a3 159D 91 SWAP2 159E 90 SWAP1 159F 61 PUSH2 0x29a1 15A2 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @159D stack[-2] = 0x15a3 // @159E stack[-1] = stack[-2] // @159E stack[0] = stack[-1] // } // Block ends with call to 0x29a1, returns to 0x15A3 label_15A3: // Incoming return from call to 0x29A1 at 0x15A2 // Inputs[2] // { // @15A4 stack[-2] // @15A4 stack[-1] // } 15A3 5B JUMPDEST 15A4 11 GT 15A5 15 ISZERO 15A6 61 PUSH2 0x15c1 15A9 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x15c1, if !(stack[-1] > stack[-2]) label_15AA: // Incoming jump from 0x15A9, if not !(stack[-1] > stack[-2]) // Inputs[1] { @15AC memory[0x40:0x60] } 15AA 60 PUSH1 0x40 15AC 51 MLOAD 15AD 62 PUSH3 0x461bcd 15B1 60 PUSH1 0xe5 15B3 1B SHL 15B4 81 DUP2 15B5 52 MSTORE 15B6 60 PUSH1 0x04 15B8 01 ADD 15B9 61 PUSH2 0x08bf 15BC 90 SWAP1 15BD 61 PUSH2 0x29b9 15C0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15BC stack[0] = 0x08bf // @15BC stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29b9, returns to 0x08BF label_15C1: // Incoming jump from 0x15A9, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @15C4 stack[-2] // @15C7 storage[0x0b] // } 15C1 5B JUMPDEST 15C2 60 PUSH1 0x64 15C4 82 DUP3 15C5 60 PUSH1 0x0b 15C7 54 SLOAD 15C8 61 PUSH2 0x15d1 15CB 91 SWAP2 15CC 90 SWAP1 15CD 61 PUSH2 0x29a1 15D0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15C2 stack[0] = 0x64 // @15CB stack[1] = 0x15d1 // @15CC stack[2] = stack[-2] // @15CC stack[3] = storage[0x0b] // } // Block ends with call to 0x29a1, returns to 0x15D1 label_15D1: // Incoming return from call to 0x29A1 at 0x15D0 // Inputs[2] // { // @15D2 stack[-1] // @15D2 stack[-2] // } 15D1 5B JUMPDEST 15D2 11 GT 15D3 15 ISZERO 15D4 61 PUSH2 0x1616 15D7 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1616, if !(stack[-1] > stack[-2]) label_15D8: // Incoming jump from 0x15D7, if not !(stack[-1] > stack[-2]) // Inputs[1] { @15DA memory[0x40:0x60] } 15D8 60 PUSH1 0x40 15DA 51 MLOAD 15DB 62 PUSH3 0x461bcd 15DF 60 PUSH1 0xe5 15E1 1B SHL 15E2 81 DUP2 15E3 52 MSTORE 15E4 60 PUSH1 0x20 15E6 60 PUSH1 0x04 15E8 82 DUP3 15E9 01 ADD 15EA 52 MSTORE 15EB 60 PUSH1 0x14 15ED 60 PUSH1 0x24 15EF 82 DUP3 15F0 01 ADD 15F1 52 MSTORE 15F2 73 PUSH20 0x1d19585b481cdd5c1c1b1e481cdbdb19081bdd5d 1607 60 PUSH1 0x62 1609 1B SHL 160A 60 PUSH1 0x44 160C 82 DUP3 160D 01 ADD 160E 52 MSTORE 160F 60 PUSH1 0x64 1611 01 ADD 1612 61 PUSH2 0x08bf 1615 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @15E3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @15EA memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15F1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @160E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1d19585b481cdd5c1c1b1e481cdbdb19081bdd5d << 0x62 // @1611 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_1616: // Incoming jump from 0x15D7, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @1617 stack[-2] // @161E storage[0x0b] // } 1616 5B JUMPDEST 1617 81 DUP2 1618 60 PUSH1 0x0b 161A 60 PUSH1 0x00 161C 82 DUP3 161D 82 DUP3 161E 54 SLOAD 161F 61 PUSH2 0x1628 1622 91 SWAP2 1623 90 SWAP1 1624 61 PUSH2 0x29a1 1627 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1617 stack[0] = stack[-2] // @1618 stack[1] = 0x0b // @161A stack[2] = 0x00 // @1622 stack[3] = 0x1628 // @1623 stack[4] = stack[-2] // @1623 stack[5] = storage[0x0b] // } // Block ends with call to 0x29a1, returns to 0x1628 label_1628: // Incoming return from call to 0x29A1 at 0x1627 // Inputs[6] // { // @1629 stack[-1] // @1629 stack[-2] // @162A stack[-3] // @1630 stack[-4] // @1632 stack[-5] // @1633 stack[-6] // } 1628 5B JUMPDEST 1629 90 SWAP1 162A 91 SWAP2 162B 55 SSTORE 162C 50 POP 162D 61 PUSH2 0x0c13 1630 90 SWAP1 1631 50 POP 1632 81 DUP2 1633 83 DUP4 1634 61 PUSH2 0x18fd 1637 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @162B storage[stack[-3]] = stack[-1] // @1630 stack[-4] = 0x0c13 // @1632 stack[-3] = stack[-5] // @1633 stack[-2] = stack[-6] // } // Block ends with unconditional jump to 0x18fd label_1638: // Incoming jump from 0x0715 // Inputs[1] { @163E stack[-1] } 1638 5B JUMPDEST 1639 60 PUSH1 0x60 163B 61 PUSH2 0x1643 163E 82 DUP3 163F 61 PUSH2 0x1dba 1642 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1639 stack[0] = 0x60 // @163B stack[1] = 0x1643 // @163E stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1dba 1643 5B JUMPDEST 1644 60 PUSH1 0x18 1646 60 PUSH1 0x40 1648 51 MLOAD 1649 60 PUSH1 0x20 164B 01 ADD 164C 61 PUSH2 0x1656 164F 92 SWAP3 1650 91 SWAP2 1651 90 SWAP1 1652 61 PUSH2 0x2a78 1655 56 *JUMP 1656 5B JUMPDEST 1657 60 PUSH1 0x40 1659 51 MLOAD 165A 60 PUSH1 0x20 165C 81 DUP2 165D 83 DUP4 165E 03 SUB 165F 03 SUB 1660 81 DUP2 1661 52 MSTORE 1662 90 SWAP1 1663 60 PUSH1 0x40 1665 52 MSTORE 1666 90 SWAP1 1667 50 POP 1668 91 SWAP2 1669 90 SWAP1 166A 50 POP 166B 56 *JUMP label_166C: // Incoming jump from 0x0755 // Inputs[2] // { // @166F storage[0x07] // @1679 msg.sender // } 166C 5B JUMPDEST 166D 60 PUSH1 0x07 166F 54 SLOAD 1670 60 PUSH1 0x01 1672 60 PUSH1 0x01 1674 60 PUSH1 0xa0 1676 1B SHL 1677 03 SUB 1678 16 AND 1679 33 CALLER 167A 14 EQ 167B 80 DUP1 167C 61 PUSH2 0x168f 167F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @167A stack[0] = msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] } // Block ends with conditional jump to 0x168f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_1680: // Incoming jump from 0x167F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[2] // { // @1683 storage[0x0e] // @168D msg.sender // } 1680 50 POP 1681 60 PUSH1 0x0e 1683 54 SLOAD 1684 60 PUSH1 0x01 1686 60 PUSH1 0x01 1688 60 PUSH1 0xa0 168A 1B SHL 168B 03 SUB 168C 16 AND 168D 33 CALLER 168E 14 EQ 168F 5B JUMPDEST 1690 61 PUSH2 0x16ab 1693 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x16ab, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] label_1694: // Incoming jump from 0x1693, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x1693, if not stack[-1] // Inputs[1] { @1696 memory[0x40:0x60] } 1694 60 PUSH1 0x40 1696 51 MLOAD 1697 62 PUSH3 0x461bcd 169B 60 PUSH1 0xe5 169D 1B SHL 169E 81 DUP2 169F 52 MSTORE 16A0 60 PUSH1 0x04 16A2 01 ADD 16A3 61 PUSH2 0x08bf 16A6 90 SWAP1 16A7 61 PUSH2 0x28f7 16AA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @169F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16A6 stack[0] = 0x08bf // @16A6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x28f7, returns to 0x08BF label_16AB: // Incoming jump from 0x1693, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0e] // Incoming jump from 0x1693, if stack[-1] // Inputs[3] // { // @16AF storage[0x0e] // @16C2 stack[-1] // @16CC stack[-2] // } 16AB 5B JUMPDEST 16AC 60 PUSH1 0x0e 16AE 80 DUP1 16AF 54 SLOAD 16B0 60 PUSH1 0x01 16B2 60 PUSH1 0x01 16B4 60 PUSH1 0xa0 16B6 1B SHL 16B7 03 SUB 16B8 19 NOT 16B9 16 AND 16BA 60 PUSH1 0x01 16BC 60 PUSH1 0x01 16BE 60 PUSH1 0xa0 16C0 1B SHL 16C1 03 SUB 16C2 92 SWAP3 16C3 90 SWAP1 16C4 92 SWAP3 16C5 16 AND 16C6 91 SWAP2 16C7 90 SWAP1 16C8 91 SWAP2 16C9 17 OR 16CA 90 SWAP1 16CB 55 SSTORE 16CC 56 *JUMP // Stack delta = -2 // Outputs[1] { @16CB storage[0x0e] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x0e]) } // Block ends with unconditional jump to stack[-2] label_16CD: // Incoming jump from 0x0A1D // Incoming jump from 0x196A // Inputs[8] // { // @16D0 storage[0x0d] // @16D3 memory[0x40:0x60] // @16E6 stack[-2] // @16F5 stack[-1] // @1707 memory[0x40:0x60] // @170D msg.gas // @170E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]] // @170E address((0x01 << 0xa0) - 0x01 & storage[0x0d]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 16CD 5B JUMPDEST 16CE 60 PUSH1 0x0d 16D0 54 SLOAD 16D1 60 PUSH1 0x40 16D3 51 MLOAD 16D4 63 PUSH4 0xc4552791 16D9 60 PUSH1 0xe0 16DB 1B SHL 16DC 81 DUP2 16DD 52 MSTORE 16DE 60 PUSH1 0x01 16E0 60 PUSH1 0x01 16E2 60 PUSH1 0xa0 16E4 1B SHL 16E5 03 SUB 16E6 84 DUP5 16E7 81 DUP2 16E8 16 AND 16E9 60 PUSH1 0x04 16EB 83 DUP4 16EC 01 ADD 16ED 52 MSTORE 16EE 60 PUSH1 0x00 16F0 92 SWAP3 16F1 81 DUP2 16F2 16 AND 16F3 91 SWAP2 16F4 90 SWAP1 16F5 84 DUP5 16F6 16 AND 16F7 90 SWAP1 16F8 82 DUP3 16F9 90 SWAP1 16FA 63 PUSH4 0xc4552791 16FF 90 SWAP1 1700 60 PUSH1 0x24 1702 01 ADD 1703 60 PUSH1 0x20 1705 60 PUSH1 0x40 1707 51 MLOAD 1708 80 DUP1 1709 83 DUP4 170A 03 SUB 170B 81 DUP2 170C 86 DUP7 170D 5A GAS 170E FA STATICCALL 170F 15 ISZERO 1710 80 DUP1 1711 15 ISZERO 1712 61 PUSH2 0x171f 1715 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @16DD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc4552791 << 0xe0 // @16ED memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @16F0 stack[0] = 0x00 // @16F3 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // @16F7 stack[2] = stack[-1] & (0x01 << 0xa0) - 0x01 // @16F9 stack[3] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // @16FF stack[4] = 0xc4552791 // @1702 stack[5] = 0x24 + memory[0x40:0x60] // @170E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address((0x01 << 0xa0) - 0x01 & storage[0x0d]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @170F stack[6] = !address((0x01 << 0xa0) - 0x01 & storage[0x0d]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x171f, if !!address((0x01 << 0xa0) - 0x01 & storage[0x0d]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_1716: // Incoming jump from 0x1715, if not !!address((0x01 << 0xa0) - 0x01 & storage[0x0d]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @1716 returndata.length // @171A returndata[0x00:0x00 + returndata.length] // @171B returndata.length // @171E memory[0x00:0x00 + returndata.length] // } 1716 3D RETURNDATASIZE 1717 60 PUSH1 0x00 1719 80 DUP1 171A 3E RETURNDATACOPY 171B 3D RETURNDATASIZE 171C 60 PUSH1 0x00 171E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @171A memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @171E revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_171F: // Incoming jump from 0x1715, if !!address((0x01 << 0xa0) - 0x01 & storage[0x0d]).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x24 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @1726 memory[0x40:0x60] // @1727 returndata.length // } 171F 5B JUMPDEST 1720 50 POP 1721 50 POP 1722 50 POP 1723 50 POP 1724 60 PUSH1 0x40 1726 51 MLOAD 1727 3D RETURNDATASIZE 1728 60 PUSH1 0x1f 172A 19 NOT 172B 60 PUSH1 0x1f 172D 82 DUP3 172E 01 ADD 172F 16 AND 1730 82 DUP3 1731 01 ADD 1732 80 DUP1 1733 60 PUSH1 0x40 1735 52 MSTORE 1736 50 POP 1737 81 DUP2 1738 01 ADD 1739 90 SWAP1 173A 61 PUSH2 0x1743 173D 91 SWAP2 173E 90 SWAP1 173F 61 PUSH2 0x2b29 1742 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1735 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @173D stack[-4] = 0x1743 // @173E stack[-2] = memory[0x40:0x60] // @173E stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2b29 1743 5B JUMPDEST 1744 60 PUSH1 0x01 1746 60 PUSH1 0x01 1748 60 PUSH1 0xa0 174A 1B SHL 174B 03 SUB 174C 16 AND 174D 14 EQ 174E 15 ISZERO 174F 61 PUSH2 0x175c 1752 57 *JUMPI 1753 60 PUSH1 0x01 1755 91 SWAP2 1756 50 POP 1757 50 POP 1758 61 PUSH2 0x087a 175B 56 *JUMP 175C 5B JUMPDEST 175D 60 PUSH1 0x01 175F 60 PUSH1 0x01 1761 60 PUSH1 0xa0 1763 1B SHL 1764 03 SUB 1765 80 DUP1 1766 85 DUP6 1767 16 AND 1768 60 PUSH1 0x00 176A 90 SWAP1 176B 81 DUP2 176C 52 MSTORE 176D 60 PUSH1 0x06 176F 60 PUSH1 0x20 1771 90 SWAP1 1772 81 DUP2 1773 52 MSTORE 1774 60 PUSH1 0x40 1776 80 DUP1 1777 83 DUP4 1778 20 SHA3 1779 93 SWAP4 177A 87 DUP8 177B 16 AND 177C 83 DUP4 177D 52 MSTORE 177E 92 SWAP3 177F 90 SWAP1 1780 52 MSTORE 1781 20 SHA3 1782 54 SLOAD 1783 60 PUSH1 0xff 1785 16 AND label_1786: // Incoming return from call to 0x2727 at 0x27E5 // Incoming jump from 0x1ECD // Incoming jump from 0x1DAE // Inputs[3] // { // @1787 stack[-6] // @1787 stack[-1] // @1788 stack[-5] // } 1786 5B JUMPDEST 1787 94 SWAP5 1788 93 SWAP4 1789 50 POP 178A 50 POP 178B 50 POP 178C 50 POP 178D 56 *JUMP // Stack delta = -5 // Outputs[1] { @1787 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_178E: // Incoming jump from 0x07E1 // Inputs[2] // { // @1791 storage[0x07] // @179B msg.sender // } 178E 5B JUMPDEST 178F 60 PUSH1 0x07 1791 54 SLOAD 1792 60 PUSH1 0x01 1794 60 PUSH1 0x01 1796 60 PUSH1 0xa0 1798 1B SHL 1799 03 SUB 179A 16 AND 179B 33 CALLER 179C 14 EQ 179D 61 PUSH2 0x17e8 17A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17e8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] label_17A1: // Incoming jump from 0x17A0, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @17A3 memory[0x40:0x60] } 17A1 60 PUSH1 0x40 17A3 51 MLOAD 17A4 62 PUSH3 0x461bcd 17A8 60 PUSH1 0xe5 17AA 1B SHL 17AB 81 DUP2 17AC 52 MSTORE 17AD 60 PUSH1 0x20 17AF 60 PUSH1 0x04 17B1 82 DUP3 17B2 01 ADD 17B3 81 DUP2 17B4 90 SWAP1 17B5 52 MSTORE 17B6 60 PUSH1 0x24 17B8 82 DUP3 17B9 01 ADD 17BA 52 MSTORE 17BB 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 17DC 60 PUSH1 0x44 17DE 82 DUP3 17DF 01 ADD 17E0 52 MSTORE 17E1 60 PUSH1 0x64 17E3 01 ADD 17E4 61 PUSH2 0x08bf 17E7 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @17AC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17B5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @17BA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @17E0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @17E3 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_17E8: // Incoming jump from 0x17A0, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x07] // Inputs[1] { @17F1 stack[-1] } 17E8 5B JUMPDEST 17E9 60 PUSH1 0x01 17EB 60 PUSH1 0x01 17ED 60 PUSH1 0xa0 17EF 1B SHL 17F0 03 SUB 17F1 81 DUP2 17F2 16 AND 17F3 61 PUSH2 0x184d 17F6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x184d, if stack[-1] & (0x01 << 0xa0) - 0x01 label_17F7: // Incoming jump from 0x17F6, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @17F9 memory[0x40:0x60] } 17F7 60 PUSH1 0x40 17F9 51 MLOAD 17FA 62 PUSH3 0x461bcd 17FE 60 PUSH1 0xe5 1800 1B SHL 1801 81 DUP2 1802 52 MSTORE 1803 60 PUSH1 0x20 1805 60 PUSH1 0x04 1807 82 DUP3 1808 01 ADD 1809 52 MSTORE 180A 60 PUSH1 0x26 180C 60 PUSH1 0x24 180E 82 DUP3 180F 01 ADD 1810 52 MSTORE 1811 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1832 60 PUSH1 0x44 1834 82 DUP3 1835 01 ADD 1836 52 MSTORE 1837 65 PUSH6 0x646472657373 183E 60 PUSH1 0xd0 1840 1B SHL 1841 60 PUSH1 0x64 1843 82 DUP3 1844 01 ADD 1845 52 MSTORE 1846 60 PUSH1 0x84 1848 01 ADD 1849 61 PUSH2 0x08bf 184C 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1802 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1809 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1810 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1836 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1845 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @1848 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_184D: // Incoming jump from 0x17F6, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1851 stack[-1] } 184D 5B JUMPDEST 184E 61 PUSH2 0x0d26 1851 81 DUP2 1852 61 PUSH2 0x1bd4 1855 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @184E stack[0] = 0x0d26 // @1851 stack[1] = stack[-1] // } // Block ends with call to 0x1bd4, returns to 0x0D26 label_1856: // Incoming call from 0x1B4C, returns to 0x1B4D // Incoming call from 0x0986, returns to 0x0987 // Incoming call from 0x1DC4, returns to 0x1DC5 // Inputs[2] // { // @185A storage[0x00] // @185B stack[-1] // } 1856 5B JUMPDEST 1857 60 PUSH1 0x00 1859 80 DUP1 185A 54 SLOAD 185B 82 DUP3 185C 10 LT 185D 80 DUP1 185E 15 ISZERO 185F 61 PUSH2 0x087a 1862 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1857 stack[0] = 0x00 // @185C stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x087a, if !(stack[-1] < storage[0x00]) label_1863: // Incoming jump from 0x1862, if not !(stack[-1] < storage[0x00]) // Inputs[2] // { // @1867 stack[-3] // @1869 stack[-4] // } 1863 50 POP 1864 50 POP 1865 60 PUSH1 0x01 1867 11 GT 1868 15 ISZERO 1869 90 SWAP1 186A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1869 stack[-4] = !(0x01 > stack[-3]) } // Block ends with unconditional jump to stack[-4] label_186B: // Incoming call from 0x0A48, returns to 0x0A49 // Incoming call from 0x19F6, returns to 0x19F7 // Inputs[8] // { // @186E stack[-2] // @187A memory[0x00:0x40] // @187C storage[keccak256(memory[0x00:0x40])] // @188F stack[-3] // @1899 memory[0x40:0x60] // @189D stack[-1] // @18C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @18C6 stack[-4] // } 186B 5B JUMPDEST 186C 60 PUSH1 0x00 186E 82 DUP3 186F 81 DUP2 1870 52 MSTORE 1871 60 PUSH1 0x05 1873 60 PUSH1 0x20 1875 52 MSTORE 1876 60 PUSH1 0x40 1878 80 DUP1 1879 82 DUP3 187A 20 SHA3 187B 80 DUP1 187C 54 SLOAD 187D 60 PUSH1 0x01 187F 60 PUSH1 0x01 1881 60 PUSH1 0xa0 1883 1B SHL 1884 03 SUB 1885 19 NOT 1886 16 AND 1887 60 PUSH1 0x01 1889 60 PUSH1 0x01 188B 60 PUSH1 0xa0 188D 1B SHL 188E 03 SUB 188F 87 DUP8 1890 81 DUP2 1891 16 AND 1892 91 SWAP2 1893 82 DUP3 1894 17 OR 1895 90 SWAP1 1896 92 SWAP3 1897 55 SSTORE 1898 91 SWAP2 1899 51 MLOAD 189A 85 DUP6 189B 93 SWAP4 189C 91 SWAP2 189D 85 DUP6 189E 16 AND 189F 91 SWAP2 18A0 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 18C1 91 SWAP2 18C2 A4 LOG4 18C3 50 POP 18C4 50 POP 18C5 50 POP 18C6 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @1870 memory[0x00:0x20] = stack[-2] // @1875 memory[0x20:0x40] = 0x05 // @1897 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @18C2 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_18C7: // Incoming jump from 0x0AEE // Inputs[5] // { // @18CA storage[0x0c] // @18DA stack[-3] // @18DE msg.sender // @18DF stack[-2] // @18E0 stack[-1] // } 18C7 5B JUMPDEST 18C8 60 PUSH1 0x0c 18CA 54 SLOAD 18CB 60 PUSH1 0x00 18CD 90 SWAP1 18CE 60 PUSH1 0x01 18D0 60 PUSH1 0x01 18D2 60 PUSH1 0xa0 18D4 1B SHL 18D5 03 SUB 18D6 16 AND 18D7 61 PUSH2 0x18eb 18DA 85 DUP6 18DB 61 PUSH2 0x18e5 18DE 33 CALLER 18DF 87 DUP8 18E0 87 DUP8 18E1 61 PUSH2 0x1e3f 18E4 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @18CD stack[0] = 0x00 // @18D6 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x0c] // @18D7 stack[2] = 0x18eb // @18DA stack[3] = stack[-3] // @18DB stack[4] = 0x18e5 // @18DE stack[5] = msg.sender // @18DF stack[6] = stack[-2] // @18E0 stack[7] = stack[-1] // } // Block ends with call to 0x1e3f, returns to 0x18E5 label_18E5: // Incoming return from call to 0x1E3F at 0x18E4 // Inputs[2] // { // @18E6 stack[-2] // @18E6 stack[-1] // } 18E5 5B JUMPDEST 18E6 90 SWAP1 18E7 61 PUSH2 0x1ece 18EA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @18E6 stack[-1] = stack[-2] // @18E6 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x1ece label_18EB: // Incoming return from call to 0x18E5 at 0x18E4 // Inputs[4] // { // @18F4 stack[-1] // @18F5 stack[-2] // @18F6 stack[-7] // @18F7 stack[-6] // } 18EB 5B JUMPDEST 18EC 60 PUSH1 0x01 18EE 60 PUSH1 0x01 18F0 60 PUSH1 0xa0 18F2 1B SHL 18F3 03 SUB 18F4 16 AND 18F5 14 EQ 18F6 94 SWAP5 18F7 93 SWAP4 18F8 50 POP 18F9 50 POP 18FA 50 POP 18FB 50 POP 18FC 56 *JUMP // Stack delta = -6 // Outputs[1] { @18F6 stack[-7] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_18FD: // Incoming jump from 0x0BAF // Incoming jump from 0x1637 // Incoming jump from 0x0D25 // Inputs[3] // { // @1901 stack[-2] // @1902 stack[-1] // @1905 memory[0x40:0x60] // } 18FD 5B JUMPDEST 18FE 61 PUSH2 0x0c13 1901 82 DUP3 1902 82 DUP3 1903 60 PUSH1 0x40 1905 51 MLOAD 1906 80 DUP1 1907 60 PUSH1 0x20 1909 01 ADD 190A 60 PUSH1 0x40 190C 52 MSTORE 190D 80 DUP1 190E 60 PUSH1 0x00 1910 81 DUP2 1911 52 MSTORE 1912 50 POP 1913 61 PUSH2 0x1ef2 1916 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @18FE stack[0] = 0x0c13 // @1901 stack[1] = stack[-2] // @1902 stack[2] = stack[-1] // @1905 stack[3] = memory[0x40:0x60] // @190C memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1911 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x1ef2 label_1917: // Incoming jump from 0x0BC0 // Incoming jump from 0x151F // Inputs[1] { @191D stack[-1] } 1917 5B JUMPDEST 1918 60 PUSH1 0x00 191A 61 PUSH2 0x1922 191D 82 DUP3 191E 61 PUSH2 0x1b30 1921 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1918 stack[0] = 0x00 // @191A stack[1] = 0x1922 // @191D stack[2] = stack[-1] // } // Block ends with call to 0x1b30, returns to 0x1922 label_1922: // Incoming return from call to 0x1B30 at 0x1921 // Inputs[4] // { // @1923 stack[-1] // @1924 memory[stack[-1]:stack[-1] + 0x20] // @1926 stack[-2] // @1934 msg.sender // } 1922 5B JUMPDEST 1923 80 DUP1 1924 51 MLOAD 1925 90 SWAP1 1926 91 SWAP2 1927 50 POP 1928 60 PUSH1 0x00 192A 90 SWAP1 192B 60 PUSH1 0x01 192D 60 PUSH1 0x01 192F 60 PUSH1 0xa0 1931 1B SHL 1932 03 SUB 1933 16 AND 1934 33 CALLER 1935 60 PUSH1 0x01 1937 60 PUSH1 0x01 1939 60 PUSH1 0xa0 193B 1B SHL 193C 03 SUB 193D 16 AND 193E 14 EQ 193F 80 DUP1 1940 61 PUSH2 0x1959 1943 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1926 stack[-2] = stack[-1] // @192A stack[-1] = 0x00 // @193E stack[0] = (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x1959, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] label_1944: // Incoming jump from 0x1943, if not (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @1945 msg.sender // @1949 stack[-4] // } 1944 50 POP 1945 33 CALLER 1946 61 PUSH2 0x194e 1949 84 DUP5 194A 61 PUSH2 0x097c 194D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1945 stack[-1] = msg.sender // @1946 stack[0] = 0x194e // @1949 stack[1] = stack[-4] // } // Block ends with call to 0x097c, returns to 0x194E label_194E: // Incoming return from call to 0x097C at 0x194D // Inputs[2] // { // @1957 stack[-1] // @1958 stack[-2] // } 194E 5B JUMPDEST 194F 60 PUSH1 0x01 1951 60 PUSH1 0x01 1953 60 PUSH1 0xa0 1955 1B SHL 1956 03 SUB 1957 16 AND 1958 14 EQ // Stack delta = -1 // Outputs[1] { @1958 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1959: // Incoming jump from 0x1943, if (0x01 << 0xa0) - 0x01 & msg.sender == (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x1958 // Inputs[1] { @195A stack[-1] } 1959 5B JUMPDEST 195A 80 DUP1 195B 61 PUSH2 0x196b 195E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x196b, if stack[-1] label_195F: // Incoming jump from 0x195E, if not stack[-1] // Inputs[3] // { // @1960 stack[-3] // @1961 memory[stack[-3]:stack[-3] + 0x20] // @1966 msg.sender // } 195F 50 POP 1960 81 DUP2 1961 51 MLOAD 1962 61 PUSH2 0x196b 1965 90 SWAP1 1966 33 CALLER 1967 61 PUSH2 0x16cd 196A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1965 stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @1965 stack[-1] = 0x196b // @1966 stack[1] = msg.sender // } // Block ends with unconditional jump to 0x16cd label_196B: // Incoming jump from 0x195E, if stack[-1] // Inputs[2] // { // @196C stack[-1] // @196C stack[-2] // } 196B 5B JUMPDEST 196C 90 SWAP1 196D 50 POP 196E 80 DUP1 196F 61 PUSH2 0x198b 1972 57 *JUMPI // Stack delta = -1 // Outputs[1] { @196C stack[-2] = stack[-1] } // Block ends with conditional jump to 0x198b, if stack[-1] label_1973: // Incoming jump from 0x1972, if not stack[-1] // Inputs[3] // { // @1975 memory[0x40:0x60] // @1985 memory[0x40:0x60] // @198A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1973 60 PUSH1 0x40 1975 51 MLOAD 1976 63 PUSH4 0x2ce44b5f 197B 60 PUSH1 0xe1 197D 1B SHL 197E 81 DUP2 197F 52 MSTORE 1980 60 PUSH1 0x04 1982 01 ADD 1983 60 PUSH1 0x40 1985 51 MLOAD 1986 80 DUP1 1987 91 SWAP2 1988 03 SUB 1989 90 SWAP1 198A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @197F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @198A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_198B: // Incoming jump from 0x1972, if stack[-1] // Inputs[3] // { // @198C stack[-5] // @1996 stack[-2] // @199A memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } 198B 5B JUMPDEST 198C 84 DUP5 198D 60 PUSH1 0x01 198F 60 PUSH1 0x01 1991 60 PUSH1 0xa0 1993 1B SHL 1994 03 SUB 1995 16 AND 1996 82 DUP3 1997 60 PUSH1 0x00 1999 01 ADD 199A 51 MLOAD 199B 60 PUSH1 0x01 199D 60 PUSH1 0x01 199F 60 PUSH1 0xa0 19A1 1B SHL 19A2 03 SUB 19A3 16 AND 19A4 14 EQ 19A5 61 PUSH2 0x19c0 19A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19c0, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_19A9: // Incoming jump from 0x19A8, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @19AB memory[0x40:0x60] // @19BA memory[0x40:0x60] // @19BF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19A9 60 PUSH1 0x40 19AB 51 MLOAD 19AC 62 PUSH3 0xa11481 19B0 60 PUSH1 0xe8 19B2 1B SHL 19B3 81 DUP2 19B4 52 MSTORE 19B5 60 PUSH1 0x04 19B7 01 ADD 19B8 60 PUSH1 0x40 19BA 51 MLOAD 19BB 80 DUP1 19BC 91 SWAP2 19BD 03 SUB 19BE 90 SWAP1 19BF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa11481 << 0xe8 // @19BF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_19C0: // Incoming jump from 0x19A8, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[1] { @19C9 stack[-4] } 19C0 5B JUMPDEST 19C1 60 PUSH1 0x01 19C3 60 PUSH1 0x01 19C5 60 PUSH1 0xa0 19C7 1B SHL 19C8 03 SUB 19C9 84 DUP5 19CA 16 AND 19CB 61 PUSH2 0x19e7 19CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19e7, if stack[-4] & (0x01 << 0xa0) - 0x01 label_19CF: // Incoming jump from 0x19CE, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @19D1 memory[0x40:0x60] // @19E1 memory[0x40:0x60] // @19E6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19CF 60 PUSH1 0x40 19D1 51 MLOAD 19D2 63 PUSH4 0x3a954ecd 19D7 60 PUSH1 0xe2 19D9 1B SHL 19DA 81 DUP2 19DB 52 MSTORE 19DC 60 PUSH1 0x04 19DE 01 ADD 19DF 60 PUSH1 0x40 19E1 51 MLOAD 19E2 80 DUP1 19E3 91 SWAP2 19E4 03 SUB 19E5 90 SWAP1 19E6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3a954ecd << 0xe2 // @19E6 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_19E7: // Incoming jump from 0x19CE, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @19ED stack[-3] // @19EE stack[-2] // @19F2 memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } 19E7 5B JUMPDEST 19E8 61 PUSH2 0x19f7 19EB 60 PUSH1 0x00 19ED 84 DUP5 19EE 84 DUP5 19EF 60 PUSH1 0x00 19F1 01 ADD 19F2 51 MLOAD 19F3 61 PUSH2 0x186b 19F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19E8 stack[0] = 0x19f7 // @19EB stack[1] = 0x00 // @19ED stack[2] = stack[-3] // @19F2 stack[3] = memory[0x00 + stack[-2]:0x00 + stack[-2] + 0x20] // } // Block ends with call to 0x186b, returns to 0x19F7 label_19F7: // Incoming return from call to 0x186B at 0x19F6 // Inputs[12] // { // @1A00 stack[-5] // @1A13 memory[0x00:0x40] // @1A15 storage[keccak256(memory[0x00:0x40])] // @1A37 stack[-4] // @1A3F memory[0x00:0x40] // @1A41 storage[keccak256(memory[0x00:0x40])] // @1A57 stack[-3] // @1A61 memory[0x00:0x40] // @1A63 storage[keccak256(memory[0x00:0x40])] // @1A76 block.timestamp // @1A8C memory[0x00:0x40] // @1A8D storage[keccak256(memory[0x00:0x40])] // } 19F7 5B JUMPDEST 19F8 60 PUSH1 0x01 19FA 60 PUSH1 0x01 19FC 60 PUSH1 0xa0 19FE 1B SHL 19FF 03 SUB 1A00 85 DUP6 1A01 81 DUP2 1A02 16 AND 1A03 60 PUSH1 0x00 1A05 90 SWAP1 1A06 81 DUP2 1A07 52 MSTORE 1A08 60 PUSH1 0x04 1A0A 60 PUSH1 0x20 1A0C 90 SWAP1 1A0D 81 DUP2 1A0E 52 MSTORE 1A0F 60 PUSH1 0x40 1A11 80 DUP1 1A12 83 DUP4 1A13 20 SHA3 1A14 80 DUP1 1A15 54 SLOAD 1A16 60 PUSH1 0x01 1A18 60 PUSH1 0x01 1A1A 60 PUSH1 0x80 1A1C 1B SHL 1A1D 03 SUB 1A1E 19 NOT 1A1F 80 DUP1 1A20 82 DUP3 1A21 16 AND 1A22 60 PUSH1 0x01 1A24 60 PUSH1 0x01 1A26 60 PUSH1 0x80 1A28 1B SHL 1A29 03 SUB 1A2A 92 SWAP3 1A2B 83 DUP4 1A2C 16 AND 1A2D 60 PUSH1 0x00 1A2F 19 NOT 1A30 01 ADD 1A31 83 DUP4 1A32 16 AND 1A33 17 OR 1A34 90 SWAP1 1A35 92 SWAP3 1A36 55 SSTORE 1A37 89 DUP10 1A38 86 DUP7 1A39 16 AND 1A3A 80 DUP1 1A3B 86 DUP7 1A3C 52 MSTORE 1A3D 83 DUP4 1A3E 86 DUP7 1A3F 20 SHA3 1A40 80 DUP1 1A41 54 SLOAD 1A42 93 SWAP4 1A43 84 DUP5 1A44 16 AND 1A45 93 SWAP4 1A46 83 DUP4 1A47 16 AND 1A48 60 PUSH1 0x01 1A4A 90 SWAP1 1A4B 81 DUP2 1A4C 01 ADD 1A4D 90 SWAP1 1A4E 93 SWAP4 1A4F 16 AND 1A50 93 SWAP4 1A51 90 SWAP1 1A52 93 SWAP4 1A53 17 OR 1A54 90 SWAP1 1A55 92 SWAP3 1A56 55 SSTORE 1A57 88 DUP9 1A58 85 DUP6 1A59 52 MSTORE 1A5A 60 PUSH1 0x03 1A5C 90 SWAP1 1A5D 93 SWAP4 1A5E 52 MSTORE 1A5F 81 DUP2 1A60 84 DUP5 1A61 20 SHA3 1A62 80 DUP1 1A63 54 SLOAD 1A64 60 PUSH1 0x01 1A66 60 PUSH1 0x01 1A68 60 PUSH1 0xe0 1A6A 1B SHL 1A6B 03 SUB 1A6C 19 NOT 1A6D 16 AND 1A6E 90 SWAP1 1A6F 91 SWAP2 1A70 17 OR 1A71 60 PUSH1 0x01 1A73 60 PUSH1 0xa0 1A75 1B SHL 1A76 42 TIMESTAMP 1A77 67 PUSH8 0xffffffffffffffff 1A80 16 AND 1A81 02 MUL 1A82 17 OR 1A83 90 SWAP1 1A84 55 SSTORE 1A85 90 SWAP1 1A86 86 DUP7 1A87 01 ADD 1A88 80 DUP1 1A89 83 DUP4 1A8A 52 MSTORE 1A8B 91 SWAP2 1A8C 20 SHA3 1A8D 54 SLOAD 1A8E 90 SWAP1 1A8F 91 SWAP2 1A90 16 AND 1A91 61 PUSH2 0x1ae6 1A94 57 *JUMPI // Stack delta = +1 // Outputs[10] // { // @1A07 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1A0E memory[0x20:0x40] = 0x04 // @1A36 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & ~0x00 + ((0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0x80) - 0x01)) // @1A3C memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1A56 storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & 0x01 + ((0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0x80) - 0x01)) // @1A59 memory[0x00:0x20] = stack[-3] // @1A5E memory[0x20:0x40] = 0x03 // @1A84 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1A8A memory[0x00:0x20] = stack[-3] + 0x01 // @1A8F stack[0] = stack[-3] + 0x01 // } // Block ends with conditional jump to 0x1ae6, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1A95: // Incoming jump from 0x1A94, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @1A97 storage[0x00] // @1A98 stack[-1] // } 1A95 60 PUSH1 0x00 1A97 54 SLOAD 1A98 81 DUP2 1A99 10 LT 1A9A 15 ISZERO 1A9B 61 PUSH2 0x1ae6 1A9E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ae6, if !(stack[-1] < storage[0x00]) label_1A9F: // Incoming jump from 0x1A9E, if not !(stack[-1] < storage[0x00]) // Inputs[6] // { // @1A9F stack[-3] // @1AA0 memory[stack[-3]:stack[-3] + 0x20] // @1AA3 stack[-1] // @1AB1 memory[0x00:0x40] // @1AB3 storage[keccak256(memory[0x00:0x40])] // @1AB7 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 1A9F 82 DUP3 1AA0 51 MLOAD 1AA1 60 PUSH1 0x00 1AA3 82 DUP3 1AA4 81 DUP2 1AA5 52 MSTORE 1AA6 60 PUSH1 0x03 1AA8 60 PUSH1 0x20 1AAA 90 SWAP1 1AAB 81 DUP2 1AAC 52 MSTORE 1AAD 60 PUSH1 0x40 1AAF 90 SWAP1 1AB0 91 SWAP2 1AB1 20 SHA3 1AB2 80 DUP1 1AB3 54 SLOAD 1AB4 91 SWAP2 1AB5 86 DUP7 1AB6 01 ADD 1AB7 51 MLOAD 1AB8 67 PUSH8 0xffffffffffffffff 1AC1 16 AND 1AC2 60 PUSH1 0x01 1AC4 60 PUSH1 0xa0 1AC6 1B SHL 1AC7 02 MUL 1AC8 60 PUSH1 0x01 1ACA 60 PUSH1 0x01 1ACC 60 PUSH1 0xe0 1ACE 1B SHL 1ACF 03 SUB 1AD0 19 NOT 1AD1 90 SWAP1 1AD2 92 SWAP3 1AD3 16 AND 1AD4 60 PUSH1 0x01 1AD6 60 PUSH1 0x01 1AD8 60 PUSH1 0xa0 1ADA 1B SHL 1ADB 03 SUB 1ADC 90 SWAP1 1ADD 93 SWAP4 1ADE 16 AND 1ADF 92 SWAP3 1AE0 90 SWAP1 1AE1 92 SWAP3 1AE2 17 OR 1AE3 17 OR 1AE4 90 SWAP1 1AE5 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @1AA5 memory[0x00:0x20] = stack[-1] // @1AAC memory[0x20:0x40] = 0x03 // @1AE5 storage[keccak256(memory[0x00:0x40])] = (memory[stack[-3]:stack[-3] + 0x20] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20]) // } // Block continues label_1AE6: // Incoming jump from 0x1A9E, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x1AE5 // Incoming jump from 0x1A94, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[6] // { // @1AE8 stack[-4] // @1AE9 stack[-5] // @1AF3 stack[-6] // @1B20 memory[0x40:0x60] // @1B23 memory[0x40:0x60] // @1B28 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // } 1AE6 5B JUMPDEST 1AE7 50 POP 1AE8 82 DUP3 1AE9 84 DUP5 1AEA 60 PUSH1 0x01 1AEC 60 PUSH1 0x01 1AEE 60 PUSH1 0xa0 1AF0 1B SHL 1AF1 03 SUB 1AF2 16 AND 1AF3 86 DUP7 1AF4 60 PUSH1 0x01 1AF6 60 PUSH1 0x01 1AF8 60 PUSH1 0xa0 1AFA 1B SHL 1AFB 03 SUB 1AFC 16 AND 1AFD 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1B1E 60 PUSH1 0x40 1B20 51 MLOAD 1B21 60 PUSH1 0x40 1B23 51 MLOAD 1B24 80 DUP1 1B25 91 SWAP2 1B26 03 SUB 1B27 90 SWAP1 1B28 A4 LOG4 // Stack delta = -1 // Outputs[1] { @1B28 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); } // Block continues label_1B29: // Incoming jump from 0x1B28 // Incoming jump from 0x2385 // Inputs[1] { @1B2F stack[-6] } 1B29 5B JUMPDEST 1B2A 50 POP 1B2B 50 POP 1B2C 50 POP 1B2D 50 POP 1B2E 50 POP 1B2F 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_1B30: // Incoming call from 0x0EF7, returns to 0x0EF8 // Incoming call from 0x1921, returns to 0x1922 // Inputs[2] // { // @1B34 memory[0x40:0x60] // @1B48 stack[-1] // } 1B30 5B JUMPDEST 1B31 60 PUSH1 0x40 1B33 80 DUP1 1B34 51 MLOAD 1B35 80 DUP1 1B36 82 DUP3 1B37 01 ADD 1B38 90 SWAP1 1B39 91 SWAP2 1B3A 52 MSTORE 1B3B 60 PUSH1 0x00 1B3D 80 DUP1 1B3E 82 DUP3 1B3F 52 MSTORE 1B40 60 PUSH1 0x20 1B42 82 DUP3 1B43 01 ADD 1B44 52 MSTORE 1B45 61 PUSH2 0x1b4d 1B48 82 DUP3 1B49 61 PUSH2 0x1856 1B4C 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @1B39 stack[0] = memory[0x40:0x60] // @1B3A memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1B3F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1B44 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1B45 stack[1] = 0x1b4d // @1B48 stack[2] = stack[-1] // } // Block ends with call to 0x1856, returns to 0x1B4D label_1B4D: // Incoming return from call to 0x1856 at 0x1B4C // Inputs[1] { @1B51 stack[-1] } 1B4D 5B JUMPDEST 1B4E 61 PUSH2 0x1b6a 1B51 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b6a, if stack[-1] label_1B52: // Incoming jump from 0x1B51, if not stack[-1] // Inputs[3] // { // @1B54 memory[0x40:0x60] // @1B64 memory[0x40:0x60] // @1B69 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B52 60 PUSH1 0x40 1B54 51 MLOAD 1B55 63 PUSH4 0x6f96cda1 1B5A 60 PUSH1 0xe1 1B5C 1B SHL 1B5D 81 DUP2 1B5E 52 MSTORE 1B5F 60 PUSH1 0x04 1B61 01 ADD 1B62 60 PUSH1 0x40 1B64 51 MLOAD 1B65 80 DUP1 1B66 91 SWAP2 1B67 03 SUB 1B68 90 SWAP1 1B69 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B5E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6f96cda1 << 0xe1 // @1B69 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B6A: // Incoming jump from 0x1B51, if stack[-1] // Inputs[1] { @1B6D stack[-2] } 1B6A 5B JUMPDEST 1B6B 60 PUSH1 0x01 1B6D 82 DUP3 1B6E 5B JUMPDEST 1B6F 81 DUP2 1B70 81 DUP2 1B71 10 LT 1B72 61 PUSH2 0x1bcd 1B75 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B6B stack[0] = 0x01 // @1B6D stack[1] = stack[-2] // } // Block ends with conditional jump to 0x1bcd, if stack[-2] < 0x01 label_1B76: // Incoming jump from 0x1B75, if not stack[-2] < 0x01 // Incoming jump from 0x1B75, if not stack[-1] < stack[-2] // Inputs[4] // { // @1B78 stack[-1] // @1B87 memory[0x00:0x40] // @1B89 memory[0x40:0x60] // @1B90 storage[keccak256(memory[0x00:0x40])] // } 1B76 60 PUSH1 0x00 1B78 81 DUP2 1B79 81 DUP2 1B7A 52 MSTORE 1B7B 60 PUSH1 0x03 1B7D 60 PUSH1 0x20 1B7F 90 SWAP1 1B80 81 DUP2 1B81 52 MSTORE 1B82 60 PUSH1 0x40 1B84 91 SWAP2 1B85 82 DUP3 1B86 90 SWAP1 1B87 20 SHA3 1B88 82 DUP3 1B89 51 MLOAD 1B8A 80 DUP1 1B8B 84 DUP5 1B8C 01 ADD 1B8D 90 SWAP1 1B8E 93 SWAP4 1B8F 52 MSTORE 1B90 54 SLOAD 1B91 60 PUSH1 0x01 1B93 60 PUSH1 0x01 1B95 60 PUSH1 0xa0 1B97 1B SHL 1B98 03 SUB 1B99 81 DUP2 1B9A 16 AND 1B9B 80 DUP1 1B9C 84 DUP5 1B9D 52 MSTORE 1B9E 60 PUSH1 0x01 1BA0 60 PUSH1 0xa0 1BA2 1B SHL 1BA3 90 SWAP1 1BA4 91 SWAP2 1BA5 04 DIV 1BA6 67 PUSH8 0xffffffffffffffff 1BAF 16 AND 1BB0 91 SWAP2 1BB1 83 DUP4 1BB2 01 ADD 1BB3 91 SWAP2 1BB4 90 SWAP1 1BB5 91 SWAP2 1BB6 52 MSTORE 1BB7 15 ISZERO 1BB8 61 PUSH2 0x1bc3 1BBB 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @1B7A memory[0x00:0x20] = stack[-1] // @1B81 memory[0x20:0x40] = 0x03 // @1B8E stack[0] = memory[0x40:0x60] // @1B8F memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1B9D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1BB6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // } // Block ends with conditional jump to 0x1bc3, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_1BBC: // Incoming jump from 0x1BBB, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1BBC stack[-1] // @1BBC stack[-6] // @1BBD stack[-5] // } 1BBC 94 SWAP5 1BBD 93 SWAP4 1BBE 50 POP 1BBF 50 POP 1BC0 50 POP 1BC1 50 POP 1BC2 56 *JUMP // Stack delta = -5 // Outputs[1] { @1BBC stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1BC3: // Incoming jump from 0x1BBB, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @1BC8 stack[-2] } 1BC3 5B JUMPDEST 1BC4 50 POP 1BC5 60 PUSH1 0x00 1BC7 19 NOT 1BC8 01 ADD 1BC9 61 PUSH2 0x1b6e 1BCC 56 *JUMP // Stack delta = -1 // Outputs[1] { @1BC8 stack[-2] = ~0x00 + stack[-2] } // Block ends with unconditional jump to 0x1b6e label_1BCD: // Incoming jump from 0x1B75, if stack[-2] < 0x01 // Incoming jump from 0x1B75, if stack[-1] < stack[-2] // Inputs[3] // { // @1BD0 stack[-5] // @1BD0 stack[-3] // @1BD1 stack[-4] // } 1BCD 5B JUMPDEST 1BCE 50 POP 1BCF 50 POP 1BD0 91 SWAP2 1BD1 90 SWAP1 1BD2 50 POP 1BD3 56 *JUMP // Stack delta = -4 // Outputs[1] { @1BD0 stack[-5] = stack[-3] } // Block ends with unconditional jump to stack[-5] label_1BD4: // Incoming call from 0x1855, returns to 0x0D26 // Incoming call from 0x0FB0, returns to 0x0FB1 // Inputs[5] // { // @1BD8 storage[0x07] // @1BE1 stack[-1] // @1BF6 memory[0x40:0x60] // @1C22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1C25 stack[-2] // } 1BD4 5B JUMPDEST 1BD5 60 PUSH1 0x07 1BD7 80 DUP1 1BD8 54 SLOAD 1BD9 60 PUSH1 0x01 1BDB 60 PUSH1 0x01 1BDD 60 PUSH1 0xa0 1BDF 1B SHL 1BE0 03 SUB 1BE1 83 DUP4 1BE2 81 DUP2 1BE3 16 AND 1BE4 60 PUSH1 0x01 1BE6 60 PUSH1 0x01 1BE8 60 PUSH1 0xa0 1BEA 1B SHL 1BEB 03 SUB 1BEC 19 NOT 1BED 83 DUP4 1BEE 16 AND 1BEF 81 DUP2 1BF0 17 OR 1BF1 90 SWAP1 1BF2 93 SWAP4 1BF3 55 SSTORE 1BF4 60 PUSH1 0x40 1BF6 51 MLOAD 1BF7 91 SWAP2 1BF8 16 AND 1BF9 91 SWAP2 1BFA 90 SWAP1 1BFB 82 DUP3 1BFC 90 SWAP1 1BFD 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1C1E 90 SWAP1 1C1F 60 PUSH1 0x00 1C21 90 SWAP1 1C22 A3 LOG3 1C23 50 POP 1C24 50 POP 1C25 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1BF3 storage[0x07] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x07] & ~((0x01 << 0xa0) - 0x01)) // @1C22 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x07] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1C26: // Incoming call from 0x129F, returns to 0x0D26 // Incoming jump from 0x11DB // Inputs[8] // { // @1C29 stack[-2] // @1C33 stack[-1] // @1C36 memory[0x40:0x60] // @1C3B memory[0x40:0x60] // @1C42 msg.gas // @1C43 address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1C43 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1C48 returndata.length // } 1C26 5B JUMPDEST 1C27 60 PUSH1 0x00 1C29 82 DUP3 1C2A 60 PUSH1 0x01 1C2C 60 PUSH1 0x01 1C2E 60 PUSH1 0xa0 1C30 1B SHL 1C31 03 SUB 1C32 16 AND 1C33 82 DUP3 1C34 60 PUSH1 0x40 1C36 51 MLOAD 1C37 60 PUSH1 0x00 1C39 60 PUSH1 0x40 1C3B 51 MLOAD 1C3C 80 DUP1 1C3D 83 DUP4 1C3E 03 SUB 1C3F 81 DUP2 1C40 85 DUP6 1C41 87 DUP8 1C42 5A GAS 1C43 F1 CALL 1C44 92 SWAP3 1C45 50 POP 1C46 50 POP 1C47 50 POP 1C48 3D RETURNDATASIZE 1C49 80 DUP1 1C4A 60 PUSH1 0x00 1C4C 81 DUP2 1C4D 14 EQ 1C4E 61 PUSH2 0x1c73 1C51 57 *JUMPI // Stack delta = +4 // Outputs[5] // { // @1C27 stack[0] = 0x00 // @1C43 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1C44 stack[1] = address((0x01 << 0xa0) - 0x01 & stack[-2]).call.gas(msg.gas).value(stack[-1])(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @1C48 stack[2] = returndata.length // @1C49 stack[3] = returndata.length // } // Block ends with conditional jump to 0x1c73, if returndata.length == 0x00 label_1C52: // Incoming jump from 0x1C51, if not returndata.length == 0x00 // Inputs[6] // { // @1C54 memory[0x40:0x60] // @1C55 stack[-2] // @1C5C returndata.length // @1C64 returndata.length // @1C67 returndata.length // @1C6E returndata[0x00:0x00 + returndata.length] // } 1C52 60 PUSH1 0x40 1C54 51 MLOAD 1C55 91 SWAP2 1C56 50 POP 1C57 60 PUSH1 0x1f 1C59 19 NOT 1C5A 60 PUSH1 0x3f 1C5C 3D RETURNDATASIZE 1C5D 01 ADD 1C5E 16 AND 1C5F 82 DUP3 1C60 01 ADD 1C61 60 PUSH1 0x40 1C63 52 MSTORE 1C64 3D RETURNDATASIZE 1C65 82 DUP3 1C66 52 MSTORE 1C67 3D RETURNDATASIZE 1C68 60 PUSH1 0x00 1C6A 60 PUSH1 0x20 1C6C 84 DUP5 1C6D 01 ADD 1C6E 3E RETURNDATACOPY 1C6F 61 PUSH2 0x1c78 1C72 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1C55 stack[-2] = memory[0x40:0x60] // @1C63 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1C66 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1C6E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1c78 label_1C73: // Incoming jump from 0x1C51, if returndata.length == 0x00 // Inputs[3] // { // @1C76 stack[-2] // @1C7B stack[-4] // @1C7B stack[-3] // } 1C73 5B JUMPDEST 1C74 60 PUSH1 0x60 1C76 91 SWAP2 1C77 50 POP 1C78 5B JUMPDEST 1C79 50 POP 1C7A 50 POP 1C7B 90 SWAP1 1C7C 50 POP 1C7D 80 DUP1 1C7E 61 PUSH2 0x0a49 1C81 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1C7B stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0a49, if stack[-3] label_1C82: // Incoming jump from 0x1C81, if not stack[-3] // Incoming jump from 0x1C81, if not stack[-3] // Inputs[1] { @1C84 memory[0x40:0x60] } 1C82 60 PUSH1 0x40 1C84 51 MLOAD 1C85 62 PUSH3 0x461bcd 1C89 60 PUSH1 0xe5 1C8B 1B SHL 1C8C 81 DUP2 1C8D 52 MSTORE 1C8E 60 PUSH1 0x20 1C90 60 PUSH1 0x04 1C92 82 DUP3 1C93 01 ADD 1C94 52 MSTORE 1C95 60 PUSH1 0x0f 1C97 60 PUSH1 0x24 1C99 82 DUP3 1C9A 01 ADD 1C9B 52 MSTORE 1C9C 6E PUSH15 0x1d1c985b9cd9995c8819985a5b1959 1CAC 60 PUSH1 0x8a 1CAE 1B SHL 1CAF 60 PUSH1 0x44 1CB1 82 DUP3 1CB2 01 ADD 1CB3 52 MSTORE 1CB4 60 PUSH1 0x64 1CB6 01 ADD 1CB7 61 PUSH2 0x08bf 1CBA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1C8D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1C94 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1C9B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0f // @1CB3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x1d1c985b9cd9995c8819985a5b1959 << 0x8a // @1CB6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_1CBB: // Incoming call from 0x2350, returns to 0x2351 // Inputs[2] // { // @1CC6 stack[-3] // @1CC8 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 1CBB 5B JUMPDEST 1CBC 60 PUSH1 0x00 1CBE 60 PUSH1 0x01 1CC0 60 PUSH1 0x01 1CC2 60 PUSH1 0xa0 1CC4 1B SHL 1CC5 03 SUB 1CC6 84 DUP5 1CC7 16 AND 1CC8 3B EXTCODESIZE 1CC9 15 ISZERO 1CCA 61 PUSH2 0x1daf 1CCD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CBC stack[0] = 0x00 } // Block ends with conditional jump to 0x1daf, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_1CCE: // Incoming jump from 0x1CCD, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[6] // { // @1CD0 memory[0x40:0x60] // @1CE3 stack[-4] // @1CF0 msg.sender // @1CF2 stack[-5] // @1CF4 stack[-3] // @1CF6 stack[-2] // } 1CCE 60 PUSH1 0x40 1CD0 51 MLOAD 1CD1 63 PUSH4 0x0a85bd01 1CD6 60 PUSH1 0xe1 1CD8 1B SHL 1CD9 81 DUP2 1CDA 52 MSTORE 1CDB 60 PUSH1 0x01 1CDD 60 PUSH1 0x01 1CDF 60 PUSH1 0xa0 1CE1 1B SHL 1CE2 03 SUB 1CE3 85 DUP6 1CE4 16 AND 1CE5 90 SWAP1 1CE6 63 PUSH4 0x150b7a02 1CEB 90 SWAP1 1CEC 61 PUSH2 0x1cff 1CEF 90 SWAP1 1CF0 33 CALLER 1CF1 90 SWAP1 1CF2 89 DUP10 1CF3 90 SWAP1 1CF4 88 DUP9 1CF5 90 SWAP1 1CF6 88 DUP9 1CF7 90 SWAP1 1CF8 60 PUSH1 0x04 1CFA 01 ADD 1CFB 61 PUSH2 0x2b46 1CFE 56 *JUMP // Stack delta = +8 // Outputs[9] // { // @1CDA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1CE5 stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1CEB stack[1] = 0x150b7a02 // @1CEF stack[2] = 0x1cff // @1CF1 stack[3] = msg.sender // @1CF3 stack[4] = stack[-5] // @1CF5 stack[5] = stack[-3] // @1CF7 stack[6] = stack[-2] // @1CFA stack[7] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2b46, returns to 0x1CFF label_1CFF: // Incoming return from call to 0x2B46 at 0x1CFE // Inputs[6] // { // @1D04 memory[0x40:0x60] // @1D06 stack[-1] // @1D0B stack[-3] // @1D0C msg.gas // @1D0D memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1D0D address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } 1CFF 5B JUMPDEST 1D00 60 PUSH1 0x20 1D02 60 PUSH1 0x40 1D04 51 MLOAD 1D05 80 DUP1 1D06 83 DUP4 1D07 03 SUB 1D08 81 DUP2 1D09 60 PUSH1 0x00 1D0B 87 DUP8 1D0C 5A GAS 1D0D F1 CALL 1D0E 92 SWAP3 1D0F 50 POP 1D10 50 POP 1D11 50 POP 1D12 80 DUP1 1D13 15 ISZERO 1D14 61 PUSH2 0x1d3a 1D17 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1D0D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1D0E stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1d3a, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1D18: // Incoming jump from 0x1D17, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @1D1C memory[0x40:0x60] // @1D1F returndata.length // } 1D18 50 POP 1D19 60 PUSH1 0x40 1D1B 80 DUP1 1D1C 51 MLOAD 1D1D 60 PUSH1 0x1f 1D1F 3D RETURNDATASIZE 1D20 90 SWAP1 1D21 81 DUP2 1D22 01 ADD 1D23 60 PUSH1 0x1f 1D25 19 NOT 1D26 16 AND 1D27 82 DUP3 1D28 01 ADD 1D29 90 SWAP1 1D2A 92 SWAP3 1D2B 52 MSTORE 1D2C 61 PUSH2 0x1d37 1D2F 91 SWAP2 1D30 81 DUP2 1D31 01 ADD 1D32 90 SWAP1 1D33 61 PUSH2 0x2b83 1D36 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1D2B memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1D2F stack[-1] = 0x1d37 // @1D32 stack[1] = memory[0x40:0x60] // @1D32 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2b83 1D37 5B JUMPDEST 1D38 60 PUSH1 0x01 label_1D3A: // Incoming jump from 0x1D17, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @1D3E stack[-1] } 1D3A 5B JUMPDEST 1D3B 61 PUSH2 0x1d95 1D3E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1d95, if stack[-1] label_1D3F: // Incoming jump from 0x1D3E, if not stack[-1] // Inputs[1] { @1D3F returndata.length } 1D3F 3D RETURNDATASIZE 1D40 80 DUP1 1D41 80 DUP1 1D42 15 ISZERO 1D43 61 PUSH2 0x1d68 1D46 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D3F stack[0] = returndata.length // @1D40 stack[1] = returndata.length // } // Block ends with conditional jump to 0x1d68, if !returndata.length label_1D47: // Incoming jump from 0x1D46, if not !returndata.length // Inputs[6] // { // @1D49 memory[0x40:0x60] // @1D4A stack[-2] // @1D51 returndata.length // @1D59 returndata.length // @1D5C returndata.length // @1D63 returndata[0x00:0x00 + returndata.length] // } 1D47 60 PUSH1 0x40 1D49 51 MLOAD 1D4A 91 SWAP2 1D4B 50 POP 1D4C 60 PUSH1 0x1f 1D4E 19 NOT 1D4F 60 PUSH1 0x3f 1D51 3D RETURNDATASIZE 1D52 01 ADD 1D53 16 AND 1D54 82 DUP3 1D55 01 ADD 1D56 60 PUSH1 0x40 1D58 52 MSTORE 1D59 3D RETURNDATASIZE 1D5A 82 DUP3 1D5B 52 MSTORE 1D5C 3D RETURNDATASIZE 1D5D 60 PUSH1 0x00 1D5F 60 PUSH1 0x20 1D61 84 DUP5 1D62 01 ADD 1D63 3E RETURNDATACOPY 1D64 61 PUSH2 0x1d6d 1D67 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1D4A stack[-2] = memory[0x40:0x60] // @1D58 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1D5B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1D63 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1d6d label_1D68: // Incoming jump from 0x1D46, if !returndata.length // Inputs[2] // { // @1D6B stack[-2] // @1D70 memory[0x60:0x80] // } 1D68 5B JUMPDEST 1D69 60 PUSH1 0x60 1D6B 91 SWAP2 1D6C 50 POP 1D6D 5B JUMPDEST 1D6E 50 POP 1D6F 80 DUP1 1D70 51 MLOAD 1D71 61 PUSH2 0x1d8d 1D74 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1D6B stack[-2] = 0x60 } // Block ends with conditional jump to 0x1d8d, if memory[0x60:0x80] label_1D75: // Incoming jump from 0x1D74, if not memory[0x60:0x80] // Incoming jump from 0x1D74, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1D77 memory[0x40:0x60] // @1D87 memory[0x40:0x60] // @1D8C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1D75 60 PUSH1 0x40 1D77 51 MLOAD 1D78 63 PUSH4 0x68d2bf6b 1D7D 60 PUSH1 0xe1 1D7F 1B SHL 1D80 81 DUP2 1D81 52 MSTORE 1D82 60 PUSH1 0x04 1D84 01 ADD 1D85 60 PUSH1 0x40 1D87 51 MLOAD 1D88 80 DUP1 1D89 91 SWAP2 1D8A 03 SUB 1D8B 90 SWAP1 1D8C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D81 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1D8C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1D8D: // Incoming jump from 0x1D74, if memory[0x60:0x80] // Incoming jump from 0x1D74, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1D8E stack[-1] // @1D8F memory[stack[-1]:stack[-1] + 0x20] // @1D94 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1D8D 5B JUMPDEST 1D8E 80 DUP1 1D8F 51 MLOAD 1D90 81 DUP2 1D91 60 PUSH1 0x20 1D93 01 ADD 1D94 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D94 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1D95: // Incoming jump from 0x1D3E, if stack[-1] // Inputs[2] // { // @1D9F stack[-1] // @1DA9 stack[-2] // } 1D95 5B JUMPDEST 1D96 60 PUSH1 0x01 1D98 60 PUSH1 0x01 1D9A 60 PUSH1 0xe0 1D9C 1B SHL 1D9D 03 SUB 1D9E 19 NOT 1D9F 16 AND 1DA0 63 PUSH4 0x0a85bd01 1DA5 60 PUSH1 0xe1 1DA7 1B SHL 1DA8 14 EQ 1DA9 90 SWAP1 1DAA 50 POP 1DAB 61 PUSH2 0x1786 1DAE 56 *JUMP // Stack delta = -1 // Outputs[1] { @1DA9 stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block ends with unconditional jump to 0x1786 label_1DAF: // Incoming jump from 0x1CCD, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[2] // { // @1DB3 stack[-6] // @1DB4 stack[-5] // } 1DAF 5B JUMPDEST 1DB0 50 POP 1DB1 60 PUSH1 0x01 1DB3 94 SWAP5 1DB4 93 SWAP4 1DB5 50 POP 1DB6 50 POP 1DB7 50 POP 1DB8 50 POP 1DB9 56 *JUMP // Stack delta = -5 // Outputs[1] { @1DB3 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_1DBA: // Incoming jump from 0x1642 // Inputs[1] { @1DC0 stack[-1] } 1DBA 5B JUMPDEST 1DBB 60 PUSH1 0x60 1DBD 61 PUSH2 0x1dc5 1DC0 82 DUP3 1DC1 61 PUSH2 0x1856 1DC4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DBB stack[0] = 0x60 // @1DBD stack[1] = 0x1dc5 // @1DC0 stack[2] = stack[-1] // } // Block ends with call to 0x1856, returns to 0x1DC5 label_1DC5: // Incoming return from call to 0x1856 at 0x1DC4 // Inputs[1] { @1DC9 stack[-1] } 1DC5 5B JUMPDEST 1DC6 61 PUSH2 0x1de2 1DC9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1de2, if stack[-1] label_1DCA: // Incoming jump from 0x1DC9, if not stack[-1] // Inputs[3] // { // @1DCC memory[0x40:0x60] // @1DDC memory[0x40:0x60] // @1DE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1DCA 60 PUSH1 0x40 1DCC 51 MLOAD 1DCD 63 PUSH4 0x0a14c4b5 1DD2 60 PUSH1 0xe4 1DD4 1B SHL 1DD5 81 DUP2 1DD6 52 MSTORE 1DD7 60 PUSH1 0x04 1DD9 01 ADD 1DDA 60 PUSH1 0x40 1DDC 51 MLOAD 1DDD 80 DUP1 1DDE 91 SWAP2 1DDF 03 SUB 1DE0 90 SWAP1 1DE1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1DD6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a14c4b5 << 0xe4 // @1DE1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1DE2: // Incoming jump from 0x1DC9, if stack[-1] 1DE2 5B JUMPDEST 1DE3 60 PUSH1 0x00 1DE5 61 PUSH2 0x1dec 1DE8 61 PUSH2 0x1eff 1DEB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DE3 stack[0] = 0x00 // @1DE5 stack[1] = 0x1dec // } // Block ends with unconditional jump to 0x1eff 1DEC 5B JUMPDEST 1DED 90 SWAP1 1DEE 50 POP 1DEF 80 DUP1 1DF0 51 MLOAD 1DF1 60 PUSH1 0x00 1DF3 14 EQ 1DF4 15 ISZERO 1DF5 61 PUSH2 0x1e0d 1DF8 57 *JUMPI 1DF9 60 PUSH1 0x40 1DFB 51 MLOAD 1DFC 80 DUP1 1DFD 60 PUSH1 0x20 1DFF 01 ADD 1E00 60 PUSH1 0x40 1E02 52 MSTORE 1E03 80 DUP1 1E04 60 PUSH1 0x00 1E06 81 DUP2 1E07 52 MSTORE 1E08 50 POP 1E09 61 PUSH2 0x1e38 1E0C 56 *JUMP 1E0D 5B JUMPDEST 1E0E 80 DUP1 1E0F 61 PUSH2 0x1e17 1E12 84 DUP5 1E13 61 PUSH2 0x1f0e 1E16 56 *JUMP 1E17 5B JUMPDEST 1E18 60 PUSH1 0x40 1E1A 51 MLOAD 1E1B 60 PUSH1 0x20 1E1D 01 ADD 1E1E 61 PUSH2 0x1e28 1E21 92 SWAP3 1E22 91 SWAP2 1E23 90 SWAP1 1E24 61 PUSH2 0x2ba0 1E27 56 *JUMP 1E28 5B JUMPDEST 1E29 60 PUSH1 0x40 1E2B 51 MLOAD 1E2C 60 PUSH1 0x20 1E2E 81 DUP2 1E2F 83 DUP4 1E30 03 SUB 1E31 03 SUB 1E32 81 DUP2 1E33 52 MSTORE 1E34 90 SWAP1 1E35 60 PUSH1 0x40 1E37 52 MSTORE label_1E38: // Incoming return from call to 0x253B at 0x2B9F // Incoming return from call to 0x253B at 0x256D // Incoming return from call to 0x256E at 0x2B45 // Incoming return from call to 0x256E at 0x259F // Incoming return from call to 0x25CC at 0x260A // Inputs[3] // { // @1E39 stack[-1] // @1E39 stack[-5] // @1E3A stack[-4] // } 1E38 5B JUMPDEST 1E39 93 SWAP4 1E3A 92 SWAP3 1E3B 50 POP 1E3C 50 POP 1E3D 50 POP 1E3E 56 *JUMP // Stack delta = -4 // Outputs[1] { @1E39 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1E3F: // Incoming call from 0x18E4, returns to 0x18E5 // Inputs[11] // { // @1E43 memory[0x40:0x60] // @1E44 address(this) // @1E56 stack[-3] // @1E60 stack[-2] // @1E68 stack[-1] // @1E6C memory[0x40:0x60] // @1E7C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1E80 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @1EB1 memory[0x40:0x60] // @1EC3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1EC6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 1E3F 5B JUMPDEST 1E40 60 PUSH1 0x40 1E42 80 DUP1 1E43 51 MLOAD 1E44 30 ADDRESS 1E45 60 PUSH1 0x20 1E47 80 DUP1 1E48 83 DUP4 1E49 01 ADD 1E4A 91 SWAP2 1E4B 90 SWAP1 1E4C 91 SWAP2 1E4D 52 MSTORE 1E4E 60 PUSH1 0x01 1E50 60 PUSH1 0x01 1E52 60 PUSH1 0xa0 1E54 1B SHL 1E55 03 SUB 1E56 86 DUP7 1E57 16 AND 1E58 82 DUP3 1E59 84 DUP5 1E5A 01 ADD 1E5B 52 MSTORE 1E5C 60 PUSH1 0x60 1E5E 82 DUP3 1E5F 01 ADD 1E60 85 DUP6 1E61 90 SWAP1 1E62 52 MSTORE 1E63 60 PUSH1 0x80 1E65 80 DUP1 1E66 83 DUP4 1E67 01 ADD 1E68 85 DUP6 1E69 90 SWAP1 1E6A 52 MSTORE 1E6B 83 DUP4 1E6C 51 MLOAD 1E6D 80 DUP1 1E6E 84 DUP5 1E6F 03 SUB 1E70 90 SWAP1 1E71 91 SWAP2 1E72 01 ADD 1E73 81 DUP2 1E74 52 MSTORE 1E75 60 PUSH1 0xa0 1E77 83 DUP4 1E78 01 ADD 1E79 84 DUP5 1E7A 52 MSTORE 1E7B 80 DUP1 1E7C 51 MLOAD 1E7D 90 SWAP1 1E7E 82 DUP3 1E7F 01 ADD 1E80 20 SHA3 1E81 7F PUSH32 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 1EA2 60 PUSH1 0xc0 1EA4 84 DUP5 1EA5 01 ADD 1EA6 52 MSTORE 1EA7 60 PUSH1 0xdc 1EA9 80 DUP1 1EAA 84 DUP5 1EAB 01 ADD 1EAC 91 SWAP2 1EAD 90 SWAP1 1EAE 91 SWAP2 1EAF 52 MSTORE 1EB0 83 DUP4 1EB1 51 MLOAD 1EB2 80 DUP1 1EB3 84 DUP5 1EB4 03 SUB 1EB5 90 SWAP1 1EB6 91 SWAP2 1EB7 01 ADD 1EB8 81 DUP2 1EB9 52 MSTORE 1EBA 60 PUSH1 0xfc 1EBC 90 SWAP1 1EBD 92 SWAP3 1EBE 01 ADD 1EBF 90 SWAP1 1EC0 92 SWAP3 1EC1 52 MSTORE 1EC2 80 DUP1 1EC3 51 MLOAD 1EC4 91 SWAP2 1EC5 01 ADD 1EC6 20 SHA3 1EC7 60 PUSH1 0x00 1EC9 90 SWAP1 1ECA 61 PUSH2 0x1786 1ECD 56 *JUMP // Stack delta = +2 // Outputs[12] // { // @1E4D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = address(this) // @1E5B memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1E62 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-2] // @1E6A memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-1] // @1E74 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x80 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1E7A memory[0x40:0x60] = memory[0x40:0x60] + 0xa0 // @1EA6 memory[memory[0x40:0x60] + 0xc0:memory[0x40:0x60] + 0xc0 + 0x20] = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 // @1EAF memory[memory[0x40:0x60] + 0xdc:memory[0x40:0x60] + 0xdc + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1EB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xdc + (memory[0x40:0x60] - memory[0x40:0x60]) // @1EC1 memory[0x40:0x60] = memory[0x40:0x60] + 0xfc // @1EC9 stack[0] = 0x00 // @1EC9 stack[1] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to 0x1786 label_1ECE: // Incoming jump from 0x18EA // Inputs[2] // { // @1ED7 stack[-2] // @1ED8 stack[-1] // } 1ECE 5B JUMPDEST 1ECF 60 PUSH1 0x00 1ED1 80 DUP1 1ED2 60 PUSH1 0x00 1ED4 61 PUSH2 0x1edd 1ED7 85 DUP6 1ED8 85 DUP6 1ED9 61 PUSH2 0x200c 1EDC 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1ECF stack[0] = 0x00 // @1ED1 stack[1] = 0x00 // @1ED2 stack[2] = 0x00 // @1ED4 stack[3] = 0x1edd // @1ED7 stack[4] = stack[-2] // @1ED8 stack[5] = stack[-1] // } // Block ends with call to 0x200c, returns to 0x1EDD label_1EDD: // Incoming return from call to 0x200C at 0x1EDC // Incoming return from call to 0x200C at 0x1EDC // Inputs[4] // { // @1EDE stack[-3] // @1EDE stack[-1] // @1EE0 stack[-2] // @1EE0 stack[-4] // } 1EDD 5B JUMPDEST 1EDE 91 SWAP2 1EDF 50 POP 1EE0 91 SWAP2 1EE1 50 POP 1EE2 61 PUSH2 0x1eea 1EE5 81 DUP2 1EE6 61 PUSH2 0x207c 1EE9 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1EDE stack[-3] = stack[-1] // @1EE0 stack[-4] = stack[-2] // @1EE2 stack[-2] = 0x1eea // @1EE5 stack[-1] = stack[-1] // } // Block ends with call to 0x207c, returns to 0x1EEA label_1EEA: // Incoming return from call to 0x207C at 0x1EE9 // Inputs[3] // { // @1EEC stack[-6] // @1EEC stack[-2] // @1EED stack[-5] // } 1EEA 5B JUMPDEST 1EEB 50 POP 1EEC 93 SWAP4 1EED 92 SWAP3 1EEE 50 POP 1EEF 50 POP 1EF0 50 POP 1EF1 56 *JUMP // Stack delta = -5 // Outputs[1] { @1EEC stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1EF2: // Incoming jump from 0x1916 // Inputs[3] // { // @1EF6 stack[-3] // @1EF7 stack[-2] // @1EF8 stack[-1] // } 1EF2 5B JUMPDEST 1EF3 61 PUSH2 0x0a49 1EF6 83 DUP4 1EF7 83 DUP4 1EF8 83 DUP4 1EF9 60 PUSH1 0x01 1EFB 61 PUSH2 0x2237 1EFE 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1EF3 stack[0] = 0x0a49 // @1EF6 stack[1] = stack[-3] // @1EF7 stack[2] = stack[-2] // @1EF8 stack[3] = stack[-1] // @1EF9 stack[4] = 0x01 // } // Block ends with call to 0x2237, returns to 0x0A49 label_1EFF: // Incoming jump from 0x1DEB // Inputs[1] { @1F05 storage[0x17] } 1EFF 5B JUMPDEST 1F00 60 PUSH1 0x60 1F02 60 PUSH1 0x17 1F04 80 DUP1 1F05 54 SLOAD 1F06 61 PUSH2 0x08f9 1F09 90 SWAP1 1F0A 61 PUSH2 0x292e 1F0D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F00 stack[0] = 0x60 // @1F02 stack[1] = 0x17 // @1F09 stack[2] = 0x08f9 // @1F09 stack[3] = storage[0x17] // } // Block ends with call to 0x292e, returns to 0x08F9 1F0E 5B JUMPDEST 1F0F 60 PUSH1 0x60 1F11 81 DUP2 1F12 61 PUSH2 0x1f32 1F15 57 *JUMPI 1F16 50 POP 1F17 50 POP 1F18 60 PUSH1 0x40 1F1A 80 DUP1 1F1B 51 MLOAD 1F1C 80 DUP1 1F1D 82 DUP3 1F1E 01 ADD 1F1F 90 SWAP1 1F20 91 SWAP2 1F21 52 MSTORE 1F22 60 PUSH1 0x01 1F24 81 DUP2 1F25 52 MSTORE 1F26 60 PUSH1 0x03 1F28 60 PUSH1 0xfc 1F2A 1B SHL 1F2B 60 PUSH1 0x20 1F2D 82 DUP3 1F2E 01 ADD 1F2F 52 MSTORE 1F30 90 SWAP1 1F31 56 *JUMP 1F32 5B JUMPDEST 1F33 81 DUP2 1F34 60 PUSH1 0x00 1F36 5B JUMPDEST 1F37 81 DUP2 1F38 15 ISZERO 1F39 61 PUSH2 0x1f5c 1F3C 57 *JUMPI 1F3D 80 DUP1 1F3E 61 PUSH2 0x1f46 1F41 81 DUP2 1F42 61 PUSH2 0x2bcf 1F45 56 *JUMP 1F46 5B JUMPDEST 1F47 91 SWAP2 1F48 50 POP 1F49 61 PUSH2 0x1f55 1F4C 90 SWAP1 1F4D 50 POP 1F4E 60 PUSH1 0x0a 1F50 83 DUP4 1F51 61 PUSH2 0x2a64 1F54 56 *JUMP 1F55 5B JUMPDEST 1F56 91 SWAP2 1F57 50 POP 1F58 61 PUSH2 0x1f36 1F5B 56 *JUMP 1F5C 5B JUMPDEST 1F5D 60 PUSH1 0x00 1F5F 81 DUP2 1F60 67 PUSH8 0xffffffffffffffff 1F69 81 DUP2 1F6A 11 GT 1F6B 15 ISZERO 1F6C 61 PUSH2 0x1f77 1F6F 57 *JUMPI 1F70 61 PUSH2 0x1f77 1F73 61 PUSH2 0x2711 1F76 56 *JUMP 1F77 5B JUMPDEST 1F78 60 PUSH1 0x40 1F7A 51 MLOAD 1F7B 90 SWAP1 1F7C 80 DUP1 1F7D 82 DUP3 1F7E 52 MSTORE 1F7F 80 DUP1 1F80 60 PUSH1 0x1f 1F82 01 ADD 1F83 60 PUSH1 0x1f 1F85 19 NOT 1F86 16 AND 1F87 60 PUSH1 0x20 1F89 01 ADD 1F8A 82 DUP3 1F8B 01 ADD 1F8C 60 PUSH1 0x40 1F8E 52 MSTORE 1F8F 80 DUP1 1F90 15 ISZERO 1F91 61 PUSH2 0x1fa1 1F94 57 *JUMPI 1F95 60 PUSH1 0x20 1F97 82 DUP3 1F98 01 ADD 1F99 81 DUP2 1F9A 80 DUP1 1F9B 36 CALLDATASIZE 1F9C 83 DUP4 1F9D 37 CALLDATACOPY 1F9E 01 ADD 1F9F 90 SWAP1 1FA0 50 POP 1FA1 5B JUMPDEST 1FA2 50 POP 1FA3 90 SWAP1 1FA4 50 POP 1FA5 5B JUMPDEST 1FA6 84 DUP5 1FA7 15 ISZERO 1FA8 61 PUSH2 0x1786 1FAB 57 *JUMPI 1FAC 61 PUSH2 0x1fb6 1FAF 60 PUSH1 0x01 1FB1 83 DUP4 1FB2 61 PUSH2 0x2be3 1FB5 56 *JUMP 1FB6 5B JUMPDEST 1FB7 91 SWAP2 1FB8 50 POP 1FB9 61 PUSH2 0x1fc3 1FBC 60 PUSH1 0x0a 1FBE 86 DUP7 1FBF 61 PUSH2 0x2bfa 1FC2 56 *JUMP 1FC3 5B JUMPDEST 1FC4 61 PUSH2 0x1fce 1FC7 90 SWAP1 1FC8 60 PUSH1 0x30 1FCA 61 PUSH2 0x29a1 1FCD 56 *JUMP 1FCE 5B JUMPDEST 1FCF 60 PUSH1 0xf8 1FD1 1B SHL 1FD2 81 DUP2 1FD3 83 DUP4 1FD4 81 DUP2 1FD5 51 MLOAD 1FD6 81 DUP2 1FD7 10 LT 1FD8 61 PUSH2 0x1fe3 1FDB 57 *JUMPI 1FDC 61 PUSH2 0x1fe3 1FDF 61 PUSH2 0x2c0e 1FE2 56 *JUMP 1FE3 5B JUMPDEST 1FE4 60 PUSH1 0x20 1FE6 01 ADD 1FE7 01 ADD 1FE8 90 SWAP1 1FE9 60 PUSH1 0x01 1FEB 60 PUSH1 0x01 1FED 60 PUSH1 0xf8 1FEF 1B SHL 1FF0 03 SUB 1FF1 19 NOT 1FF2 16 AND 1FF3 90 SWAP1 1FF4 81 DUP2 1FF5 60 PUSH1 0x00 1FF7 1A BYTE 1FF8 90 SWAP1 1FF9 53 MSTORE8 1FFA 50 POP 1FFB 61 PUSH2 0x2005 1FFE 60 PUSH1 0x0a 2000 86 DUP7 2001 61 PUSH2 0x2a64 2004 56 *JUMP 2005 5B JUMPDEST 2006 94 SWAP5 2007 50 POP 2008 61 PUSH2 0x1fa5 200B 56 *JUMP label_200C: // Incoming call from 0x1EDC, returns to 0x1EDD // Inputs[2] // { // @2010 stack[-1] // @2011 memory[stack[-1]:stack[-1] + 0x20] // } 200C 5B JUMPDEST 200D 60 PUSH1 0x00 200F 80 DUP1 2010 82 DUP3 2011 51 MLOAD 2012 60 PUSH1 0x41 2014 14 EQ 2015 15 ISZERO 2016 61 PUSH2 0x2043 2019 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @200D stack[0] = 0x00 // @200F stack[1] = 0x00 // } // Block ends with conditional jump to 0x2043, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) label_201A: // Incoming jump from 0x2019, if not !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @201C stack[-3] // @201E memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2023 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @2028 memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @202F stack[-4] // } 201A 60 PUSH1 0x20 201C 83 DUP4 201D 01 ADD 201E 51 MLOAD 201F 60 PUSH1 0x40 2021 84 DUP5 2022 01 ADD 2023 51 MLOAD 2024 60 PUSH1 0x60 2026 85 DUP6 2027 01 ADD 2028 51 MLOAD 2029 60 PUSH1 0x00 202B 1A BYTE 202C 61 PUSH2 0x2037 202F 87 DUP8 2030 82 DUP3 2031 85 DUP6 2032 85 DUP6 2033 61 PUSH2 0x2386 2036 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @201E stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2023 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @202B stack[2] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @202C stack[3] = 0x2037 // @202F stack[4] = stack[-4] // @2030 stack[5] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @2031 stack[6] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2032 stack[7] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x2386, returns to 0x2037 label_2037: // Incoming return from call to 0x2386 at 0x2036 // Inputs[4] // { // @2038 stack[-6] // @2038 stack[-1] // @203A stack[-2] // @203A stack[-7] // } 2037 5B JUMPDEST 2038 94 SWAP5 2039 50 POP 203A 94 SWAP5 203B 50 POP 203C 50 POP 203D 50 POP 203E 50 POP 203F 61 PUSH2 0x2075 2042 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @2038 stack[-6] = stack[-1] // @203A stack[-7] = stack[-2] // } // Block ends with unconditional jump to 0x2075 label_2043: // Incoming jump from 0x2019, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @2044 stack[-3] // @2045 memory[stack[-3]:stack[-3] + 0x20] // } 2043 5B JUMPDEST 2044 82 DUP3 2045 51 MLOAD 2046 60 PUSH1 0x40 2048 14 EQ 2049 15 ISZERO 204A 61 PUSH2 0x206d 204D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x206d, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) label_204E: // Incoming jump from 0x204D, if not !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @2050 stack[-3] // @2052 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2057 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @205B stack[-4] // } 204E 60 PUSH1 0x20 2050 83 DUP4 2051 01 ADD 2052 51 MLOAD 2053 60 PUSH1 0x40 2055 84 DUP5 2056 01 ADD 2057 51 MLOAD 2058 61 PUSH2 0x2062 205B 86 DUP7 205C 83 DUP4 205D 83 DUP4 205E 61 PUSH2 0x2473 2061 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2052 stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2057 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @2058 stack[2] = 0x2062 // @205B stack[3] = stack[-4] // @205C stack[4] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @205D stack[5] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x2473, returns to 0x2062 label_2062: // Incoming return from call to 0x2473 at 0x2061 // Inputs[4] // { // @2063 stack[-5] // @2063 stack[-1] // @2065 stack[-6] // @2065 stack[-2] // } 2062 5B JUMPDEST 2063 93 SWAP4 2064 50 POP 2065 93 SWAP4 2066 50 POP 2067 50 POP 2068 50 POP 2069 61 PUSH2 0x2075 206C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2063 stack[-5] = stack[-1] // @2065 stack[-6] = stack[-2] // } // Block ends with unconditional jump to 0x2075 label_206D: // Incoming jump from 0x204D, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @2071 stack[-2] // @2076 stack[-4] // @2078 stack[-5] // @2079 stack[-3] // } 206D 5B JUMPDEST 206E 50 POP 206F 60 PUSH1 0x00 2071 90 SWAP1 2072 50 POP 2073 60 PUSH1 0x02 2075 5B JUMPDEST 2076 92 SWAP3 2077 50 POP 2078 92 SWAP3 2079 90 SWAP1 207A 50 POP 207B 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2076 stack[-4] = 0x02 // @2078 stack[-5] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_207C: // Incoming call from 0x1EE9, returns to 0x1EEA // Inputs[1] { @207F stack[-1] } 207C 5B JUMPDEST 207D 60 PUSH1 0x00 207F 81 DUP2 2080 60 PUSH1 0x04 2082 81 DUP2 2083 11 GT 2084 15 ISZERO 2085 61 PUSH2 0x2090 2088 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @207D stack[0] = 0x00 // @207F stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2090, if !(stack[-1] > 0x04) label_2089: // Incoming jump from 0x2088, if not !(stack[-1] > 0x04) 2089 61 PUSH2 0x2090 208C 61 PUSH2 0x29db 208F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2089 stack[0] = 0x2090 } // Block ends with unconditional jump to 0x29db label_2090: // Incoming jump from 0x2088, if !(stack[-1] > 0x04) // Inputs[2] // { // @2091 stack[-1] // @2091 stack[-2] // } 2090 5B JUMPDEST 2091 14 EQ 2092 15 ISZERO 2093 61 PUSH2 0x2099 2096 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2099, if !(stack[-1] == stack[-2]) label_2097: // Incoming jump from 0x2096, if not !(stack[-1] == stack[-2]) // Inputs[1] { @2098 stack[-2] } 2097 50 POP 2098 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_2099: // Incoming jump from 0x2096, if !(stack[-1] == stack[-2]) // Inputs[1] { @209C stack[-1] } 2099 5B JUMPDEST 209A 60 PUSH1 0x01 209C 81 DUP2 209D 60 PUSH1 0x04 209F 81 DUP2 20A0 11 GT 20A1 15 ISZERO 20A2 61 PUSH2 0x20ad 20A5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @209A stack[0] = 0x01 // @209C stack[1] = stack[-1] // } // Block ends with conditional jump to 0x20ad, if !(stack[-1] > 0x04) label_20A6: // Incoming jump from 0x20A5, if not !(stack[-1] > 0x04) 20A6 61 PUSH2 0x20ad 20A9 61 PUSH2 0x29db 20AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @20A6 stack[0] = 0x20ad } // Block ends with unconditional jump to 0x29db label_20AD: // Incoming jump from 0x20A5, if !(stack[-1] > 0x04) // Inputs[2] // { // @20AE stack[-2] // @20AE stack[-1] // } 20AD 5B JUMPDEST 20AE 14 EQ 20AF 15 ISZERO 20B0 61 PUSH2 0x20fb 20B3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x20fb, if !(stack[-1] == stack[-2]) label_20B4: // Incoming jump from 0x20B3, if not !(stack[-1] == stack[-2]) // Inputs[1] { @20B6 memory[0x40:0x60] } 20B4 60 PUSH1 0x40 20B6 51 MLOAD 20B7 62 PUSH3 0x461bcd 20BB 60 PUSH1 0xe5 20BD 1B SHL 20BE 81 DUP2 20BF 52 MSTORE 20C0 60 PUSH1 0x20 20C2 60 PUSH1 0x04 20C4 82 DUP3 20C5 01 ADD 20C6 52 MSTORE 20C7 60 PUSH1 0x18 20C9 60 PUSH1 0x24 20CB 82 DUP3 20CC 01 ADD 20CD 52 MSTORE 20CE 7F PUSH32 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 20EF 60 PUSH1 0x44 20F1 82 DUP3 20F2 01 ADD 20F3 52 MSTORE 20F4 60 PUSH1 0x64 20F6 01 ADD 20F7 61 PUSH2 0x08bf 20FA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @20BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @20C6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @20CD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @20F3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 // @20F6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_20FB: // Incoming jump from 0x20B3, if !(stack[-1] == stack[-2]) // Inputs[1] { @20FE stack[-1] } 20FB 5B JUMPDEST 20FC 60 PUSH1 0x02 20FE 81 DUP2 20FF 60 PUSH1 0x04 2101 81 DUP2 2102 11 GT 2103 15 ISZERO 2104 61 PUSH2 0x210f 2107 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20FC stack[0] = 0x02 // @20FE stack[1] = stack[-1] // } // Block ends with conditional jump to 0x210f, if !(stack[-1] > 0x04) label_2108: // Incoming jump from 0x2107, if not !(stack[-1] > 0x04) 2108 61 PUSH2 0x210f 210B 61 PUSH2 0x29db 210E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2108 stack[0] = 0x210f } // Block ends with unconditional jump to 0x29db label_210F: // Incoming jump from 0x2107, if !(stack[-1] > 0x04) // Inputs[2] // { // @2110 stack[-1] // @2110 stack[-2] // } 210F 5B JUMPDEST 2110 14 EQ 2111 15 ISZERO 2112 61 PUSH2 0x215d 2115 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x215d, if !(stack[-1] == stack[-2]) label_2116: // Incoming jump from 0x2115, if not !(stack[-1] == stack[-2]) // Inputs[1] { @2118 memory[0x40:0x60] } 2116 60 PUSH1 0x40 2118 51 MLOAD 2119 62 PUSH3 0x461bcd 211D 60 PUSH1 0xe5 211F 1B SHL 2120 81 DUP2 2121 52 MSTORE 2122 60 PUSH1 0x20 2124 60 PUSH1 0x04 2126 82 DUP3 2127 01 ADD 2128 52 MSTORE 2129 60 PUSH1 0x1f 212B 60 PUSH1 0x24 212D 82 DUP3 212E 01 ADD 212F 52 MSTORE 2130 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 2151 60 PUSH1 0x44 2153 82 DUP3 2154 01 ADD 2155 52 MSTORE 2156 60 PUSH1 0x64 2158 01 ADD 2159 61 PUSH2 0x08bf 215C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2121 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2128 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @212F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @2155 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 // @2158 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_215D: // Incoming jump from 0x2115, if !(stack[-1] == stack[-2]) // Inputs[1] { @2160 stack[-1] } 215D 5B JUMPDEST 215E 60 PUSH1 0x03 2160 81 DUP2 2161 60 PUSH1 0x04 2163 81 DUP2 2164 11 GT 2165 15 ISZERO 2166 61 PUSH2 0x2171 2169 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @215E stack[0] = 0x03 // @2160 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x2171, if !(stack[-1] > 0x04) label_216A: // Incoming jump from 0x2169, if not !(stack[-1] > 0x04) 216A 61 PUSH2 0x2171 216D 61 PUSH2 0x29db 2170 56 *JUMP // Stack delta = +1 // Outputs[1] { @216A stack[0] = 0x2171 } // Block ends with unconditional jump to 0x29db label_2171: // Incoming jump from 0x2169, if !(stack[-1] > 0x04) // Inputs[2] // { // @2172 stack[-2] // @2172 stack[-1] // } 2171 5B JUMPDEST 2172 14 EQ 2173 15 ISZERO 2174 61 PUSH2 0x21ca 2177 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x21ca, if !(stack[-1] == stack[-2]) label_2178: // Incoming jump from 0x2177, if not !(stack[-1] == stack[-2]) // Inputs[1] { @217A memory[0x40:0x60] } 2178 60 PUSH1 0x40 217A 51 MLOAD 217B 62 PUSH3 0x461bcd 217F 60 PUSH1 0xe5 2181 1B SHL 2182 81 DUP2 2183 52 MSTORE 2184 60 PUSH1 0x20 2186 60 PUSH1 0x04 2188 82 DUP3 2189 01 ADD 218A 52 MSTORE 218B 60 PUSH1 0x22 218D 60 PUSH1 0x24 218F 82 DUP3 2190 01 ADD 2191 52 MSTORE 2192 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 21B3 60 PUSH1 0x44 21B5 82 DUP3 21B6 01 ADD 21B7 52 MSTORE 21B8 61 PUSH2 0x7565 21BB 60 PUSH1 0xf0 21BD 1B SHL 21BE 60 PUSH1 0x64 21C0 82 DUP3 21C1 01 ADD 21C2 52 MSTORE 21C3 60 PUSH1 0x84 21C5 01 ADD 21C6 61 PUSH2 0x08bf 21C9 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @2183 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @218A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2191 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @21B7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c // @21C2 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @21C5 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_21CA: // Incoming jump from 0x2177, if !(stack[-1] == stack[-2]) // Inputs[1] { @21CD stack[-1] } 21CA 5B JUMPDEST 21CB 60 PUSH1 0x04 21CD 81 DUP2 21CE 60 PUSH1 0x04 21D0 81 DUP2 21D1 11 GT 21D2 15 ISZERO 21D3 61 PUSH2 0x21de 21D6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21CB stack[0] = 0x04 // @21CD stack[1] = stack[-1] // } // Block ends with conditional jump to 0x21de, if !(stack[-1] > 0x04) label_21D7: // Incoming jump from 0x21D6, if not !(stack[-1] > 0x04) 21D7 61 PUSH2 0x21de 21DA 61 PUSH2 0x29db 21DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @21D7 stack[0] = 0x21de } // Block ends with unconditional jump to 0x29db label_21DE: // Incoming jump from 0x21D6, if !(stack[-1] > 0x04) // Inputs[2] // { // @21DF stack[-2] // @21DF stack[-1] // } 21DE 5B JUMPDEST 21DF 14 EQ 21E0 15 ISZERO 21E1 61 PUSH2 0x0d26 21E4 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0d26, if !(stack[-1] == stack[-2]) label_21E5: // Incoming jump from 0x21E4, if not !(stack[-1] == stack[-2]) // Inputs[1] { @21E7 memory[0x40:0x60] } 21E5 60 PUSH1 0x40 21E7 51 MLOAD 21E8 62 PUSH3 0x461bcd 21EC 60 PUSH1 0xe5 21EE 1B SHL 21EF 81 DUP2 21F0 52 MSTORE 21F1 60 PUSH1 0x20 21F3 60 PUSH1 0x04 21F5 82 DUP3 21F6 01 ADD 21F7 52 MSTORE 21F8 60 PUSH1 0x22 21FA 60 PUSH1 0x24 21FC 82 DUP3 21FD 01 ADD 21FE 52 MSTORE 21FF 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 2220 60 PUSH1 0x44 2222 82 DUP3 2223 01 ADD 2224 52 MSTORE 2225 61 PUSH2 0x7565 2228 60 PUSH1 0xf0 222A 1B SHL 222B 60 PUSH1 0x64 222D 82 DUP3 222E 01 ADD 222F 52 MSTORE 2230 60 PUSH1 0x84 2232 01 ADD 2233 61 PUSH2 0x08bf 2236 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @21F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @21F7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @21FE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @2224 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c // @222F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @2232 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x08bf label_2237: // Incoming call from 0x1EFE, returns to 0x0A49 // Inputs[2] // { // @223A storage[0x00] // @2243 stack[-4] // } 2237 5B JUMPDEST 2238 60 PUSH1 0x00 223A 54 SLOAD 223B 60 PUSH1 0x01 223D 60 PUSH1 0x01 223F 60 PUSH1 0xa0 2241 1B SHL 2242 03 SUB 2243 85 DUP6 2244 16 AND 2245 61 PUSH2 0x2260 2248 57 *JUMPI // Stack delta = +1 // Outputs[1] { @223A stack[0] = storage[0x00] } // Block ends with conditional jump to 0x2260, if stack[-4] & (0x01 << 0xa0) - 0x01 label_2249: // Incoming jump from 0x2248, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @224B memory[0x40:0x60] // @225A memory[0x40:0x60] // @225F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2249 60 PUSH1 0x40 224B 51 MLOAD 224C 62 PUSH3 0x2e0763 2250 60 PUSH1 0xe8 2252 1B SHL 2253 81 DUP2 2254 52 MSTORE 2255 60 PUSH1 0x04 2257 01 ADD 2258 60 PUSH1 0x40 225A 51 MLOAD 225B 80 DUP1 225C 91 SWAP2 225D 03 SUB 225E 90 SWAP1 225F FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2254 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e0763 << 0xe8 // @225F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2260: // Incoming jump from 0x2248, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2261 stack[-4] } 2260 5B JUMPDEST 2261 83 DUP4 2262 61 PUSH2 0x227e 2265 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x227e, if stack[-4] label_2266: // Incoming jump from 0x2265, if not stack[-4] // Inputs[3] // { // @2268 memory[0x40:0x60] // @2278 memory[0x40:0x60] // @227D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2266 60 PUSH1 0x40 2268 51 MLOAD 2269 63 PUSH4 0xb562e8dd 226E 60 PUSH1 0xe0 2270 1B SHL 2271 81 DUP2 2272 52 MSTORE 2273 60 PUSH1 0x04 2275 01 ADD 2276 60 PUSH1 0x40 2278 51 MLOAD 2279 80 DUP1 227A 91 SWAP2 227B 03 SUB 227C 90 SWAP1 227D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2272 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd << 0xe0 // @227D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_227E: // Incoming jump from 0x2265, if stack[-4] // Inputs[8] // { // @2287 stack[-5] // @2299 memory[0x00:0x40] // @229B storage[keccak256(memory[0x00:0x40])] // @22B7 stack[-4] // @22CC stack[-1] // @22D5 memory[0x00:0x40] // @22D7 storage[keccak256(memory[0x00:0x40])] // @22EA block.timestamp // } 227E 5B JUMPDEST 227F 60 PUSH1 0x01 2281 60 PUSH1 0x01 2283 60 PUSH1 0xa0 2285 1B SHL 2286 03 SUB 2287 85 DUP6 2288 16 AND 2289 60 PUSH1 0x00 228B 81 DUP2 228C 81 DUP2 228D 52 MSTORE 228E 60 PUSH1 0x04 2290 60 PUSH1 0x20 2292 90 SWAP1 2293 81 DUP2 2294 52 MSTORE 2295 60 PUSH1 0x40 2297 80 DUP1 2298 83 DUP4 2299 20 SHA3 229A 80 DUP1 229B 54 SLOAD 229C 60 PUSH1 0x01 229E 60 PUSH1 0x80 22A0 1B SHL 22A1 60 PUSH1 0x01 22A3 60 PUSH1 0x01 22A5 60 PUSH1 0x80 22A7 1B SHL 22A8 03 SUB 22A9 19 NOT 22AA 82 DUP3 22AB 16 AND 22AC 60 PUSH1 0x01 22AE 60 PUSH1 0x01 22B0 60 PUSH1 0x80 22B2 1B SHL 22B3 03 SUB 22B4 92 SWAP3 22B5 83 DUP4 22B6 16 AND 22B7 8C DUP13 22B8 01 ADD 22B9 83 DUP4 22BA 16 AND 22BB 90 SWAP1 22BC 81 DUP2 22BD 17 OR 22BE 82 DUP3 22BF 90 SWAP1 22C0 04 DIV 22C1 83 DUP4 22C2 16 AND 22C3 8C DUP13 22C4 01 ADD 22C5 90 SWAP1 22C6 92 SWAP3 22C7 16 AND 22C8 02 MUL 22C9 17 OR 22CA 90 SWAP1 22CB 55 SSTORE 22CC 84 DUP5 22CD 83 DUP4 22CE 52 MSTORE 22CF 60 PUSH1 0x03 22D1 90 SWAP1 22D2 91 SWAP2 22D3 52 MSTORE 22D4 81 DUP2 22D5 20 SHA3 22D6 80 DUP1 22D7 54 SLOAD 22D8 60 PUSH1 0x01 22DA 60 PUSH1 0x01 22DC 60 PUSH1 0xe0 22DE 1B SHL 22DF 03 SUB 22E0 19 NOT 22E1 16 AND 22E2 90 SWAP1 22E3 92 SWAP3 22E4 17 OR 22E5 60 PUSH1 0x01 22E7 60 PUSH1 0xa0 22E9 1B SHL 22EA 42 TIMESTAMP 22EB 67 PUSH8 0xffffffffffffffff 22F4 16 AND 22F5 02 MUL 22F6 17 OR 22F7 90 SWAP1 22F8 91 SWAP2 22F9 55 SSTORE 22FA 81 DUP2 22FB 90 SWAP1 22FC 5B JUMPDEST 22FD 85 DUP6 22FE 81 DUP2 22FF 10 LT 2300 15 ISZERO 2301 61 PUSH2 0x237d 2304 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @228D memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @2294 memory[0x20:0x40] = 0x04 // @22CB storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0x80) - 0x01 & stack[-4] + ((0x01 << 0x80) - 0x01 & (((0x01 << 0x80) - 0x01 & stack[-4] + ((0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0x80) - 0x01))) / (0x01 << 0x80))) * (0x01 << 0x80) | ((0x01 << 0x80) - 0x01 & stack[-4] + ((0x01 << 0x80) - 0x01 & storage[keccak256(memory[0x00:0x40])])) // @22CE memory[0x00:0x20] = stack[-1] // @22D3 memory[0x20:0x40] = 0x03 // @22F9 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @22FB stack[0] = stack[-1] // @22FB stack[1] = 0x00 // } // Block ends with conditional jump to 0x237d, if !(0x00 < stack[-4]) label_2305: // Incoming call from 0x2304, returns to 0x0000, if not !(0x00 < stack[-4]) // Incoming jump from 0x2304, if not !(stack[-1] < stack[-6]) // Inputs[5] // { // @2307 memory[0x40:0x60] // @2308 stack[-2] // @2312 stack[-7] // @233C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @233D stack[-4] // } 2305 60 PUSH1 0x40 2307 51 MLOAD 2308 82 DUP3 2309 90 SWAP1 230A 60 PUSH1 0x01 230C 60 PUSH1 0x01 230E 60 PUSH1 0xa0 2310 1B SHL 2311 03 SUB 2312 89 DUP10 2313 16 AND 2314 90 SWAP1 2315 60 PUSH1 0x00 2317 90 SWAP1 2318 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2339 90 SWAP1 233A 82 DUP3 233B 90 SWAP1 233C A4 LOG4 233D 83 DUP4 233E 80 DUP1 233F 15 ISZERO 2340 61 PUSH2 0x2353 2343 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @233C log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @233D stack[0] = stack[-4] // } // Block ends with conditional jump to 0x2353, if !stack[-4] label_2344: // Incoming jump from 0x2343, if not !stack[-4] // Inputs[3] // { // @234A stack[-8] // @234B stack[-3] // @234C stack[-6] // } 2344 50 POP 2345 61 PUSH2 0x2351 2348 60 PUSH1 0x00 234A 88 DUP9 234B 84 DUP5 234C 88 DUP9 234D 61 PUSH2 0x1cbb 2350 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2345 stack[-1] = 0x2351 // @2348 stack[0] = 0x00 // @234A stack[1] = stack[-8] // @234B stack[2] = stack[-3] // @234C stack[3] = stack[-6] // } // Block ends with call to 0x1cbb, returns to 0x2351 label_2351: // Incoming return from call to 0x1CBB at 0x2350 // Inputs[1] { @2352 stack[-1] } 2351 5B JUMPDEST 2352 15 ISZERO // Stack delta = +0 // Outputs[1] { @2352 stack[-1] = !stack[-1] } // Block continues label_2353: // Incoming jump from 0x2352 // Incoming jump from 0x2343, if !stack[-4] // Inputs[1] { @2354 stack[-1] } 2353 5B JUMPDEST 2354 15 ISZERO 2355 61 PUSH2 0x2371 2358 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2371, if !stack[-1] label_2359: // Incoming jump from 0x2358, if not !stack[-1] // Inputs[3] // { // @235B memory[0x40:0x60] // @236B memory[0x40:0x60] // @2370 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2359 60 PUSH1 0x40 235B 51 MLOAD 235C 63 PUSH4 0x68d2bf6b 2361 60 PUSH1 0xe1 2363 1B SHL 2364 81 DUP2 2365 52 MSTORE 2366 60 PUSH1 0x04 2368 01 ADD 2369 60 PUSH1 0x40 236B 51 MLOAD 236C 80 DUP1 236D 91 SWAP2 236E 03 SUB 236F 90 SWAP1 2370 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2365 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @2370 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2371: // Incoming jump from 0x2358, if !stack[-1] // Inputs[2] // { // @2374 stack[-2] // @2378 stack[-1] // } 2371 5B JUMPDEST 2372 60 PUSH1 0x01 2374 91 SWAP2 2375 82 DUP3 2376 01 ADD 2377 91 SWAP2 2378 01 ADD 2379 61 PUSH2 0x22fc 237C 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2377 stack[-2] = 0x01 + stack[-2] // @2378 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x22fc label_237D: // Incoming jump from 0x2304, if !(0x00 < stack[-4]) // Incoming jump from 0x2304, if !(stack[-1] < stack[-6]) // Inputs[1] { @2381 stack[-2] } 237D 5B JUMPDEST 237E 50 POP 237F 60 PUSH1 0x00 2381 55 SSTORE 2382 61 PUSH2 0x1b29 2385 56 *JUMP // Stack delta = -2 // Outputs[1] { @2381 storage[0x00] = stack[-2] } // Block ends with unconditional jump to 0x1b29 label_2386: // Incoming call from 0x2036, returns to 0x2037 // Incoming call from 0x2493, returns to 0x2494 // Inputs[1] { @23AB stack[-1] } 2386 5B JUMPDEST 2387 60 PUSH1 0x00 2389 80 DUP1 238A 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 23AB 83 DUP4 23AC 11 GT 23AD 15 ISZERO 23AE 61 PUSH2 0x23bd 23B1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2387 stack[0] = 0x00 // @2389 stack[1] = 0x00 // } // Block ends with conditional jump to 0x23bd, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) label_23B2: // Incoming jump from 0x23B1, if not !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @23B5 stack[-2] } 23B2 50 POP 23B3 60 PUSH1 0x00 23B5 90 SWAP1 23B6 50 POP 23B7 60 PUSH1 0x03 23B9 61 PUSH2 0x246a 23BC 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @23B5 stack[-2] = 0x00 // @23B7 stack[-1] = 0x03 // } // Block ends with unconditional jump to 0x246a label_23BD: // Incoming jump from 0x23B1, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @23BE stack[-5] } 23BD 5B JUMPDEST 23BE 84 DUP5 23BF 60 PUSH1 0xff 23C1 16 AND 23C2 60 PUSH1 0x1b 23C4 14 EQ 23C5 15 ISZERO 23C6 80 DUP1 23C7 15 ISZERO 23C8 61 PUSH2 0x23d5 23CB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23C5 stack[0] = !(0x1b == 0xff & stack[-5]) } // Block ends with conditional jump to 0x23d5, if !!(0x1b == 0xff & stack[-5]) label_23CC: // Incoming jump from 0x23CB, if not !!(0x1b == 0xff & stack[-5]) // Inputs[1] { @23CD stack[-6] } 23CC 50 POP 23CD 84 DUP5 23CE 60 PUSH1 0xff 23D0 16 AND 23D1 60 PUSH1 0x1c 23D3 14 EQ 23D4 15 ISZERO 23D5 5B JUMPDEST 23D6 15 ISZERO 23D7 61 PUSH2 0x23e6 23DA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x23e6, if !!(0x1c == 0xff & stack[-6]) label_23DB: // Incoming jump from 0x23DA, if not !stack[-1] // Incoming jump from 0x23DA, if not !!(0x1c == 0xff & stack[-6]) // Inputs[1] { @23DE stack[-2] } 23DB 50 POP 23DC 60 PUSH1 0x00 23DE 90 SWAP1 23DF 50 POP 23E0 60 PUSH1 0x04 23E2 61 PUSH2 0x246a 23E5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @23DE stack[-2] = 0x00 // @23E0 stack[-1] = 0x04 // } // Block ends with unconditional jump to 0x246a label_23E6: // Incoming jump from 0x23DA, if !stack[-1] // Incoming jump from 0x23DA, if !!(0x1c == 0xff & stack[-6]) // Inputs[9] // { // @23EA memory[0x40:0x60] // @23F7 stack[-6] // @23FC stack[-5] // @2409 stack[-4] // @2410 stack[-3] // @241D memory[0x40:0x60] // @2428 msg.gas // @2429 address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @2429 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 23E6 5B JUMPDEST 23E7 60 PUSH1 0x40 23E9 80 DUP1 23EA 51 MLOAD 23EB 60 PUSH1 0x00 23ED 80 DUP1 23EE 82 DUP3 23EF 52 MSTORE 23F0 60 PUSH1 0x20 23F2 82 DUP3 23F3 01 ADD 23F4 80 DUP1 23F5 84 DUP5 23F6 52 MSTORE 23F7 89 DUP10 23F8 90 SWAP1 23F9 52 MSTORE 23FA 60 PUSH1 0xff 23FC 88 DUP9 23FD 16 AND 23FE 92 SWAP3 23FF 82 DUP3 2400 01 ADD 2401 92 SWAP3 2402 90 SWAP1 2403 92 SWAP3 2404 52 MSTORE 2405 60 PUSH1 0x60 2407 81 DUP2 2408 01 ADD 2409 86 DUP7 240A 90 SWAP1 240B 52 MSTORE 240C 60 PUSH1 0x80 240E 81 DUP2 240F 01 ADD 2410 85 DUP6 2411 90 SWAP1 2412 52 MSTORE 2413 60 PUSH1 0x01 2415 90 SWAP1 2416 60 PUSH1 0xa0 2418 01 ADD 2419 60 PUSH1 0x20 241B 60 PUSH1 0x40 241D 51 MLOAD 241E 60 PUSH1 0x20 2420 81 DUP2 2421 03 SUB 2422 90 SWAP1 2423 80 DUP1 2424 84 DUP5 2425 03 SUB 2426 90 SWAP1 2427 85 DUP6 2428 5A GAS 2429 FA STATICCALL 242A 15 ISZERO 242B 80 DUP1 242C 15 ISZERO 242D 61 PUSH2 0x243a 2430 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @23EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @23F6 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @23F9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-6] // @2403 stack[0] = 0x00 // @2404 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-5] & 0xff // @240B memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-4] // @2412 memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-3] // @2415 stack[1] = 0x01 // @2418 stack[2] = 0xa0 + memory[0x40:0x60] // @2429 memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @242A stack[3] = !address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x243a, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_2431: // Incoming jump from 0x2430, if not !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @2431 returndata.length // @2435 returndata[0x00:0x00 + returndata.length] // @2436 returndata.length // @2439 memory[0x00:0x00 + returndata.length] // } 2431 3D RETURNDATASIZE 2432 60 PUSH1 0x00 2434 80 DUP1 2435 3E RETURNDATACOPY 2436 3D RETURNDATASIZE 2437 60 PUSH1 0x00 2439 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2435 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @2439 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_243A: // Incoming jump from 0x2430, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[3] // { // @243F memory[0x40:0x60] // @2444 memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @2445 stack[-4] // } 243A 5B JUMPDEST 243B 50 POP 243C 50 POP 243D 60 PUSH1 0x40 243F 51 MLOAD 2440 60 PUSH1 0x1f 2442 19 NOT 2443 01 ADD 2444 51 MLOAD 2445 91 SWAP2 2446 50 POP 2447 50 POP 2448 60 PUSH1 0x01 244A 60 PUSH1 0x01 244C 60 PUSH1 0xa0 244E 1B SHL 244F 03 SUB 2450 81 DUP2 2451 16 AND 2452 61 PUSH2 0x2463 2455 57 *JUMPI // Stack delta = -3 // Outputs[1] { @2445 stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] } // Block ends with conditional jump to 0x2463, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 label_2456: // Incoming jump from 0x2455, if not memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @245A stack[-2] // @245C stack[-3] // } 2456 60 PUSH1 0x00 2458 60 PUSH1 0x01 245A 92 SWAP3 245B 50 POP 245C 92 SWAP3 245D 50 POP 245E 50 POP 245F 61 PUSH2 0x246a 2462 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @245A stack[-2] = 0x01 // @245C stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x246a label_2463: // Incoming jump from 0x2455, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2464 stack[-1] // @2464 stack[-3] // @2468 stack[-2] // } 2463 5B JUMPDEST 2464 91 SWAP2 2465 50 POP 2466 60 PUSH1 0x00 2468 90 SWAP1 2469 50 POP // Stack delta = -1 // Outputs[2] // { // @2464 stack[-3] = stack[-1] // @2468 stack[-2] = 0x00 // } // Block continues label_246A: // Incoming jump from 0x23BC // Incoming jump from 0x2469 // Incoming jump from 0x23E5 // Incoming jump from 0x2462 // Inputs[5] // { // @246B stack[-1] // @246B stack[-6] // @246D stack[-7] // @246D stack[-2] // @246E stack[-5] // } 246A 5B JUMPDEST 246B 94 SWAP5 246C 50 POP 246D 94 SWAP5 246E 92 SWAP3 246F 50 POP 2470 50 POP 2471 50 POP 2472 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @246B stack[-6] = stack[-1] // @246D stack[-7] = stack[-2] // } // Block ends with unconditional jump to stack[-7] label_2473: // Incoming call from 0x2061, returns to 0x2062 // Inputs[3] // { // @247F stack[-1] // @248C stack[-3] // @248E stack[-2] // } 2473 5B JUMPDEST 2474 60 PUSH1 0x00 2476 80 DUP1 2477 60 PUSH1 0x01 2479 60 PUSH1 0x01 247B 60 PUSH1 0xff 247D 1B SHL 247E 03 SUB 247F 83 DUP4 2480 16 AND 2481 60 PUSH1 0xff 2483 84 DUP5 2484 90 SWAP1 2485 1C SHR 2486 60 PUSH1 0x1b 2488 01 ADD 2489 61 PUSH2 0x2494 248C 87 DUP8 248D 82 DUP3 248E 88 DUP9 248F 85 DUP6 2490 61 PUSH2 0x2386 2493 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @2474 stack[0] = 0x00 // @2476 stack[1] = 0x00 // @2480 stack[2] = stack[-1] & (0x01 << 0xff) - 0x01 // @2488 stack[3] = 0x1b + (stack[-1] >> 0xff) // @2489 stack[4] = 0x2494 // @248C stack[5] = stack[-3] // @248D stack[6] = 0x1b + (stack[-1] >> 0xff) // @248E stack[7] = stack[-2] // @248F stack[8] = stack[-1] & (0x01 << 0xff) - 0x01 // } // Block ends with call to 0x2386, returns to 0x2494 label_2494: // Incoming return from call to 0x2386 at 0x2493 // Inputs[7] // { // @2495 stack[-5] // @2495 stack[-1] // @2497 stack[-6] // @2497 stack[-2] // @249B stack[-9] // @249D stack[-10] // @249E stack[-8] // } 2494 5B JUMPDEST 2495 93 SWAP4 2496 50 POP 2497 93 SWAP4 2498 50 POP 2499 50 POP 249A 50 POP 249B 93 SWAP4 249C 50 POP 249D 93 SWAP4 249E 91 SWAP2 249F 50 POP 24A0 50 POP 24A1 56 *JUMP // Stack delta = -8 // Outputs[2] // { // @249B stack[-9] = stack[-1] // @249D stack[-10] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_24A2: // Incoming jump from 0x0EEC // Incoming jump from 0x0C12 // Inputs[2] // { // @24A3 stack[-3] // @24A5 storage[stack[-3]] // } 24A2 5B JUMPDEST 24A3 82 DUP3 24A4 80 DUP1 24A5 54 SLOAD 24A6 61 PUSH2 0x24ae 24A9 90 SWAP1 24AA 61 PUSH2 0x292e 24AD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @24A3 stack[0] = stack[-3] // @24A9 stack[1] = 0x24ae // @24A9 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x292e, returns to 0x24AE label_24AE: // Incoming return from call to 0x292E at 0x24AD // Inputs[5] // { // @24AF stack[-1] // @24AF stack[-2] // @24B7 memory[0x00:0x20] // @24C2 stack[-4] // @24C3 stack[-3] // } 24AE 5B JUMPDEST 24AF 90 SWAP1 24B0 60 PUSH1 0x00 24B2 52 MSTORE 24B3 60 PUSH1 0x20 24B5 60 PUSH1 0x00 24B7 20 SHA3 24B8 90 SWAP1 24B9 60 PUSH1 0x1f 24BB 01 ADD 24BC 60 PUSH1 0x20 24BE 90 SWAP1 24BF 04 DIV 24C0 81 DUP2 24C1 01 ADD 24C2 92 SWAP3 24C3 82 DUP3 24C4 61 PUSH2 0x24d0 24C7 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @24B2 memory[0x00:0x20] = stack[-2] // @24B8 stack[-2] = keccak256(memory[0x00:0x20]) // @24C2 stack[-1] = stack[-4] // @24C2 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x24d0, if stack[-3] label_24C8: // Incoming jump from 0x24C7, if not stack[-3] // Inputs[1] { @24CA stack[-5] } 24C8 60 PUSH1 0x00 24CA 85 DUP6 24CB 55 SSTORE 24CC 61 PUSH2 0x2516 24CF 56 *JUMP // Stack delta = +0 // Outputs[1] { @24CB storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x2516 label_24D0: // Incoming jump from 0x24C7, if stack[-3] // Inputs[1] { @24D1 stack[-3] } 24D0 5B JUMPDEST 24D1 82 DUP3 24D2 60 PUSH1 0x1f 24D4 10 LT 24D5 61 PUSH2 0x24e9 24D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x24e9, if 0x1f < stack[-3] label_24D9: // Incoming jump from 0x24D8, if not 0x1f < stack[-3] // Inputs[4] // { // @24D9 stack[-1] // @24DA memory[stack[-1]:stack[-1] + 0x20] // @24DF stack[-3] // @24E3 stack[-5] // } 24D9 80 DUP1 24DA 51 MLOAD 24DB 60 PUSH1 0xff 24DD 19 NOT 24DE 16 AND 24DF 83 DUP4 24E0 80 DUP1 24E1 01 ADD 24E2 17 OR 24E3 85 DUP6 24E4 55 SSTORE 24E5 61 PUSH2 0x2516 24E8 56 *JUMP // Stack delta = +0 // Outputs[1] { @24E4 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x2516 label_24E9: // Incoming jump from 0x24D8, if 0x1f < stack[-3] // Inputs[2] // { // @24EA stack[-3] // @24F0 stack[-5] // } 24E9 5B JUMPDEST 24EA 82 DUP3 24EB 80 DUP1 24EC 01 ADD 24ED 60 PUSH1 0x01 24EF 01 ADD 24F0 85 DUP6 24F1 55 SSTORE 24F2 82 DUP3 24F3 15 ISZERO 24F4 61 PUSH2 0x2516 24F7 57 *JUMPI // Stack delta = +0 // Outputs[1] { @24F1 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x2516, if !stack[-3] label_24F8: // Incoming jump from 0x24F7, if not !stack[-3] // Inputs[2] // { // @24F8 stack[-3] // @24F8 stack[-1] // } 24F8 91 SWAP2 24F9 82 DUP3 24FA 01 ADD 24FB 5B JUMPDEST 24FC 82 DUP3 24FD 81 DUP2 24FE 11 GT 24FF 15 ISZERO 2500 61 PUSH2 0x2516 2503 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @24F8 stack[-3] = stack[-1] // @24FA stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x2516, if !(stack[-1] + stack[-3] > stack[-1]) label_2504: // Incoming jump from 0x2503, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x2503, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @2504 stack[-3] // @2505 memory[stack[-3]:stack[-3] + 0x20] // @2506 stack[-2] // @2508 stack[-1] // } 2504 82 DUP3 2505 51 MLOAD 2506 82 DUP3 2507 55 SSTORE 2508 91 SWAP2 2509 60 PUSH1 0x20 250B 01 ADD 250C 91 SWAP2 250D 90 SWAP1 250E 60 PUSH1 0x01 2510 01 ADD 2511 90 SWAP1 2512 61 PUSH2 0x24fb 2515 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2507 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @250C stack[-3] = 0x20 + stack[-3] // @2511 stack[-2] = 0x01 + stack[-2] // @2511 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x24fb label_2516: // Incoming jump from 0x24F7, if !stack[-3] // Incoming jump from 0x24E8 // Incoming jump from 0x2503, if !(stack[-1] > stack[-3]) // Incoming jump from 0x24CF // Incoming jump from 0x2503, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @251B stack[-4] // @251C stack[-3] // } 2516 5B JUMPDEST 2517 50 POP 2518 61 PUSH2 0x2522 251B 92 SWAP3 251C 91 SWAP2 251D 50 POP 251E 61 PUSH2 0x2526 2521 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @251B stack[-4] = 0x2522 // @251C stack[-3] = stack[-4] // } // Block ends with call to 0x2526, returns to 0x2522 label_2522: // Incoming jump from 0x252F, if !(stack[-2] > stack[-1]) // Incoming jump from 0x252F, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x2526 at 0x2521 // Inputs[2] // { // @2524 stack[-2] // @2524 stack[-3] // } 2522 5B JUMPDEST 2523 50 POP 2524 90 SWAP1 2525 56 *JUMP // Stack delta = -2 // Outputs[1] { @2524 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_2526: // Incoming call from 0x2521, returns to 0x2522 // Inputs[2] // { // @2528 stack[-1] // @2529 stack[-2] // } 2526 5B JUMPDEST 2527 5B JUMPDEST 2528 80 DUP1 2529 82 DUP3 252A 11 GT 252B 15 ISZERO 252C 61 PUSH2 0x2522 252F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2522, if !(stack[-2] > stack[-1]) label_2530: // Incoming jump from 0x252F, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x252F, if not !(stack[-2] > stack[-1]) // Inputs[1] { @2532 stack[-1] } 2530 60 PUSH1 0x00 2532 81 DUP2 2533 55 SSTORE 2534 60 PUSH1 0x01 2536 01 ADD 2537 61 PUSH2 0x2527 253A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2533 storage[stack[-1]] = 0x00 // @2536 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2527 label_253B: // Incoming call from 0x256D, returns to 0x1E38 // Incoming call from 0x2B9F, returns to 0x1E38 // Inputs[1] { @2545 stack[-1] } 253B 5B JUMPDEST 253C 60 PUSH1 0x01 253E 60 PUSH1 0x01 2540 60 PUSH1 0xe0 2542 1B SHL 2543 03 SUB 2544 19 NOT 2545 81 DUP2 2546 16 AND 2547 81 DUP2 2548 14 EQ 2549 61 PUSH2 0x0d26 254C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d26, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_254D: // Incoming jump from 0x254C, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2550 memory[0x00:0x00] } 254D 60 PUSH1 0x00 254F 80 DUP1 2550 FD *REVERT // Stack delta = +0 // Outputs[1] { @2550 revert(memory[0x00:0x00]); } // Block terminates label_2551: // Incoming call from 0x02B2, returns to 0x02B3 // Inputs[2] // { // @2556 stack[-1] // @2557 stack[-2] // } 2551 5B JUMPDEST 2552 60 PUSH1 0x00 2554 60 PUSH1 0x20 2556 82 DUP3 2557 84 DUP5 2558 03 SUB 2559 12 SLT 255A 15 ISZERO 255B 61 PUSH2 0x2563 255E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2552 stack[0] = 0x00 } // Block ends with conditional jump to 0x2563, if !(stack[-2] - stack[-1] i< 0x20) label_255F: // Incoming jump from 0x255E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2562 memory[0x00:0x00] } 255F 60 PUSH1 0x00 2561 80 DUP1 2562 FD *REVERT // Stack delta = +0 // Outputs[1] { @2562 revert(memory[0x00:0x00]); } // Block terminates label_2563: // Incoming jump from 0x255E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2564 stack[-2] // @2565 msg.data[stack[-2]:stack[-2] + 0x20] // } 2563 5B JUMPDEST 2564 81 DUP2 2565 35 CALLDATALOAD 2566 61 PUSH2 0x1e38 2569 81 DUP2 256A 61 PUSH2 0x253b 256D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2565 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2566 stack[1] = 0x1e38 // @2569 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x253b, returns to 0x1E38 label_256E: // Incoming call from 0x2803, returns to 0x2804 // Incoming call from 0x2844, returns to 0x2845 // Incoming call from 0x2854, returns to 0x2855 // Incoming call from 0x2641, returns to 0x2642 // Incoming call from 0x2B45, returns to 0x1E38 // Incoming call from 0x28E6, returns to 0x28E7 // Incoming call from 0x28C8, returns to 0x2819 // Incoming call from 0x26FF, returns to 0x2700 // Incoming call from 0x26EF, returns to 0x26F0 // Incoming call from 0x28F6, returns to 0x2819 // Incoming call from 0x259F, returns to 0x1E38 // Inputs[1] { @2577 stack[-1] } 256E 5B JUMPDEST 256F 60 PUSH1 0x01 2571 60 PUSH1 0x01 2573 60 PUSH1 0xa0 2575 1B SHL 2576 03 SUB 2577 81 DUP2 2578 16 AND 2579 81 DUP2 257A 14 EQ 257B 61 PUSH2 0x0d26 257E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d26, if stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 label_257F: // Incoming jump from 0x257E, if not stack[-1] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2582 memory[0x00:0x00] } 257F 60 PUSH1 0x00 2581 80 DUP1 2582 FD *REVERT // Stack delta = +0 // Outputs[1] { @2582 revert(memory[0x00:0x00]); } // Block terminates label_2583: // Incoming call from 0x04B8, returns to 0x04B9 // Incoming call from 0x0592, returns to 0x0593 // Incoming call from 0x07DC, returns to 0x07DD // Incoming call from 0x02E7, returns to 0x02E8 // Incoming call from 0x06B0, returns to 0x06B1 // Incoming call from 0x0750, returns to 0x0751 // Incoming call from 0x0525, returns to 0x0526 // Inputs[2] // { // @2588 stack[-1] // @2589 stack[-2] // } 2583 5B JUMPDEST 2584 60 PUSH1 0x00 2586 60 PUSH1 0x20 2588 82 DUP3 2589 84 DUP5 258A 03 SUB 258B 12 SLT 258C 15 ISZERO 258D 61 PUSH2 0x2595 2590 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2584 stack[0] = 0x00 } // Block ends with conditional jump to 0x2595, if !(stack[-2] - stack[-1] i< 0x20) label_2591: // Incoming jump from 0x2590, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2594 memory[0x00:0x00] } 2591 60 PUSH1 0x00 2593 80 DUP1 2594 FD *REVERT // Stack delta = +0 // Outputs[1] { @2594 revert(memory[0x00:0x00]); } // Block terminates label_2595: // Incoming jump from 0x2590, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2596 stack[-2] // @2597 msg.data[stack[-2]:stack[-2] + 0x20] // } 2595 5B JUMPDEST 2596 81 DUP2 2597 35 CALLDATALOAD 2598 61 PUSH2 0x1e38 259B 81 DUP2 259C 61 PUSH2 0x256e 259F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2597 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2598 stack[1] = 0x1e38 // @259B stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x256e, returns to 0x1E38 label_25A0: // Incoming call from 0x25E3, returns to 0x25E4 // Inputs[1] { @25A4 stack[-3] } 25A0 5B JUMPDEST 25A1 60 PUSH1 0x00 25A3 5B JUMPDEST 25A4 83 DUP4 25A5 81 DUP2 25A6 10 LT 25A7 15 ISZERO 25A8 61 PUSH2 0x25bb 25AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25A1 stack[0] = 0x00 } // Block ends with conditional jump to 0x25bb, if !(0x00 < stack[-3]) label_25AC: // Incoming jump from 0x25AB, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x25AB, if not !(0x00 < stack[-3]) // Inputs[4] // { // @25AC stack[-2] // @25AD stack[-1] // @25AF memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25B0 stack[-3] // } 25AC 81 DUP2 25AD 81 DUP2 25AE 01 ADD 25AF 51 MLOAD 25B0 83 DUP4 25B1 82 DUP3 25B2 01 ADD 25B3 52 MSTORE 25B4 60 PUSH1 0x20 25B6 01 ADD 25B7 61 PUSH2 0x25a3 25BA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @25B3 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @25B6 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x25a3 label_25BB: // Incoming jump from 0x25AB, if !(stack[-1] < stack[-4]) // Incoming jump from 0x25AB, if !(0x00 < stack[-3]) // Inputs[2] // { // @25BC stack[-4] // @25BD stack[-1] // } 25BB 5B JUMPDEST 25BC 83 DUP4 25BD 81 DUP2 25BE 11 GT 25BF 15 ISZERO 25C0 61 PUSH2 0x0bb0 25C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bb0, if !(stack[-1] > stack[-4]) label_25C4: // Incoming jump from 0x25C3, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @25C8 stack[-4] // @25C9 stack[-3] // @25CB stack[-5] // } 25C4 50 POP 25C5 50 POP 25C6 60 PUSH1 0x00 25C8 91 SWAP2 25C9 01 ADD 25CA 52 MSTORE 25CB 56 *JUMP // Stack delta = -5 // Outputs[1] { @25CA memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_25CC: // Incoming call from 0x2B78, returns to 0x2B79 // Incoming call from 0x260A, returns to 0x1E38 // Inputs[3] // { // @25CF stack[-1] // @25D0 memory[stack[-1]:stack[-1] + 0x20] // @25D2 stack[-2] // } 25CC 5B JUMPDEST 25CD 60 PUSH1 0x00 25CF 81 DUP2 25D0 51 MLOAD 25D1 80 DUP1 25D2 84 DUP5 25D3 52 MSTORE 25D4 61 PUSH2 0x25e4 25D7 81 DUP2 25D8 60 PUSH1 0x20 25DA 86 DUP7 25DB 01 ADD 25DC 60 PUSH1 0x20 25DE 86 DUP7 25DF 01 ADD 25E0 61 PUSH2 0x25a0 25E3 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @25CD stack[0] = 0x00 // @25D0 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @25D3 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @25D4 stack[2] = 0x25e4 // @25D7 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @25DB stack[4] = stack[-2] + 0x20 // @25DF stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x25a0, returns to 0x25E4 label_25E4: // Incoming return from call to 0x25A0 at 0x25E3 // Inputs[4] // { // @25E7 stack[-1] // @25EC stack[-4] // @25ED stack[-2] // @25F3 stack[-5] // } 25E4 5B JUMPDEST 25E5 60 PUSH1 0x1f 25E7 01 ADD 25E8 60 PUSH1 0x1f 25EA 19 NOT 25EB 16 AND 25EC 92 SWAP3 25ED 90 SWAP1 25EE 92 SWAP3 25EF 01 ADD 25F0 60 PUSH1 0x20 25F2 01 ADD 25F3 92 SWAP3 25F4 91 SWAP2 25F5 50 POP 25F6 50 POP 25F7 56 *JUMP // Stack delta = -4 // Outputs[1] { @25F3 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_25F8: // Incoming jump from 0x0310 // Inputs[2] // { // @25FB stack[-1] // @2606 stack[-2] // } 25F8 5B JUMPDEST 25F9 60 PUSH1 0x20 25FB 81 DUP2 25FC 52 MSTORE 25FD 60 PUSH1 0x00 25FF 61 PUSH2 0x1e38 2602 60 PUSH1 0x20 2604 83 DUP4 2605 01 ADD 2606 84 DUP5 2607 61 PUSH2 0x25cc 260A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @25FC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @25FD stack[0] = 0x00 // @25FF stack[1] = 0x1e38 // @2605 stack[2] = stack[-1] + 0x20 // @2606 stack[3] = stack[-2] // } // Block ends with call to 0x25cc, returns to 0x1E38 label_260B: // Incoming call from 0x0710, returns to 0x0711 // Incoming call from 0x040E, returns to 0x040F // Incoming call from 0x032B, returns to 0x032C // Incoming call from 0x04E5, returns to 0x04E6 // Incoming call from 0x0572, returns to 0x0573 // Inputs[2] // { // @2610 stack[-1] // @2611 stack[-2] // } 260B 5B JUMPDEST 260C 60 PUSH1 0x00 260E 60 PUSH1 0x20 2610 82 DUP3 2611 84 DUP5 2612 03 SUB 2613 12 SLT 2614 15 ISZERO 2615 61 PUSH2 0x261d 2618 57 *JUMPI // Stack delta = +1 // Outputs[1] { @260C stack[0] = 0x00 } // Block ends with conditional jump to 0x261d, if !(stack[-2] - stack[-1] i< 0x20) label_2619: // Incoming jump from 0x2618, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @261C memory[0x00:0x00] } 2619 60 PUSH1 0x00 261B 80 DUP1 261C FD *REVERT // Stack delta = +0 // Outputs[1] { @261C revert(memory[0x00:0x00]); } // Block terminates label_261D: // Incoming jump from 0x2618, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @261F stack[-2] // @261F msg.data[stack[-2]:stack[-2] + 0x20] // @2620 stack[-4] // @2621 stack[-3] // } 261D 5B JUMPDEST 261E 50 POP 261F 35 CALLDATALOAD 2620 91 SWAP2 2621 90 SWAP1 2622 50 POP 2623 56 *JUMP // Stack delta = -3 // Outputs[1] { @2620 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2624: // Incoming call from 0x042E, returns to 0x042F // Incoming call from 0x0363, returns to 0x0364 // Inputs[2] // { // @262A stack[-1] // @262B stack[-2] // } 2624 5B JUMPDEST 2625 60 PUSH1 0x00 2627 80 DUP1 2628 60 PUSH1 0x40 262A 83 DUP4 262B 85 DUP6 262C 03 SUB 262D 12 SLT 262E 15 ISZERO 262F 61 PUSH2 0x2637 2632 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2625 stack[0] = 0x00 // @2627 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2637, if !(stack[-2] - stack[-1] i< 0x40) label_2633: // Incoming jump from 0x2632, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2636 memory[0x00:0x00] } 2633 60 PUSH1 0x00 2635 80 DUP1 2636 FD *REVERT // Stack delta = +0 // Outputs[1] { @2636 revert(memory[0x00:0x00]); } // Block terminates label_2637: // Incoming jump from 0x2632, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2638 stack[-3] // @2639 msg.data[stack[-3]:stack[-3] + 0x20] // } 2637 5B JUMPDEST 2638 82 DUP3 2639 35 CALLDATALOAD 263A 61 PUSH2 0x2642 263D 81 DUP2 263E 61 PUSH2 0x256e 2641 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2639 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @263A stack[1] = 0x2642 // @263D stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x256e, returns to 0x2642 label_2642: // Incoming return from call to 0x256E at 0x2641 // Inputs[5] // { // @2643 stack[-6] // @2643 stack[-1] // @2646 stack[-4] // @264A msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @264B stack[-5] // } 2642 5B JUMPDEST 2643 94 SWAP5 2644 60 PUSH1 0x20 2646 93 SWAP4 2647 90 SWAP1 2648 93 SWAP4 2649 01 ADD 264A 35 CALLDATALOAD 264B 93 SWAP4 264C 50 POP 264D 50 POP 264E 50 POP 264F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2643 stack[-6] = stack[-1] // @264B stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_2650: // Incoming call from 0x05BA, returns to 0x05BB // Incoming call from 0x03A6, returns to 0x03A7 // Inputs[2] // { // @2659 stack[-1] // @265A stack[-2] // } 2650 5B JUMPDEST 2651 60 PUSH1 0x00 2653 80 DUP1 2654 60 PUSH1 0x00 2656 80 DUP1 2657 60 PUSH1 0x60 2659 85 DUP6 265A 87 DUP8 265B 03 SUB 265C 12 SLT 265D 15 ISZERO 265E 61 PUSH2 0x2666 2661 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2651 stack[0] = 0x00 // @2653 stack[1] = 0x00 // @2654 stack[2] = 0x00 // @2656 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2666, if !(stack[-2] - stack[-1] i< 0x60) label_2662: // Incoming jump from 0x2661, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2665 memory[0x00:0x00] } 2662 60 PUSH1 0x00 2664 80 DUP1 2665 FD *REVERT // Stack delta = +0 // Outputs[1] { @2665 revert(memory[0x00:0x00]); } // Block terminates label_2666: // Incoming jump from 0x2661, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[6] // { // @2667 stack[-5] // @2668 msg.data[stack[-5]:stack[-5] + 0x20] // @2669 stack[-4] // @266F msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2670 stack[-3] // @2676 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 2666 5B JUMPDEST 2667 84 DUP5 2668 35 CALLDATALOAD 2669 93 SWAP4 266A 50 POP 266B 60 PUSH1 0x20 266D 85 DUP6 266E 01 ADD 266F 35 CALLDATALOAD 2670 92 SWAP3 2671 50 POP 2672 60 PUSH1 0x40 2674 85 DUP6 2675 01 ADD 2676 35 CALLDATALOAD 2677 67 PUSH8 0xffffffffffffffff 2680 80 DUP1 2681 82 DUP3 2682 11 GT 2683 15 ISZERO 2684 61 PUSH2 0x268c 2687 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @2669 stack[-4] = msg.data[stack[-5]:stack[-5] + 0x20] // @2670 stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2676 stack[0] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2677 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x268c, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) label_2688: // Incoming jump from 0x2687, if not !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @268B memory[0x00:0x00] } 2688 60 PUSH1 0x00 268A 80 DUP1 268B FD *REVERT // Stack delta = +0 // Outputs[1] { @268B revert(memory[0x00:0x00]); } // Block terminates label_268C: // Incoming jump from 0x2687, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @268D stack[-2] // @268E stack[-7] // @2692 stack[-8] // } 268C 5B JUMPDEST 268D 81 DUP2 268E 87 DUP8 268F 01 ADD 2690 91 SWAP2 2691 50 POP 2692 87 DUP8 2693 60 PUSH1 0x1f 2695 83 DUP4 2696 01 ADD 2697 12 SLT 2698 61 PUSH2 0x26a0 269B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2690 stack[-2] = stack[-7] + stack[-2] } // Block ends with conditional jump to 0x26a0, if stack[-7] + stack[-2] + 0x1f i< stack[-8] label_269C: // Incoming jump from 0x269B, if not stack[-7] + stack[-2] + 0x1f i< stack[-8] // Inputs[1] { @269F memory[0x00:0x00] } 269C 60 PUSH1 0x00 269E 80 DUP1 269F FD *REVERT // Stack delta = +0 // Outputs[1] { @269F revert(memory[0x00:0x00]); } // Block terminates label_26A0: // Incoming jump from 0x269B, if stack[-7] + stack[-2] + 0x1f i< stack[-8] // Inputs[3] // { // @26A1 stack[-2] // @26A2 msg.data[stack[-2]:stack[-2] + 0x20] // @26A3 stack[-1] // } 26A0 5B JUMPDEST 26A1 81 DUP2 26A2 35 CALLDATALOAD 26A3 81 DUP2 26A4 81 DUP2 26A5 11 GT 26A6 15 ISZERO 26A7 61 PUSH2 0x26af 26AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26A2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x26af, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_26AB: // Incoming jump from 0x26AA, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @26AE memory[0x00:0x00] } 26AB 60 PUSH1 0x00 26AD 80 DUP1 26AE FD *REVERT // Stack delta = +0 // Outputs[1] { @26AE revert(memory[0x00:0x00]); } // Block terminates label_26AF: // Incoming jump from 0x26AA, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @26B0 stack[-9] // @26B3 stack[-1] // @26B4 stack[-3] // } 26AF 5B JUMPDEST 26B0 88 DUP9 26B1 60 PUSH1 0x20 26B3 82 DUP3 26B4 85 DUP6 26B5 01 ADD 26B6 01 ADD 26B7 11 GT 26B8 15 ISZERO 26B9 61 PUSH2 0x26c1 26BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x26c1, if !(stack[-3] + stack[-1] + 0x20 > stack[-9]) label_26BD: // Incoming jump from 0x26BC, if not !(stack[-3] + stack[-1] + 0x20 > stack[-9]) // Inputs[1] { @26C0 memory[0x00:0x00] } 26BD 60 PUSH1 0x00 26BF 80 DUP1 26C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @26C0 revert(memory[0x00:0x00]); } // Block terminates label_26C1: // Incoming jump from 0x26BC, if !(stack[-3] + stack[-1] + 0x20 > stack[-9]) // Inputs[7] // { // @26C2 stack[-7] // @26C2 stack[-1] // @26C3 stack[-10] // @26C4 stack[-6] // @26C5 stack[-9] // @26CA stack[-3] // @26CB stack[-8] // } 26C1 5B JUMPDEST 26C2 95 SWAP6 26C3 98 SWAP9 26C4 94 SWAP5 26C5 97 SWAP8 26C6 50 POP 26C7 50 POP 26C8 60 PUSH1 0x20 26CA 01 ADD 26CB 94 SWAP5 26CC 50 POP 26CD 50 POP 26CE 50 POP 26CF 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @26C2 stack[-7] = stack[-1] // @26C3 stack[-10] = stack[-7] // @26C5 stack[-9] = stack[-6] // @26CB stack[-8] = 0x20 + stack[-3] // } // Block ends with unconditional jump to stack[-10] label_26D0: // Incoming call from 0x0482, returns to 0x0483 // Incoming call from 0x03C6, returns to 0x03C7 // Inputs[2] // { // @26D8 stack[-1] // @26D9 stack[-2] // } 26D0 5B JUMPDEST 26D1 60 PUSH1 0x00 26D3 80 DUP1 26D4 60 PUSH1 0x00 26D6 60 PUSH1 0x60 26D8 84 DUP5 26D9 86 DUP7 26DA 03 SUB 26DB 12 SLT 26DC 15 ISZERO 26DD 61 PUSH2 0x26e5 26E0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @26D1 stack[0] = 0x00 // @26D3 stack[1] = 0x00 // @26D4 stack[2] = 0x00 // } // Block ends with conditional jump to 0x26e5, if !(stack[-2] - stack[-1] i< 0x60) label_26E1: // Incoming jump from 0x26E0, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @26E4 memory[0x00:0x00] } 26E1 60 PUSH1 0x00 26E3 80 DUP1 26E4 FD *REVERT // Stack delta = +0 // Outputs[1] { @26E4 revert(memory[0x00:0x00]); } // Block terminates label_26E5: // Incoming jump from 0x26E0, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @26E6 stack[-4] // @26E7 msg.data[stack[-4]:stack[-4] + 0x20] // } 26E5 5B JUMPDEST 26E6 83 DUP4 26E7 35 CALLDATALOAD 26E8 61 PUSH2 0x26f0 26EB 81 DUP2 26EC 61 PUSH2 0x256e 26EF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @26E7 stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @26E8 stack[1] = 0x26f0 // @26EB stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x256e, returns to 0x26F0 label_26F0: // Incoming return from call to 0x256E at 0x26EF // Inputs[4] // { // @26F1 stack[-4] // @26F1 stack[-1] // @26F5 stack[-5] // @26F7 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 26F0 5B JUMPDEST 26F1 92 SWAP3 26F2 50 POP 26F3 60 PUSH1 0x20 26F5 84 DUP5 26F6 01 ADD 26F7 35 CALLDATALOAD 26F8 61 PUSH2 0x2700 26FB 81 DUP2 26FC 61 PUSH2 0x256e 26FF 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @26F1 stack[-4] = stack[-1] // @26F7 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @26F8 stack[0] = 0x2700 // @26FB stack[1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x256e, returns to 0x2700 label_2700: // Incoming return from call to 0x256E at 0x26FF // Inputs[6] // { // @2701 stack[-4] // @2701 stack[-1] // @2702 stack[-7] // @2704 stack[-6] // @270A stack[-5] // @270E msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } 2700 5B JUMPDEST 2701 92 SWAP3 2702 95 SWAP6 2703 92 SWAP3 2704 94 SWAP5 2705 50 POP 2706 50 POP 2707 50 POP 2708 60 PUSH1 0x40 270A 91 SWAP2 270B 90 SWAP1 270C 91 SWAP2 270D 01 ADD 270E 35 CALLDATALOAD 270F 90 SWAP1 2710 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2702 stack[-7] = stack[-4] // @2704 stack[-6] = stack[-1] // @270F stack[-5] = msg.data[0x40 + stack[-5]:0x40 + stack[-5] + 0x20] // } // Block ends with unconditional jump to stack[-7] label_2711: // Incoming jump from 0x2769 // Incoming jump from 0x2741 // Inputs[1] { @2726 memory[0x00:0x24] } 2711 5B JUMPDEST 2712 63 PUSH4 0x4e487b71 2717 60 PUSH1 0xe0 2719 1B SHL 271A 60 PUSH1 0x00 271C 52 MSTORE 271D 60 PUSH1 0x41 271F 60 PUSH1 0x04 2721 52 MSTORE 2722 60 PUSH1 0x24 2724 60 PUSH1 0x00 2726 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @271C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2721 memory[0x04:0x24] = 0x41 // @2726 revert(memory[0x00:0x24]); // } // Block terminates label_2727: // Incoming call from 0x2897, returns to 0x2898 // Incoming call from 0x27E5, returns to 0x1786 // Inputs[1] { @2734 stack[-2] } 2727 5B JUMPDEST 2728 60 PUSH1 0x00 272A 67 PUSH8 0xffffffffffffffff 2733 80 DUP1 2734 84 DUP5 2735 11 GT 2736 15 ISZERO 2737 61 PUSH2 0x2742 273A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2728 stack[0] = 0x00 // @272A stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2742, if !(stack[-2] > 0xffffffffffffffff) label_273B: // Incoming jump from 0x273A, if not !(stack[-2] > 0xffffffffffffffff) 273B 61 PUSH2 0x2742 273E 61 PUSH2 0x2711 2741 56 *JUMP // Stack delta = +1 // Outputs[1] { @273B stack[0] = 0x2742 } // Block ends with unconditional jump to 0x2711 label_2742: // Incoming jump from 0x273A, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @2745 memory[0x40:0x60] // @2748 stack[-4] // @2757 stack[-1] // } 2742 5B JUMPDEST 2743 60 PUSH1 0x40 2745 51 MLOAD 2746 60 PUSH1 0x1f 2748 85 DUP6 2749 01 ADD 274A 60 PUSH1 0x1f 274C 19 NOT 274D 90 SWAP1 274E 81 DUP2 274F 16 AND 2750 60 PUSH1 0x3f 2752 01 ADD 2753 16 AND 2754 81 DUP2 2755 01 ADD 2756 90 SWAP1 2757 82 DUP3 2758 82 DUP3 2759 11 GT 275A 81 DUP2 275B 83 DUP4 275C 10 LT 275D 17 OR 275E 15 ISZERO 275F 61 PUSH2 0x276a 2762 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2756 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @2756 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x276a, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_2763: // Incoming jump from 0x2762, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 2763 61 PUSH2 0x276a 2766 61 PUSH2 0x2711 2769 56 *JUMP // Stack delta = +1 // Outputs[1] { @2763 stack[0] = 0x276a } // Block ends with unconditional jump to 0x2711 label_276A: // Incoming jump from 0x2762, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @276B stack[-2] // @276F stack[-1] // @2770 stack[-4] // @2772 stack[-6] // @2775 stack[-7] // @2777 stack[-5] // } 276A 5B JUMPDEST 276B 81 DUP2 276C 60 PUSH1 0x40 276E 52 MSTORE 276F 80 DUP1 2770 93 SWAP4 2771 50 POP 2772 85 DUP6 2773 81 DUP2 2774 52 MSTORE 2775 86 DUP7 2776 86 DUP7 2777 86 DUP7 2778 01 ADD 2779 11 GT 277A 15 ISZERO 277B 61 PUSH2 0x2783 277E 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @276E memory[0x40:0x60] = stack[-2] // @2770 stack[-4] = stack[-1] // @2774 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x2783, if !(stack[-5] + stack[-6] > stack[-7]) label_277F: // Incoming jump from 0x277E, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @2782 memory[0x00:0x00] } 277F 60 PUSH1 0x00 2781 80 DUP1 2782 FD *REVERT // Stack delta = +0 // Outputs[1] { @2782 revert(memory[0x00:0x00]); } // Block terminates label_2783: // Incoming jump from 0x277E, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @2784 stack[-6] // @2785 stack[-5] // @2788 stack[-1] // @278A msg.data[stack[-5]:stack[-5] + stack[-6]] // @2797 stack[-4] // @2797 stack[-8] // @2798 stack[-7] // } 2783 5B JUMPDEST 2784 85 DUP6 2785 85 DUP6 2786 60 PUSH1 0x20 2788 83 DUP4 2789 01 ADD 278A 37 CALLDATACOPY 278B 60 PUSH1 0x00 278D 60 PUSH1 0x20 278F 87 DUP8 2790 83 DUP4 2791 01 ADD 2792 01 ADD 2793 52 MSTORE 2794 50 POP 2795 50 POP 2796 50 POP 2797 93 SWAP4 2798 92 SWAP3 2799 50 POP 279A 50 POP 279B 50 POP 279C 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @278A memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @2793 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @2797 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_279D: // Incoming call from 0x0505, returns to 0x0506 // Incoming call from 0x03E6, returns to 0x03E7 // Inputs[2] // { // @27A2 stack[-1] // @27A3 stack[-2] // } 279D 5B JUMPDEST 279E 60 PUSH1 0x00 27A0 60 PUSH1 0x20 27A2 82 DUP3 27A3 84 DUP5 27A4 03 SUB 27A5 12 SLT 27A6 15 ISZERO 27A7 61 PUSH2 0x27af 27AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @279E stack[0] = 0x00 } // Block ends with conditional jump to 0x27af, if !(stack[-2] - stack[-1] i< 0x20) label_27AB: // Incoming jump from 0x27AA, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @27AE memory[0x00:0x00] } 27AB 60 PUSH1 0x00 27AD 80 DUP1 27AE FD *REVERT // Stack delta = +0 // Outputs[1] { @27AE revert(memory[0x00:0x00]); } // Block terminates label_27AF: // Incoming jump from 0x27AA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @27B0 stack[-2] // @27B1 msg.data[stack[-2]:stack[-2] + 0x20] // } 27AF 5B JUMPDEST 27B0 81 DUP2 27B1 35 CALLDATALOAD 27B2 67 PUSH8 0xffffffffffffffff 27BB 81 DUP2 27BC 11 GT 27BD 15 ISZERO 27BE 61 PUSH2 0x27c6 27C1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27B1 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x27c6, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_27C2: // Incoming jump from 0x27C1, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @27C5 memory[0x00:0x00] } 27C2 60 PUSH1 0x00 27C4 80 DUP1 27C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @27C5 revert(memory[0x00:0x00]); } // Block terminates label_27C6: // Incoming jump from 0x27C1, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @27C7 stack[-3] // @27C8 stack[-1] // @27CD stack[-4] // } 27C6 5B JUMPDEST 27C7 82 DUP3 27C8 01 ADD 27C9 60 PUSH1 0x1f 27CB 81 DUP2 27CC 01 ADD 27CD 84 DUP5 27CE 13 SGT 27CF 61 PUSH2 0x27d7 27D2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @27C8 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x27d7, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_27D3: // Incoming jump from 0x27D2, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @27D6 memory[0x00:0x00] } 27D3 60 PUSH1 0x00 27D5 80 DUP1 27D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @27D6 revert(memory[0x00:0x00]); } // Block terminates label_27D7: // Incoming jump from 0x27D2, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @27DB stack[-4] // @27DC stack[-1] // @27DD msg.data[stack[-1]:stack[-1] + 0x20] // } 27D7 5B JUMPDEST 27D8 61 PUSH2 0x1786 27DB 84 DUP5 27DC 82 DUP3 27DD 35 CALLDATALOAD 27DE 60 PUSH1 0x20 27E0 84 DUP5 27E1 01 ADD 27E2 61 PUSH2 0x2727 27E5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @27D8 stack[0] = 0x1786 // @27DB stack[1] = stack[-4] // @27DD stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @27E1 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2727, returns to 0x1786 label_27E6: // Incoming call from 0x0690, returns to 0x0691 // Inputs[2] // { // @27EC stack[-1] // @27ED stack[-2] // } 27E6 5B JUMPDEST 27E7 60 PUSH1 0x00 27E9 80 DUP1 27EA 60 PUSH1 0x40 27EC 83 DUP4 27ED 85 DUP6 27EE 03 SUB 27EF 12 SLT 27F0 15 ISZERO 27F1 61 PUSH2 0x27f9 27F4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @27E7 stack[0] = 0x00 // @27E9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x27f9, if !(stack[-2] - stack[-1] i< 0x40) label_27F5: // Incoming jump from 0x27F4, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @27F8 memory[0x00:0x00] } 27F5 60 PUSH1 0x00 27F7 80 DUP1 27F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @27F8 revert(memory[0x00:0x00]); } // Block terminates label_27F9: // Incoming jump from 0x27F4, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @27FA stack[-3] // @27FB msg.data[stack[-3]:stack[-3] + 0x20] // } 27F9 5B JUMPDEST 27FA 82 DUP3 27FB 35 CALLDATALOAD 27FC 61 PUSH2 0x2804 27FF 81 DUP2 2800 61 PUSH2 0x256e 2803 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @27FB stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @27FC stack[1] = 0x2804 // @27FF stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x256e, returns to 0x2804 label_2804: // Incoming return from call to 0x256E at 0x2803 // Inputs[4] // { // @2805 stack[-1] // @2805 stack[-3] // @2809 stack[-4] // @280B msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2804 5B JUMPDEST 2805 91 SWAP2 2806 50 POP 2807 60 PUSH1 0x20 2809 83 DUP4 280A 01 ADD 280B 35 CALLDATALOAD 280C 80 DUP1 280D 15 ISZERO 280E 15 ISZERO 280F 81 DUP2 2810 14 EQ 2811 61 PUSH2 0x2819 2814 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2805 stack[-3] = stack[-1] // @280B stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2819, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_2815: // Incoming jump from 0x2814, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[1] { @2818 memory[0x00:0x00] } 2815 60 PUSH1 0x00 2817 80 DUP1 2818 FD *REVERT // Stack delta = +0 // Outputs[1] { @2818 revert(memory[0x00:0x00]); } // Block terminates label_2819: // Incoming jump from 0x2814, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Incoming return from call to 0x256E at 0x28C8 // Incoming return from call to 0x256E at 0x28F6 // Inputs[6] // { // @281A stack[-1] // @281B stack[-2] // @281E stack[-5] // @2820 stack[-3] // @2820 stack[-6] // @2821 stack[-4] // } 2819 5B JUMPDEST 281A 80 DUP1 281B 91 SWAP2 281C 50 POP 281D 50 POP 281E 92 SWAP3 281F 50 POP 2820 92 SWAP3 2821 90 SWAP1 2822 50 POP 2823 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @281E stack[-5] = stack[-1] // @2820 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2824: // Incoming call from 0x06D0, returns to 0x06D1 // Inputs[2] // { // @282D stack[-1] // @282E stack[-2] // } 2824 5B JUMPDEST 2825 60 PUSH1 0x00 2827 80 DUP1 2828 60 PUSH1 0x00 282A 80 DUP1 282B 60 PUSH1 0x80 282D 85 DUP6 282E 87 DUP8 282F 03 SUB 2830 12 SLT 2831 15 ISZERO 2832 61 PUSH2 0x283a 2835 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2825 stack[0] = 0x00 // @2827 stack[1] = 0x00 // @2828 stack[2] = 0x00 // @282A stack[3] = 0x00 // } // Block ends with conditional jump to 0x283a, if !(stack[-2] - stack[-1] i< 0x80) label_2836: // Incoming jump from 0x2835, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2839 memory[0x00:0x00] } 2836 60 PUSH1 0x00 2838 80 DUP1 2839 FD *REVERT // Stack delta = +0 // Outputs[1] { @2839 revert(memory[0x00:0x00]); } // Block terminates label_283A: // Incoming jump from 0x2835, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @283B stack[-5] // @283C msg.data[stack[-5]:stack[-5] + 0x20] // } 283A 5B JUMPDEST 283B 84 DUP5 283C 35 CALLDATALOAD 283D 61 PUSH2 0x2845 2840 81 DUP2 2841 61 PUSH2 0x256e 2844 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @283C stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @283D stack[1] = 0x2845 // @2840 stack[2] = msg.data[stack[-5]:stack[-5] + 0x20] // } // Block ends with call to 0x256e, returns to 0x2845 label_2845: // Incoming return from call to 0x256E at 0x2844 // Inputs[4] // { // @2846 stack[-1] // @2846 stack[-5] // @284A stack[-6] // @284C msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } 2845 5B JUMPDEST 2846 93 SWAP4 2847 50 POP 2848 60 PUSH1 0x20 284A 85 DUP6 284B 01 ADD 284C 35 CALLDATALOAD 284D 61 PUSH2 0x2855 2850 81 DUP2 2851 61 PUSH2 0x256e 2854 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2846 stack[-5] = stack[-1] // @284C stack[-1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @284D stack[0] = 0x2855 // @2850 stack[1] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with call to 0x256e, returns to 0x2855 label_2855: // Incoming return from call to 0x256E at 0x2854 // Inputs[6] // { // @2856 stack[-4] // @2856 stack[-1] // @285A stack[-6] // @285C msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @285D stack[-3] // @2863 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2855 5B JUMPDEST 2856 92 SWAP3 2857 50 POP 2858 60 PUSH1 0x40 285A 85 DUP6 285B 01 ADD 285C 35 CALLDATALOAD 285D 91 SWAP2 285E 50 POP 285F 60 PUSH1 0x60 2861 85 DUP6 2862 01 ADD 2863 35 CALLDATALOAD 2864 67 PUSH8 0xffffffffffffffff 286D 81 DUP2 286E 11 GT 286F 15 ISZERO 2870 61 PUSH2 0x2878 2873 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2856 stack[-4] = stack[-1] // @285D stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2863 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2878, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2874: // Incoming jump from 0x2873, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2877 memory[0x00:0x00] } 2874 60 PUSH1 0x00 2876 80 DUP1 2877 FD *REVERT // Stack delta = +0 // Outputs[1] { @2877 revert(memory[0x00:0x00]); } // Block terminates label_2878: // Incoming jump from 0x2873, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2879 stack[-6] // @287A stack[-1] // @287F stack[-7] // } 2878 5B JUMPDEST 2879 85 DUP6 287A 01 ADD 287B 60 PUSH1 0x1f 287D 81 DUP2 287E 01 ADD 287F 87 DUP8 2880 13 SGT 2881 61 PUSH2 0x2889 2884 57 *JUMPI // Stack delta = +0 // Outputs[1] { @287A stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x2889, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_2885: // Incoming jump from 0x2884, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @2888 memory[0x00:0x00] } 2885 60 PUSH1 0x00 2887 80 DUP1 2888 FD *REVERT // Stack delta = +0 // Outputs[1] { @2888 revert(memory[0x00:0x00]); } // Block terminates label_2889: // Incoming jump from 0x2884, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @288D stack[-7] // @288E stack[-1] // @288F msg.data[stack[-1]:stack[-1] + 0x20] // } 2889 5B JUMPDEST 288A 61 PUSH2 0x2898 288D 87 DUP8 288E 82 DUP3 288F 35 CALLDATALOAD 2890 60 PUSH1 0x20 2892 84 DUP5 2893 01 ADD 2894 61 PUSH2 0x2727 2897 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @288A stack[0] = 0x2898 // @288D stack[1] = stack[-7] // @288F stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2893 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2727, returns to 0x2898 label_2898: // Incoming return from call to 0x2727 at 0x2897 // Inputs[8] // { // @2899 stack[-3] // @2899 stack[-1] // @289C stack[-6] // @289D stack[-9] // @289E stack[-5] // @289F stack[-8] // @28A1 stack[-4] // @28A1 stack[-7] // } 2898 5B JUMPDEST 2899 91 SWAP2 289A 50 POP 289B 50 POP 289C 92 SWAP3 289D 95 SWAP6 289E 91 SWAP2 289F 94 SWAP5 28A0 50 POP 28A1 92 SWAP3 28A2 50 POP 28A3 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @289C stack[-6] = stack[-1] // @289D stack[-9] = stack[-6] // @289F stack[-8] = stack[-5] // @28A1 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_28A4: // Incoming call from 0x06F0, returns to 0x06F1 // Inputs[2] // { // @28AA stack[-1] // @28AB stack[-2] // } 28A4 5B JUMPDEST 28A5 60 PUSH1 0x00 28A7 80 DUP1 28A8 60 PUSH1 0x40 28AA 83 DUP4 28AB 85 DUP6 28AC 03 SUB 28AD 12 SLT 28AE 15 ISZERO 28AF 61 PUSH2 0x28b7 28B2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28A5 stack[0] = 0x00 // @28A7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x28b7, if !(stack[-2] - stack[-1] i< 0x40) label_28B3: // Incoming jump from 0x28B2, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28B6 memory[0x00:0x00] } 28B3 60 PUSH1 0x00 28B5 80 DUP1 28B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @28B6 revert(memory[0x00:0x00]); } // Block terminates label_28B7: // Incoming jump from 0x28B2, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @28B8 stack[-3] // @28B9 msg.data[stack[-3]:stack[-3] + 0x20] // @28BA stack[-2] // @28C0 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 28B7 5B JUMPDEST 28B8 82 DUP3 28B9 35 CALLDATALOAD 28BA 91 SWAP2 28BB 50 POP 28BC 60 PUSH1 0x20 28BE 83 DUP4 28BF 01 ADD 28C0 35 CALLDATALOAD 28C1 61 PUSH2 0x2819 28C4 81 DUP2 28C5 61 PUSH2 0x256e 28C8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @28BA stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @28C0 stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @28C1 stack[1] = 0x2819 // @28C4 stack[2] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with call to 0x256e, returns to 0x2819 label_28C9: // Incoming jump from 0x07BC // Inputs[2] // { // @28CF stack[-1] // @28D0 stack[-2] // } 28C9 5B JUMPDEST 28CA 60 PUSH1 0x00 28CC 80 DUP1 28CD 60 PUSH1 0x40 28CF 83 DUP4 28D0 85 DUP6 28D1 03 SUB 28D2 12 SLT 28D3 15 ISZERO 28D4 61 PUSH2 0x28dc 28D7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28CA stack[0] = 0x00 // @28CC stack[1] = 0x00 // } // Block ends with conditional jump to 0x28dc, if !(stack[-2] - stack[-1] i< 0x40) label_28D8: // Incoming jump from 0x28D7, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28DB memory[0x00:0x00] } 28D8 60 PUSH1 0x00 28DA 80 DUP1 28DB FD *REVERT // Stack delta = +0 // Outputs[1] { @28DB revert(memory[0x00:0x00]); } // Block terminates label_28DC: // Incoming jump from 0x28D7, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @28DD stack[-3] // @28DE msg.data[stack[-3]:stack[-3] + 0x20] // } 28DC 5B JUMPDEST 28DD 82 DUP3 28DE 35 CALLDATALOAD 28DF 61 PUSH2 0x28e7 28E2 81 DUP2 28E3 61 PUSH2 0x256e 28E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @28DE stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @28DF stack[1] = 0x28e7 // @28E2 stack[2] = msg.data[stack[-3]:stack[-3] + 0x20] // } // Block ends with call to 0x256e, returns to 0x28E7 label_28E7: // Incoming return from call to 0x256E at 0x28E6 // Inputs[4] // { // @28E8 stack[-1] // @28E8 stack[-3] // @28EC stack[-4] // @28EE msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 28E7 5B JUMPDEST 28E8 91 SWAP2 28E9 50 POP 28EA 60 PUSH1 0x20 28EC 83 DUP4 28ED 01 ADD 28EE 35 CALLDATALOAD 28EF 61 PUSH2 0x2819 28F2 81 DUP2 28F3 61 PUSH2 0x256e 28F6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @28E8 stack[-3] = stack[-1] // @28EE stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @28EF stack[0] = 0x2819 // @28F2 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x256e, returns to 0x2819 label_28F7: // Incoming call from 0x1587, returns to 0x08BF // Incoming call from 0x12DE, returns to 0x08BF // Incoming call from 0x0ED9, returns to 0x08BF // Incoming call from 0x1400, returns to 0x08BF // Incoming call from 0x0BFF, returns to 0x08BF // Incoming call from 0x16AA, returns to 0x08BF // Incoming call from 0x0E3D, returns to 0x08BF // Incoming call from 0x11AD, returns to 0x08BF // Incoming call from 0x08BE, returns to 0x08BF // Incoming call from 0x14F2, returns to 0x08BF // Inputs[2] // { // @28FB stack[-1] // @292C stack[-2] // } 28F7 5B JUMPDEST 28F8 60 PUSH1 0x20 28FA 80 DUP1 28FB 82 DUP3 28FC 52 MSTORE 28FD 60 PUSH1 0x1f 28FF 90 SWAP1 2900 82 DUP3 2901 01 ADD 2902 52 MSTORE 2903 7F PUSH32 0x43616c6c6572206e6f7420746865206f776e6572206f72206d616e6167657200 2924 60 PUSH1 0x40 2926 82 DUP3 2927 01 ADD 2928 52 MSTORE 2929 60 PUSH1 0x60 292B 01 ADD 292C 90 SWAP1 292D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @28FC memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2902 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1f // @2928 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x43616c6c6572206e6f7420746865206f776e6572206f72206d616e6167657200 // @292C stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_292E: // Incoming call from 0x13C1, returns to 0x1334 // Incoming call from 0x1F0D, returns to 0x08F9 // Incoming call from 0x1333, returns to 0x1334 // Incoming call from 0x08F8, returns to 0x08F9 // Incoming call from 0x24AD, returns to 0x24AE // Incoming call from 0x135F, returns to 0x1360 // Incoming call from 0x1326, returns to 0x08F9 // Incoming call from 0x0924, returns to 0x0925 // Inputs[1] { @2931 stack[-1] } 292E 5B JUMPDEST 292F 60 PUSH1 0x01 2931 81 DUP2 2932 81 DUP2 2933 1C SHR 2934 90 SWAP1 2935 82 DUP3 2936 16 AND 2937 80 DUP1 2938 61 PUSH2 0x2942 293B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2934 stack[0] = stack[-1] >> 0x01 // @2936 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2942, if stack[-1] & 0x01 label_293C: // Incoming jump from 0x293B, if not stack[-1] & 0x01 // Inputs[2] // { // @293E stack[-2] // @2947 stack[-1] // } 293C 60 PUSH1 0x7f 293E 82 DUP3 293F 16 AND 2940 91 SWAP2 2941 50 POP 2942 5B JUMPDEST 2943 60 PUSH1 0x20 2945 82 DUP3 2946 10 LT 2947 81 DUP2 2948 14 EQ 2949 15 ISZERO 294A 61 PUSH2 0x2963 294D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2940 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2963, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_294E: // Incoming jump from 0x294D, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x294D, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @2962 memory[0x00:0x24] } 294E 63 PUSH4 0x4e487b71 2953 60 PUSH1 0xe0 2955 1B SHL 2956 60 PUSH1 0x00 2958 52 MSTORE 2959 60 PUSH1 0x22 295B 60 PUSH1 0x04 295D 52 MSTORE 295E 60 PUSH1 0x24 2960 60 PUSH1 0x00 2962 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2958 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @295D memory[0x04:0x24] = 0x22 // @2962 revert(memory[0x00:0x24]); // } // Block terminates label_2963: // Incoming jump from 0x294D, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x294D, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @2965 stack[-4] // @2965 stack[-2] // @2966 stack[-3] // } 2963 5B JUMPDEST 2964 50 POP 2965 91 SWAP2 2966 90 SWAP1 2967 50 POP 2968 56 *JUMP // Stack delta = -3 // Outputs[1] { @2965 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2969: // Incoming call from 0x0A6F, returns to 0x08BF // Incoming call from 0x0C3D, returns to 0x08BF // Incoming call from 0x0FD4, returns to 0x08BF // Inputs[2] // { // @296D stack[-1] // @2989 stack[-2] // } 2969 5B JUMPDEST 296A 60 PUSH1 0x20 296C 80 DUP1 296D 82 DUP3 296E 52 MSTORE 296F 60 PUSH1 0x08 2971 90 SWAP1 2972 82 DUP3 2973 01 ADD 2974 52 MSTORE 2975 67 PUSH8 0x6e6f74206c697665 297E 60 PUSH1 0xc0 2980 1B SHL 2981 60 PUSH1 0x40 2983 82 DUP3 2984 01 ADD 2985 52 MSTORE 2986 60 PUSH1 0x60 2988 01 ADD 2989 90 SWAP1 298A 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @296E memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2974 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x08 // @2985 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x6e6f74206c697665 << 0xc0 // @2989 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_298B: // Incoming jump from 0x29B3 // Incoming jump from 0x2A0A // Inputs[1] { @29A0 memory[0x00:0x24] } 298B 5B JUMPDEST 298C 63 PUSH4 0x4e487b71 2991 60 PUSH1 0xe0 2993 1B SHL 2994 60 PUSH1 0x00 2996 52 MSTORE 2997 60 PUSH1 0x11 2999 60 PUSH1 0x04 299B 52 MSTORE 299C 60 PUSH1 0x24 299E 60 PUSH1 0x00 29A0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2996 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @299B memory[0x04:0x24] = 0x11 // @29A0 revert(memory[0x00:0x24]); // } // Block terminates label_29A1: // Incoming call from 0x116E, returns to 0x0BA0 // Incoming call from 0x15D0, returns to 0x15D1 // Incoming call from 0x0B9F, returns to 0x0BA0 // Incoming call from 0x15A2, returns to 0x15A3 // Incoming call from 0x0FEF, returns to 0x0FF0 // Incoming call from 0x1627, returns to 0x1628 // Incoming call from 0x0A8A, returns to 0x0A8B // Incoming call from 0x0CCE, returns to 0x0CCF // Incoming call from 0x10AA, returns to 0x10AB // Incoming call from 0x0B47, returns to 0x0B48 // Inputs[2] // { // @29A4 stack[-2] // @29A6 stack[-1] // } 29A1 5B JUMPDEST 29A2 60 PUSH1 0x00 29A4 82 DUP3 29A5 19 NOT 29A6 82 DUP3 29A7 11 GT 29A8 15 ISZERO 29A9 61 PUSH2 0x29b4 29AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @29A2 stack[0] = 0x00 } // Block ends with conditional jump to 0x29b4, if !(stack[-1] > ~stack[-2]) label_29AD: // Incoming jump from 0x29AC, if not !(stack[-1] > ~stack[-2]) 29AD 61 PUSH2 0x29b4 29B0 61 PUSH2 0x298b 29B3 56 *JUMP // Stack delta = +1 // Outputs[1] { @29AD stack[0] = 0x29b4 } // Block ends with unconditional jump to 0x298b label_29B4: // Incoming jump from 0x29AC, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @29B6 stack[-2] // @29B6 stack[-3] // @29B7 stack[-4] // } 29B4 5B JUMPDEST 29B5 50 POP 29B6 01 ADD 29B7 90 SWAP1 29B8 56 *JUMP // Stack delta = -3 // Outputs[1] { @29B7 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_29B9: // Incoming call from 0x100D, returns to 0x08BF // Incoming call from 0x0AA8, returns to 0x08BF // Incoming call from 0x0CEC, returns to 0x08BF // Incoming call from 0x15C0, returns to 0x08BF // Inputs[2] // { // @29BD stack[-1] // @29D9 stack[-2] // } 29B9 5B JUMPDEST 29BA 60 PUSH1 0x20 29BC 80 DUP1 29BD 82 DUP3 29BE 52 MSTORE 29BF 60 PUSH1 0x08 29C1 90 SWAP1 29C2 82 DUP3 29C3 01 ADD 29C4 52 MSTORE 29C5 67 PUSH8 0x1cdbdb19081bdd5d 29CE 60 PUSH1 0xc2 29D0 1B SHL 29D1 60 PUSH1 0x40 29D3 82 DUP3 29D4 01 ADD 29D5 52 MSTORE 29D6 60 PUSH1 0x60 29D8 01 ADD 29D9 90 SWAP1 29DA 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @29BE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @29C4 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x08 // @29D5 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x1cdbdb19081bdd5d << 0xc2 // @29D9 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_29DB: // Incoming jump from 0x208F // Incoming jump from 0x20AC // Incoming jump from 0x210E // Incoming jump from 0x21DD // Incoming jump from 0x2170 // Inputs[1] { @29F0 memory[0x00:0x24] } 29DB 5B JUMPDEST 29DC 63 PUSH4 0x4e487b71 29E1 60 PUSH1 0xe0 29E3 1B SHL 29E4 60 PUSH1 0x00 29E6 52 MSTORE 29E7 60 PUSH1 0x21 29E9 60 PUSH1 0x04 29EB 52 MSTORE 29EC 60 PUSH1 0x24 29EE 60 PUSH1 0x00 29F0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @29E6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @29EB memory[0x04:0x24] = 0x21 // @29F0 revert(memory[0x00:0x24]); // } // Block terminates label_29F1: // Incoming call from 0x1215, returns to 0x11CD // Incoming call from 0x1132, returns to 0x1133 // Incoming call from 0x124F, returns to 0x11CD // Incoming call from 0x10FE, returns to 0x10FF // Incoming call from 0x1232, returns to 0x11CD // Incoming call from 0x1289, returns to 0x11CD // Incoming call from 0x11F8, returns to 0x11CD // Incoming call from 0x126C, returns to 0x11CD // Incoming call from 0x11CC, returns to 0x11CD // Incoming call from 0x0CFE, returns to 0x0CFF // Inputs[2] // { // @29F4 stack[-1] // @29F9 stack[-2] // } 29F1 5B JUMPDEST 29F2 60 PUSH1 0x00 29F4 81 DUP2 29F5 60 PUSH1 0x00 29F7 19 NOT 29F8 04 DIV 29F9 83 DUP4 29FA 11 GT 29FB 82 DUP3 29FC 15 ISZERO 29FD 15 ISZERO 29FE 16 AND 29FF 15 ISZERO 2A00 61 PUSH2 0x2a0b 2A03 57 *JUMPI // Stack delta = +1 // Outputs[1] { @29F2 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a0b, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2A04: // Incoming jump from 0x2A03, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2A04 61 PUSH2 0x2a0b 2A07 61 PUSH2 0x298b 2A0A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A04 stack[0] = 0x2a0b } // Block ends with unconditional jump to 0x298b label_2A0B: // Incoming jump from 0x2A03, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2A0D stack[-2] // @2A0D stack[-3] // @2A0E stack[-4] // } 2A0B 5B JUMPDEST 2A0C 50 POP 2A0D 02 MUL 2A0E 90 SWAP1 2A0F 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A0E stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_2A10: // Incoming call from 0x114F, returns to 0x08BF // Incoming call from 0x0D1B, returns to 0x08BF // Incoming call from 0x111B, returns to 0x08BF // Inputs[2] // { // @2A14 stack[-1] // @2A36 stack[-2] // } 2A10 5B JUMPDEST 2A11 60 PUSH1 0x20 2A13 80 DUP1 2A14 82 DUP3 2A15 52 MSTORE 2A16 60 PUSH1 0x0e 2A18 90 SWAP1 2A19 82 DUP3 2A1A 01 ADD 2A1B 52 MSTORE 2A1C 6D PUSH14 0x0dcdee840cadcdeeaced040cae8d 2A2B 60 PUSH1 0x93 2A2D 1B SHL 2A2E 60 PUSH1 0x40 2A30 82 DUP3 2A31 01 ADD 2A32 52 MSTORE 2A33 60 PUSH1 0x60 2A35 01 ADD 2A36 90 SWAP1 2A37 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @2A15 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2A1B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x0e // @2A32 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x0dcdee840cadcdeeaced040cae8d << 0x93 // @2A36 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2A38: // Incoming jump from 0x0DF5 // Inputs[1] { @2A4D memory[0x00:0x24] } 2A38 5B JUMPDEST 2A39 63 PUSH4 0x4e487b71 2A3E 60 PUSH1 0xe0 2A40 1B SHL 2A41 60 PUSH1 0x00 2A43 52 MSTORE 2A44 60 PUSH1 0x01 2A46 60 PUSH1 0x04 2A48 52 MSTORE 2A49 60 PUSH1 0x24 2A4B 60 PUSH1 0x00 2A4D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2A43 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2A48 memory[0x04:0x24] = 0x01 // @2A4D revert(memory[0x00:0x24]); // } // Block terminates label_2A4E: // Incoming jump from 0x2A72 // Inputs[1] { @2A63 memory[0x00:0x24] } 2A4E 5B JUMPDEST 2A4F 63 PUSH4 0x4e487b71 2A54 60 PUSH1 0xe0 2A56 1B SHL 2A57 60 PUSH1 0x00 2A59 52 MSTORE 2A5A 60 PUSH1 0x12 2A5C 60 PUSH1 0x04 2A5E 52 MSTORE 2A5F 60 PUSH1 0x24 2A61 60 PUSH1 0x00 2A63 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2A59 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2A5E memory[0x04:0x24] = 0x12 // @2A63 revert(memory[0x00:0x24]); // } // Block terminates label_2A64: // Incoming call from 0x11D6, returns to 0x11D7 // Inputs[1] { @2A67 stack[-2] } 2A64 5B JUMPDEST 2A65 60 PUSH1 0x00 2A67 82 DUP3 2A68 61 PUSH2 0x2a73 2A6B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A65 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a73, if stack[-2] label_2A6C: // Incoming jump from 0x2A6B, if not stack[-2] 2A6C 61 PUSH2 0x2a73 2A6F 61 PUSH2 0x2a4e 2A72 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A6C stack[0] = 0x2a73 } // Block ends with unconditional jump to 0x2a4e label_2A73: // Incoming jump from 0x2A6B, if stack[-2] // Inputs[3] // { // @2A75 stack[-3] // @2A75 stack[-2] // @2A76 stack[-4] // } 2A73 5B JUMPDEST 2A74 50 POP 2A75 04 DIV 2A76 90 SWAP1 2A77 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A76 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] 2A78 5B JUMPDEST 2A79 60 PUSH1 0x00 2A7B 83 DUP4 2A7C 51 MLOAD 2A7D 60 PUSH1 0x20 2A7F 61 PUSH2 0x2a8b 2A82 82 DUP3 2A83 85 DUP6 2A84 83 DUP4 2A85 89 DUP10 2A86 01 ADD 2A87 61 PUSH2 0x25a0 2A8A 56 *JUMP 2A8B 5B JUMPDEST 2A8C 84 DUP5 2A8D 54 SLOAD 2A8E 91 SWAP2 2A8F 84 DUP5 2A90 01 ADD 2A91 91 SWAP2 2A92 60 PUSH1 0x00 2A94 90 SWAP1 2A95 60 PUSH1 0x01 2A97 81 DUP2 2A98 81 DUP2 2A99 1C SHR 2A9A 90 SWAP1 2A9B 80 DUP1 2A9C 83 DUP4 2A9D 16 AND 2A9E 80 DUP1 2A9F 61 PUSH2 0x2aa9 2AA2 57 *JUMPI 2AA3 60 PUSH1 0x7f 2AA5 83 DUP4 2AA6 16 AND 2AA7 92 SWAP3 2AA8 50 POP 2AA9 5B JUMPDEST 2AAA 85 DUP6 2AAB 83 DUP4 2AAC 10 LT 2AAD 81 DUP2 2AAE 14 EQ 2AAF 15 ISZERO 2AB0 61 PUSH2 0x2ac7 2AB3 57 *JUMPI 2AB4 63 PUSH4 0x4e487b71 2AB9 60 PUSH1 0xe0 2ABB 1B SHL 2ABC 85 DUP6 2ABD 52 MSTORE 2ABE 60 PUSH1 0x22 2AC0 60 PUSH1 0x04 2AC2 52 MSTORE 2AC3 60 PUSH1 0x24 2AC5 85 DUP6 2AC6 FD *REVERT 2AC7 5B JUMPDEST 2AC8 80 DUP1 2AC9 80 DUP1 2ACA 15 ISZERO 2ACB 61 PUSH2 0x2adb 2ACE 57 *JUMPI 2ACF 60 PUSH1 0x01 2AD1 81 DUP2 2AD2 14 EQ 2AD3 61 PUSH2 0x2aec 2AD6 57 *JUMPI 2AD7 61 PUSH2 0x2b19 2ADA 56 *JUMP 2ADB 5B JUMPDEST 2ADC 60 PUSH1 0xff 2ADE 19 NOT 2ADF 85 DUP6 2AE0 16 AND 2AE1 88 DUP9 2AE2 52 MSTORE 2AE3 83 DUP4 2AE4 88 DUP9 2AE5 01 ADD 2AE6 95 SWAP6 2AE7 50 POP 2AE8 61 PUSH2 0x2b19 2AEB 56 *JUMP 2AEC 5B JUMPDEST 2AED 60 PUSH1 0x00 2AEF 8B DUP12 2AF0 81 DUP2 2AF1 52 MSTORE 2AF2 60 PUSH1 0x20 2AF4 90 SWAP1 2AF5 20 SHA3 2AF6 60 PUSH1 0x00 2AF8 5B JUMPDEST 2AF9 85 DUP6 2AFA 81 DUP2 2AFB 10 LT 2AFC 15 ISZERO 2AFD 61 PUSH2 0x2b11 2B00 57 *JUMPI 2B01 81 DUP2 2B02 54 SLOAD 2B03 8A DUP11 2B04 82 DUP3 2B05 01 ADD 2B06 52 MSTORE 2B07 90 SWAP1 2B08 84 DUP5 2B09 01 ADD 2B0A 90 SWAP1 2B0B 88 DUP9 2B0C 01 ADD 2B0D 61 PUSH2 0x2af8 2B10 56 *JUMP 2B11 5B JUMPDEST 2B12 50 POP 2B13 50 POP 2B14 83 DUP4 2B15 88 DUP9 2B16 01 ADD 2B17 95 SWAP6 2B18 50 POP 2B19 5B JUMPDEST 2B1A 50 POP 2B1B 93 SWAP4 2B1C 9A SWAP11 2B1D 99 SWAP10 2B1E 50 POP 2B1F 50 POP 2B20 50 POP 2B21 50 POP 2B22 50 POP 2B23 50 POP 2B24 50 POP 2B25 50 POP 2B26 50 POP 2B27 50 POP 2B28 56 *JUMP label_2B29: // Incoming jump from 0x1742 // Inputs[2] // { // @2B2E stack[-1] // @2B2F stack[-2] // } 2B29 5B JUMPDEST 2B2A 60 PUSH1 0x00 2B2C 60 PUSH1 0x20 2B2E 82 DUP3 2B2F 84 DUP5 2B30 03 SUB 2B31 12 SLT 2B32 15 ISZERO 2B33 61 PUSH2 0x2b3b 2B36 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B2A stack[0] = 0x00 } // Block ends with conditional jump to 0x2b3b, if !(stack[-2] - stack[-1] i< 0x20) label_2B37: // Incoming jump from 0x2B36, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2B3A memory[0x00:0x00] } 2B37 60 PUSH1 0x00 2B39 80 DUP1 2B3A FD *REVERT // Stack delta = +0 // Outputs[1] { @2B3A revert(memory[0x00:0x00]); } // Block terminates label_2B3B: // Incoming jump from 0x2B36, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2B3C stack[-2] // @2B3D memory[stack[-2]:stack[-2] + 0x20] // } 2B3B 5B JUMPDEST 2B3C 81 DUP2 2B3D 51 MLOAD 2B3E 61 PUSH2 0x1e38 2B41 81 DUP2 2B42 61 PUSH2 0x256e 2B45 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B3D stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2B3E stack[1] = 0x1e38 // @2B41 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x256e, returns to 0x1E38 label_2B46: // Incoming call from 0x1CFE, returns to 0x1CFF // Inputs[5] // { // @2B4F stack[-5] // @2B52 stack[-1] // @2B54 stack[-4] // @2B5F stack[-3] // @2B74 stack[-2] // } 2B46 5B JUMPDEST 2B47 60 PUSH1 0x01 2B49 60 PUSH1 0x01 2B4B 60 PUSH1 0xa0 2B4D 1B SHL 2B4E 03 SUB 2B4F 85 DUP6 2B50 81 DUP2 2B51 16 AND 2B52 82 DUP3 2B53 52 MSTORE 2B54 84 DUP5 2B55 16 AND 2B56 60 PUSH1 0x20 2B58 82 DUP3 2B59 01 ADD 2B5A 52 MSTORE 2B5B 60 PUSH1 0x40 2B5D 81 DUP2 2B5E 01 ADD 2B5F 83 DUP4 2B60 90 SWAP1 2B61 52 MSTORE 2B62 60 PUSH1 0x80 2B64 60 PUSH1 0x60 2B66 82 DUP3 2B67 01 ADD 2B68 81 DUP2 2B69 90 SWAP1 2B6A 52 MSTORE 2B6B 60 PUSH1 0x00 2B6D 90 SWAP1 2B6E 61 PUSH2 0x2b79 2B71 90 SWAP1 2B72 83 DUP4 2B73 01 ADD 2B74 84 DUP5 2B75 61 PUSH2 0x25cc 2B78 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @2B53 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @2B5A memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2B61 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @2B6A memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @2B6D stack[0] = 0x00 // @2B71 stack[1] = 0x2b79 // @2B73 stack[2] = stack[-1] + 0x80 // @2B74 stack[3] = stack[-2] // } // Block ends with call to 0x25cc, returns to 0x2B79 label_2B79: // Incoming return from call to 0x25CC at 0x2B78 // Inputs[3] // { // @2B7A stack[-8] // @2B7A stack[-1] // @2B7B stack[-7] // } 2B79 5B JUMPDEST 2B7A 96 SWAP7 2B7B 95 SWAP6 2B7C 50 POP 2B7D 50 POP 2B7E 50 POP 2B7F 50 POP 2B80 50 POP 2B81 50 POP 2B82 56 *JUMP // Stack delta = -7 // Outputs[1] { @2B7A stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_2B83: // Incoming jump from 0x1D36 // Inputs[2] // { // @2B88 stack[-1] // @2B89 stack[-2] // } 2B83 5B JUMPDEST 2B84 60 PUSH1 0x00 2B86 60 PUSH1 0x20 2B88 82 DUP3 2B89 84 DUP5 2B8A 03 SUB 2B8B 12 SLT 2B8C 15 ISZERO 2B8D 61 PUSH2 0x2b95 2B90 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B84 stack[0] = 0x00 } // Block ends with conditional jump to 0x2b95, if !(stack[-2] - stack[-1] i< 0x20) label_2B91: // Incoming jump from 0x2B90, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2B94 memory[0x00:0x00] } 2B91 60 PUSH1 0x00 2B93 80 DUP1 2B94 FD *REVERT // Stack delta = +0 // Outputs[1] { @2B94 revert(memory[0x00:0x00]); } // Block terminates label_2B95: // Incoming jump from 0x2B90, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2B96 stack[-2] // @2B97 memory[stack[-2]:stack[-2] + 0x20] // } 2B95 5B JUMPDEST 2B96 81 DUP2 2B97 51 MLOAD 2B98 61 PUSH2 0x1e38 2B9B 81 DUP2 2B9C 61 PUSH2 0x253b 2B9F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B97 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2B98 stack[1] = 0x1e38 // @2B9B stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x253b, returns to 0x1E38 2BA0 5B JUMPDEST 2BA1 60 PUSH1 0x00 2BA3 83 DUP4 2BA4 51 MLOAD 2BA5 61 PUSH2 0x2bb2 2BA8 81 DUP2 2BA9 84 DUP5 2BAA 60 PUSH1 0x20 2BAC 88 DUP9 2BAD 01 ADD 2BAE 61 PUSH2 0x25a0 2BB1 56 *JUMP 2BB2 5B JUMPDEST 2BB3 83 DUP4 2BB4 51 MLOAD 2BB5 90 SWAP1 2BB6 83 DUP4 2BB7 01 ADD 2BB8 90 SWAP1 2BB9 61 PUSH2 0x2bc6 2BBC 81 DUP2 2BBD 83 DUP4 2BBE 60 PUSH1 0x20 2BC0 88 DUP9 2BC1 01 ADD 2BC2 61 PUSH2 0x25a0 2BC5 56 *JUMP 2BC6 5B JUMPDEST 2BC7 01 ADD 2BC8 94 SWAP5 2BC9 93 SWAP4 2BCA 50 POP 2BCB 50 POP 2BCC 50 POP 2BCD 50 POP 2BCE 56 *JUMP 2BCF 5B JUMPDEST 2BD0 60 PUSH1 0x00 2BD2 60 PUSH1 0x00 2BD4 19 NOT 2BD5 82 DUP3 2BD6 14 EQ 2BD7 15 ISZERO 2BD8 61 PUSH2 0x0e94 2BDB 57 *JUMPI 2BDC 61 PUSH2 0x0e94 2BDF 61 PUSH2 0x298b 2BE2 56 *JUMP 2BE3 5B JUMPDEST 2BE4 60 PUSH1 0x00 2BE6 82 DUP3 2BE7 82 DUP3 2BE8 10 LT 2BE9 15 ISZERO 2BEA 61 PUSH2 0x2bf5 2BED 57 *JUMPI 2BEE 61 PUSH2 0x2bf5 2BF1 61 PUSH2 0x298b 2BF4 56 *JUMP 2BF5 5B JUMPDEST 2BF6 50 POP 2BF7 03 SUB 2BF8 90 SWAP1 2BF9 56 *JUMP 2BFA 5B JUMPDEST 2BFB 60 PUSH1 0x00 2BFD 82 DUP3 2BFE 61 PUSH2 0x2c09 2C01 57 *JUMPI 2C02 61 PUSH2 0x2c09 2C05 61 PUSH2 0x2a4e 2C08 56 *JUMP 2C09 5B JUMPDEST 2C0A 50 POP 2C0B 06 MOD 2C0C 90 SWAP1 2C0D 56 *JUMP 2C0E 5B JUMPDEST 2C0F 63 PUSH4 0x4e487b71 2C14 60 PUSH1 0xe0 2C16 1B SHL 2C17 60 PUSH1 0x00 2C19 52 MSTORE 2C1A 60 PUSH1 0x32 2C1C 60 PUSH1 0x04 2C1E 52 MSTORE 2C1F 60 PUSH1 0x24 2C21 60 PUSH1 0x00 2C23 FD *REVERT 2C24 FE *ASSERT 2C25 A2 LOG2 2C26 64 PUSH5 0x6970667358 2C2C 22 22 2C2D 12 SLT 2C2E 20 SHA3 2C2F 94 SWAP5 2C30 C2 C2 2C31 B2 SWAP 2C32 B7 B7 2C33 A5 A5 2C34 AF AF 2C35 2A 2A 2C36 E5 E5 2C37 74 PUSH21 0x0aed12187cf42d448b22000ce6b780ad7f0a23baef 2C4D 14 EQ 2C4E 45 GASLIMIT 2C4F 64 PUSH5 0x736f6c6343 2C55 00 *STOP 2C56 08 ADDMOD 2C57 0B SIGNEXTEND 2C58 00 *STOP 2C59 33 CALLER