Online Solidity Decompiler

label_0000: // Inputs[1] { @0005 msg.value } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 34 CALLVALUE 0006 80 DUP1 0007 15 ISZERO 0008 61 PUSH2 0x0010 000B 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0004 memory[0x40:0x60] = 0x80 // @0005 stack[0] = msg.value // } // Block ends with conditional jump to 0x0010, if !msg.value label_000C: // Incoming jump from 0x000B, if not !msg.value // Inputs[1] { @000F memory[0x00:0x00] } 000C 60 PUSH1 0x00 000E 80 DUP1 000F FD *REVERT // Stack delta = +0 // Outputs[1] { @000F revert(memory[0x00:0x00]); } // Block terminates label_0010: // Incoming jump from 0x000B, if !msg.value // Inputs[1] { @0014 msg.data.length } 0010 5B JUMPDEST 0011 50 POP 0012 60 PUSH1 0x04 0014 36 CALLDATASIZE 0015 10 LT 0016 61 PUSH2 0x018c 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x018c, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x7a62b340 0026 11 GT 0027 61 PUSH2 0x00e3 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00e3, if 0x7a62b340 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x7a62b340 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xbb0b66f0 0031 11 GT 0032 61 PUSH2 0x008c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008c, if 0xbb0b66f0 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xbb0b66f0 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xee9a31a2 003C 11 GT 003D 61 PUSH2 0x0066 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0xee9a31a2 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xee9a31a2 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xee9a31a2 0047 14 EQ 0048 61 PUSH2 0x0340 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0340, if 0xee9a31a2 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xee9a31a2 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xf242432a 0052 14 EQ 0053 61 PUSH2 0x0353 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0353, if 0xf242432a == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xf242432a == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x0366 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0366, if 0xf2fde38b == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0065 memory[0x00:0x00] } 0062 60 PUSH1 0x00 0064 80 DUP1 0065 FD *REVERT // Stack delta = +0 // Outputs[1] { @0065 revert(memory[0x00:0x00]); } // Block terminates label_0066: // Incoming jump from 0x0040, if 0xee9a31a2 > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0xbb0b66f0 006D 14 EQ 006E 61 PUSH2 0x02de 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02de, if 0xbb0b66f0 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0xbb0b66f0 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0xc87b56dd 0078 14 EQ 0079 61 PUSH2 0x02f1 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f1, if 0xc87b56dd == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xc87b56dd == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xe985e9c5 0083 14 EQ 0084 61 PUSH2 0x0304 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0304, if 0xe985e9c5 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @008B memory[0x00:0x00] } 0088 60 PUSH1 0x00 008A 80 DUP1 008B FD *REVERT // Stack delta = +0 // Outputs[1] { @008B revert(memory[0x00:0x00]); } // Block terminates label_008C: // Incoming jump from 0x0035, if 0xbb0b66f0 > stack[-1] // Inputs[1] { @008D stack[-1] } 008C 5B JUMPDEST 008D 80 DUP1 008E 63 PUSH4 0x95d89b41 0093 11 GT 0094 61 PUSH2 0x00bd 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bd, if 0x95d89b41 > stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x95d89b41 > stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x95d89b41 009E 14 EQ 009F 61 PUSH2 0x02bb 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02bb, if 0x95d89b41 == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x9ef5c7eb 00A9 14 EQ 00AA 61 PUSH2 0x02c3 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c3, if 0x9ef5c7eb == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x9ef5c7eb == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0xa22cb465 00B4 14 EQ 00B5 61 PUSH2 0x02cb 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cb, if 0xa22cb465 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00BC memory[0x00:0x00] } 00B9 60 PUSH1 0x00 00BB 80 DUP1 00BC FD *REVERT // Stack delta = +0 // Outputs[1] { @00BC revert(memory[0x00:0x00]); } // Block terminates label_00BD: // Incoming jump from 0x0097, if 0x95d89b41 > stack[-1] // Inputs[1] { @00BE stack[-1] } 00BD 5B JUMPDEST 00BE 80 DUP1 00BF 63 PUSH4 0x7a62b340 00C4 14 EQ 00C5 61 PUSH2 0x01ef 00C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ef, if 0x7a62b340 == stack[-1] label_00C9: // Incoming jump from 0x00C8, if not 0x7a62b340 == stack[-1] // Inputs[1] { @00C9 stack[-1] } 00C9 80 DUP1 00CA 63 PUSH4 0x7fc39c9d 00CF 14 EQ 00D0 61 PUSH2 0x0277 00D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0277, if 0x7fc39c9d == stack[-1] label_00D4: // Incoming jump from 0x00D3, if not 0x7fc39c9d == stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D4 80 DUP1 00D5 63 PUSH4 0x8da5cb5b 00DA 14 EQ 00DB 61 PUSH2 0x0296 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0296, if 0x8da5cb5b == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00E2 memory[0x00:0x00] } 00DF 60 PUSH1 0x00 00E1 80 DUP1 00E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E2 revert(memory[0x00:0x00]); } // Block terminates label_00E3: // Incoming jump from 0x002A, if 0x7a62b340 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00E4 stack[-1] } 00E3 5B JUMPDEST 00E4 80 DUP1 00E5 63 PUSH4 0x2c678c64 00EA 11 GT 00EB 61 PUSH2 0x0145 00EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0145, if 0x2c678c64 > stack[-1] label_00EF: // Incoming jump from 0x00EE, if not 0x2c678c64 > stack[-1] // Inputs[1] { @00EF stack[-1] } 00EF 80 DUP1 00F0 63 PUSH4 0x51232a51 00F5 11 GT 00F6 61 PUSH2 0x011f 00F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011f, if 0x51232a51 > stack[-1] label_00FA: // Incoming jump from 0x00F9, if not 0x51232a51 > stack[-1] // Inputs[1] { @00FA stack[-1] } 00FA 80 DUP1 00FB 63 PUSH4 0x51232a51 0100 14 EQ 0101 61 PUSH2 0x0249 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0249, if 0x51232a51 == stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x51232a51 == stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x55f804b3 010B 14 EQ 010C 61 PUSH2 0x025c 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025c, if 0x55f804b3 == stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x715018a6 0116 14 EQ 0117 61 PUSH2 0x026f 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026f, if 0x715018a6 == stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x715018a6 == stack[-1] // Inputs[1] { @011E memory[0x00:0x00] } 011B 60 PUSH1 0x00 011D 80 DUP1 011E FD *REVERT // Stack delta = +0 // Outputs[1] { @011E revert(memory[0x00:0x00]); } // Block terminates label_011F: // Incoming jump from 0x00F9, if 0x51232a51 > stack[-1] // Inputs[1] { @0120 stack[-1] } 011F 5B JUMPDEST 0120 80 DUP1 0121 63 PUSH4 0x2c678c64 0126 14 EQ 0127 61 PUSH2 0x020b 012A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020b, if 0x2c678c64 == stack[-1] label_012B: // Incoming jump from 0x012A, if not 0x2c678c64 == stack[-1] // Inputs[1] { @012B stack[-1] } 012B 80 DUP1 012C 63 PUSH4 0x2eb2c2d6 0131 14 EQ 0132 61 PUSH2 0x0214 0135 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0214, if 0x2eb2c2d6 == stack[-1] label_0136: // Incoming jump from 0x0135, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @0136 stack[-1] } 0136 80 DUP1 0137 63 PUSH4 0x4e1273f4 013C 14 EQ 013D 61 PUSH2 0x0229 0140 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0229, if 0x4e1273f4 == stack[-1] label_0141: // Incoming jump from 0x0140, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @0144 memory[0x00:0x00] } 0141 60 PUSH1 0x00 0143 80 DUP1 0144 FD *REVERT // Stack delta = +0 // Outputs[1] { @0144 revert(memory[0x00:0x00]); } // Block terminates label_0145: // Incoming jump from 0x00EE, if 0x2c678c64 > stack[-1] // Inputs[1] { @0146 stack[-1] } 0145 5B JUMPDEST 0146 80 DUP1 0147 63 PUSH4 0x06fdde03 014C 11 GT 014D 61 PUSH2 0x0176 0150 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0176, if 0x06fdde03 > stack[-1] label_0151: // Incoming jump from 0x0150, if not 0x06fdde03 > stack[-1] // Inputs[1] { @0151 stack[-1] } 0151 80 DUP1 0152 63 PUSH4 0x06fdde03 0157 14 EQ 0158 61 PUSH2 0x01da 015B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01da, if 0x06fdde03 == stack[-1] label_015C: // Incoming jump from 0x015B, if not 0x06fdde03 == stack[-1] // Inputs[1] { @015C stack[-1] } 015C 80 DUP1 015D 63 PUSH4 0x0e89341c 0162 14 EQ 0163 61 PUSH2 0x01ef 0166 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ef, if 0x0e89341c == stack[-1] label_0167: // Incoming jump from 0x0166, if not 0x0e89341c == stack[-1] // Inputs[1] { @0167 stack[-1] } 0167 80 DUP1 0168 63 PUSH4 0x1d224352 016D 14 EQ 016E 61 PUSH2 0x0202 0171 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0202, if 0x1d224352 == stack[-1] label_0172: // Incoming jump from 0x0171, if not 0x1d224352 == stack[-1] // Inputs[1] { @0175 memory[0x00:0x00] } 0172 60 PUSH1 0x00 0174 80 DUP1 0175 FD *REVERT // Stack delta = +0 // Outputs[1] { @0175 revert(memory[0x00:0x00]); } // Block terminates label_0176: // Incoming jump from 0x0150, if 0x06fdde03 > stack[-1] // Inputs[1] { @0177 stack[-1] } 0176 5B JUMPDEST 0177 80 DUP1 0178 62 PUSH3 0xfdd58e 017C 14 EQ 017D 61 PUSH2 0x0191 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0191, if 0xfdd58e == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0xfdd58e == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x01ffc9a7 0187 14 EQ 0188 61 PUSH2 0x01b7 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b7, if 0x01ffc9a7 == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x01ffc9a7 == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @0190 memory[0x00:0x00] } 018C 5B JUMPDEST 018D 60 PUSH1 0x00 018F 80 DUP1 0190 FD *REVERT // Stack delta = +0 // Outputs[1] { @0190 revert(memory[0x00:0x00]); } // Block terminates label_0191: // Incoming jump from 0x0180, if 0xfdd58e == stack[-1] // Inputs[1] { @0198 msg.data.length } 0191 5B JUMPDEST 0192 61 PUSH2 0x01a4 0195 61 PUSH2 0x019f 0198 36 CALLDATASIZE 0199 60 PUSH1 0x04 019B 61 PUSH2 0x1d02 019E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0192 stack[0] = 0x01a4 // @0195 stack[1] = 0x019f // @0198 stack[2] = msg.data.length // @0199 stack[3] = 0x04 // } // Block ends with call to 0x1d02, returns to 0x019F label_019F: // Incoming return from call to 0x1D02 at 0x019E 019F 5B JUMPDEST 01A0 61 PUSH2 0x0379 01A3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0379 label_01A4: // Incoming jump from 0x0213 // Incoming jump from 0x020A // Incoming return from call to 0x019F at 0x019E // Inputs[4] // { // @01A7 memory[0x40:0x60] // @01A8 stack[-1] // @01B1 memory[0x40:0x60] // @01B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01A4 5B JUMPDEST 01A5 60 PUSH1 0x40 01A7 51 MLOAD 01A8 90 SWAP1 01A9 81 DUP2 01AA 52 MSTORE 01AB 60 PUSH1 0x20 01AD 01 ADD 01AE 5B JUMPDEST 01AF 60 PUSH1 0x40 01B1 51 MLOAD 01B2 80 DUP1 01B3 91 SWAP2 01B4 03 SUB 01B5 90 SWAP1 01B6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @01B6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01B7: // Incoming jump from 0x018B, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01BE msg.data.length } 01B7 5B JUMPDEST 01B8 61 PUSH2 0x01ca 01BB 61 PUSH2 0x01c5 01BE 36 CALLDATASIZE 01BF 60 PUSH1 0x04 01C1 61 PUSH2 0x1e5f 01C4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01B8 stack[0] = 0x01ca // @01BB stack[1] = 0x01c5 // @01BE stack[2] = msg.data.length // @01BF stack[3] = 0x04 // } // Block ends with call to 0x1e5f, returns to 0x01C5 label_01C5: // Incoming return from call to 0x1E5F at 0x01C4 01C5 5B JUMPDEST 01C6 61 PUSH2 0x0422 01C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0422 label_01CA: // Incoming return from call to 0x01C5 at 0x01C4 // Incoming return from call to 0x0312 at 0x0311 // Inputs[2] // { // @01CD memory[0x40:0x60] // @01CE stack[-1] // } 01CA 5B JUMPDEST 01CB 60 PUSH1 0x40 01CD 51 MLOAD 01CE 90 SWAP1 01CF 15 ISZERO 01D0 15 ISZERO 01D1 81 DUP2 01D2 52 MSTORE 01D3 60 PUSH1 0x20 01D5 01 ADD 01D6 61 PUSH2 0x01ae 01D9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01D2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01D5 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01ae label_01DA: // Incoming jump from 0x015B, if 0x06fdde03 == stack[-1] 01DA 5B JUMPDEST 01DB 61 PUSH2 0x01e2 01DE 61 PUSH2 0x04bf 01E1 56 *JUMP // Stack delta = +1 // Outputs[1] { @01DB stack[0] = 0x01e2 } // Block ends with call to 0x04bf, returns to 0x01E2 label_01E2: // Incoming return from call to 0x04BF at 0x01E1 // Incoming return from call to 0x02FF at 0x02FE // Incoming return from call to 0x09F6 at 0x02C2 // Incoming return from call to 0x0A03 at 0x02CA // Inputs[2] // { // @01E5 memory[0x40:0x60] // @01E9 stack[-1] // } 01E2 5B JUMPDEST 01E3 60 PUSH1 0x40 01E5 51 MLOAD 01E6 61 PUSH2 0x01ae 01E9 91 SWAP2 01EA 90 SWAP1 01EB 61 PUSH2 0x2093 01EE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01E9 stack[-1] = 0x01ae // @01EA stack[1] = memory[0x40:0x60] // @01EA stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2093 label_01EF: // Incoming jump from 0x00C8, if 0x7a62b340 == stack[-1] // Incoming jump from 0x0166, if 0x0e89341c == stack[-1] // Inputs[1] { @01F6 msg.data.length } 01EF 5B JUMPDEST 01F0 61 PUSH2 0x01e2 01F3 61 PUSH2 0x01fd 01F6 36 CALLDATASIZE 01F7 60 PUSH1 0x04 01F9 61 PUSH2 0x1f04 01FC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01F0 stack[0] = 0x01e2 // @01F3 stack[1] = 0x01fd // @01F6 stack[2] = msg.data.length // @01F7 stack[3] = 0x04 // } // Block ends with call to 0x1f04, returns to 0x01FD label_01FD: // Incoming return from call to 0x1F04 at 0x01FC 01FD 5B JUMPDEST 01FE 61 PUSH2 0x054d 0201 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x054d label_0202: // Incoming jump from 0x0171, if 0x1d224352 == stack[-1] 0202 5B JUMPDEST 0203 61 PUSH2 0x01a4 0206 61 PUSH2 0x01f4 0209 81 DUP2 020A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0203 stack[0] = 0x01a4 // @0206 stack[1] = 0x01f4 // } // Block ends with unconditional jump to 0x01a4 label_020B: // Incoming jump from 0x012A, if 0x2c678c64 == stack[-1] // Inputs[1] { @0211 storage[0x09] } 020B 5B JUMPDEST 020C 61 PUSH2 0x01a4 020F 60 PUSH1 0x09 0211 54 SLOAD 0212 81 DUP2 0213 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @020C stack[0] = 0x01a4 // @0211 stack[1] = storage[0x09] // } // Block ends with unconditional jump to 0x01a4 label_0214: // Incoming jump from 0x0135, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @021B msg.data.length } 0214 5B JUMPDEST 0215 61 PUSH2 0x0227 0218 61 PUSH2 0x0222 021B 36 CALLDATASIZE 021C 60 PUSH1 0x04 021E 61 PUSH2 0x1bbf 0221 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0215 stack[0] = 0x0227 // @0218 stack[1] = 0x0222 // @021B stack[2] = msg.data.length // @021C stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1bbf 0222 5B JUMPDEST 0223 61 PUSH2 0x0558 0226 56 *JUMP label_0227: // Incoming return from call to 0x02D9 at 0x02D8 // Incoming return from call to 0x0990 at 0x0276 // Incoming return from call to 0x02EC at 0x02EB 0227 5B JUMPDEST 0228 00 *STOP // Stack delta = +0 // Outputs[1] { @0228 stop(); } // Block terminates label_0229: // Incoming jump from 0x0140, if 0x4e1273f4 == stack[-1] // Inputs[1] { @0230 msg.data.length } 0229 5B JUMPDEST 022A 61 PUSH2 0x023c 022D 61 PUSH2 0x0237 0230 36 CALLDATASIZE 0231 60 PUSH1 0x04 0233 61 PUSH2 0x1d94 0236 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @022A stack[0] = 0x023c // @022D stack[1] = 0x0237 // @0230 stack[2] = msg.data.length // @0231 stack[3] = 0x04 // } // Block ends with call to 0x1d94, returns to 0x0237 label_0237: // Incoming return from call to 0x1D94 at 0x0236 0237 5B JUMPDEST 0238 61 PUSH2 0x05fa 023B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05fa label_023C: // Incoming return from call to 0x0237 at 0x0236 // Inputs[2] // { // @023F memory[0x40:0x60] // @0243 stack[-1] // } 023C 5B JUMPDEST 023D 60 PUSH1 0x40 023F 51 MLOAD 0240 61 PUSH2 0x01ae 0243 91 SWAP2 0244 90 SWAP1 0245 61 PUSH2 0x2052 0248 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0243 stack[-1] = 0x01ae // @0244 stack[1] = memory[0x40:0x60] // @0244 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2052 label_0249: // Incoming jump from 0x0104, if 0x51232a51 == stack[-1] // Inputs[1] { @0250 msg.data.length } 0249 5B JUMPDEST 024A 61 PUSH2 0x01a4 024D 61 PUSH2 0x0257 0250 36 CALLDATASIZE 0251 60 PUSH1 0x04 0253 61 PUSH2 0x1d02 0256 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @024A stack[0] = 0x01a4 // @024D stack[1] = 0x0257 // @0250 stack[2] = msg.data.length // @0251 stack[3] = 0x04 // } // Block ends with call to 0x1d02, returns to 0x0257 label_0257: // Incoming return from call to 0x1D02 at 0x0256 0257 5B JUMPDEST 0258 61 PUSH2 0x0770 025B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0770 label_025C: // Incoming jump from 0x010F, if 0x55f804b3 == stack[-1] // Inputs[1] { @0263 msg.data.length } 025C 5B JUMPDEST 025D 61 PUSH2 0x0227 0260 61 PUSH2 0x026a 0263 36 CALLDATASIZE 0264 60 PUSH1 0x04 0266 61 PUSH2 0x1e97 0269 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @025D stack[0] = 0x0227 // @0260 stack[1] = 0x026a // @0263 stack[2] = msg.data.length // @0264 stack[3] = 0x04 // } // Block ends with call to 0x1e97, returns to 0x026A label_026A: // Incoming return from call to 0x1E97 at 0x0269 026A 5B JUMPDEST 026B 61 PUSH2 0x0925 026E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0925 label_026F: // Incoming jump from 0x011A, if 0x715018a6 == stack[-1] 026F 5B JUMPDEST 0270 61 PUSH2 0x0227 0273 61 PUSH2 0x0990 0276 56 *JUMP // Stack delta = +1 // Outputs[1] { @0270 stack[0] = 0x0227 } // Block ends with call to 0x0990, returns to 0x0227 label_0277: // Incoming jump from 0x00D3, if 0x7fc39c9d == stack[-1] // Inputs[1] { @027A storage[0x08] } 0277 5B JUMPDEST 0278 60 PUSH1 0x08 027A 54 SLOAD 027B 61 PUSH2 0x0284 027E 90 SWAP1 027F 60 PUSH1 0xff 0281 16 AND 0282 81 DUP2 0283 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @027E stack[0] = 0x0284 // @0281 stack[1] = 0xff & storage[0x08] // } // Block ends with unconditional jump to 0x0284 label_0284: // Incoming jump from 0x0283 // Inputs[2] // { // @0287 memory[0x40:0x60] // @028B stack[-1] // } 0284 5B JUMPDEST 0285 60 PUSH1 0x40 0287 51 MLOAD 0288 60 PUSH1 0xff 028A 90 SWAP1 028B 91 SWAP2 028C 16 AND 028D 81 DUP2 028E 52 MSTORE 028F 60 PUSH1 0x20 0291 01 ADD 0292 61 PUSH2 0x01ae 0295 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @028E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @0291 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01ae label_0296: // Incoming jump from 0x00DE, if 0x8da5cb5b == stack[-1] // Inputs[2] // { // @0299 storage[0x03] // @02A6 memory[0x40:0x60] // } 0296 5B JUMPDEST 0297 60 PUSH1 0x03 0299 54 SLOAD 029A 60 PUSH1 0x01 029C 60 PUSH1 0x01 029E 60 PUSH1 0xa0 02A0 1B SHL 02A1 03 SUB 02A2 16 AND 02A3 5B JUMPDEST 02A4 60 PUSH1 0x40 02A6 51 MLOAD 02A7 60 PUSH1 0x01 02A9 60 PUSH1 0x01 02AB 60 PUSH1 0xa0 02AD 1B SHL 02AE 03 SUB 02AF 90 SWAP1 02B0 91 SWAP2 02B1 16 AND 02B2 81 DUP2 02B3 52 MSTORE 02B4 60 PUSH1 0x20 02B6 01 ADD 02B7 61 PUSH2 0x01ae 02BA 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @02B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x01 << 0xa0) - 0x01 & storage[0x03] & (0x01 << 0xa0) - 0x01 // @02B6 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01ae label_02BB: // Incoming jump from 0x00A2, if 0x95d89b41 == stack[-1] 02BB 5B JUMPDEST 02BC 61 PUSH2 0x01e2 02BF 61 PUSH2 0x09f6 02C2 56 *JUMP // Stack delta = +1 // Outputs[1] { @02BC stack[0] = 0x01e2 } // Block ends with call to 0x09f6, returns to 0x01E2 label_02C3: // Incoming jump from 0x00AD, if 0x9ef5c7eb == stack[-1] 02C3 5B JUMPDEST 02C4 61 PUSH2 0x01e2 02C7 61 PUSH2 0x0a03 02CA 56 *JUMP // Stack delta = +1 // Outputs[1] { @02C4 stack[0] = 0x01e2 } // Block ends with call to 0x0a03, returns to 0x01E2 label_02CB: // Incoming jump from 0x00B8, if 0xa22cb465 == stack[-1] // Inputs[1] { @02D2 msg.data.length } 02CB 5B JUMPDEST 02CC 61 PUSH2 0x0227 02CF 61 PUSH2 0x02d9 02D2 36 CALLDATASIZE 02D3 60 PUSH1 0x04 02D5 61 PUSH2 0x1cc8 02D8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02CC stack[0] = 0x0227 // @02CF stack[1] = 0x02d9 // @02D2 stack[2] = msg.data.length // @02D3 stack[3] = 0x04 // } // Block ends with call to 0x1cc8, returns to 0x02D9 label_02D9: // Incoming return from call to 0x1CC8 at 0x02D8 02D9 5B JUMPDEST 02DA 61 PUSH2 0x0a10 02DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a10 label_02DE: // Incoming jump from 0x0071, if 0xbb0b66f0 == stack[-1] // Inputs[1] { @02E5 msg.data.length } 02DE 5B JUMPDEST 02DF 61 PUSH2 0x0227 02E2 61 PUSH2 0x02ec 02E5 36 CALLDATASIZE 02E6 60 PUSH1 0x04 02E8 61 PUSH2 0x1d2b 02EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DF stack[0] = 0x0227 // @02E2 stack[1] = 0x02ec // @02E5 stack[2] = msg.data.length // @02E6 stack[3] = 0x04 // } // Block ends with call to 0x1d2b, returns to 0x02EC label_02EC: // Incoming return from call to 0x1D2B at 0x02EB 02EC 5B JUMPDEST 02ED 61 PUSH2 0x0afb 02F0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0afb label_02F1: // Incoming jump from 0x007C, if 0xc87b56dd == stack[-1] // Inputs[1] { @02F8 msg.data.length } 02F1 5B JUMPDEST 02F2 61 PUSH2 0x01e2 02F5 61 PUSH2 0x02ff 02F8 36 CALLDATASIZE 02F9 60 PUSH1 0x04 02FB 61 PUSH2 0x1f04 02FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F2 stack[0] = 0x01e2 // @02F5 stack[1] = 0x02ff // @02F8 stack[2] = msg.data.length // @02F9 stack[3] = 0x04 // } // Block ends with call to 0x1f04, returns to 0x02FF label_02FF: // Incoming return from call to 0x1F04 at 0x02FE 02FF 5B JUMPDEST 0300 61 PUSH2 0x0cc2 0303 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cc2 label_0304: // Incoming jump from 0x0087, if 0xe985e9c5 == stack[-1] // Inputs[1] { @030B msg.data.length } 0304 5B JUMPDEST 0305 61 PUSH2 0x01ca 0308 61 PUSH2 0x0312 030B 36 CALLDATASIZE 030C 60 PUSH1 0x04 030E 61 PUSH2 0x1b8d 0311 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0305 stack[0] = 0x01ca // @0308 stack[1] = 0x0312 // @030B stack[2] = msg.data.length // @030C stack[3] = 0x04 // } // Block ends with call to 0x1b8d, returns to 0x0312 label_0312: // Incoming call from 0x0DD5, returns to 0x0DD6 // Incoming return from call to 0x1B8D at 0x0311 // Inputs[6] // { // @031B stack[-2] // @032E memory[0x00:0x40] // @032F stack[-1] // @0339 memory[0x00:0x40] // @033A storage[keccak256(memory[0x00:0x40])] // @033E stack[-3] // } 0312 5B JUMPDEST 0313 60 PUSH1 0x01 0315 60 PUSH1 0x01 0317 60 PUSH1 0xa0 0319 1B SHL 031A 03 SUB 031B 91 SWAP2 031C 82 DUP3 031D 16 AND 031E 60 PUSH1 0x00 0320 90 SWAP1 0321 81 DUP2 0322 52 MSTORE 0323 60 PUSH1 0x01 0325 60 PUSH1 0x20 0327 90 SWAP1 0328 81 DUP2 0329 52 MSTORE 032A 60 PUSH1 0x40 032C 80 DUP1 032D 83 DUP4 032E 20 SHA3 032F 93 SWAP4 0330 90 SWAP1 0331 94 SWAP5 0332 16 AND 0333 82 DUP3 0334 52 MSTORE 0335 91 SWAP2 0336 90 SWAP1 0337 91 SWAP2 0338 52 MSTORE 0339 20 SHA3 033A 54 SLOAD 033B 60 PUSH1 0xff 033D 16 AND 033E 90 SWAP1 033F 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0322 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0329 memory[0x20:0x40] = 0x01 // @0334 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0338 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @033E stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0340: // Incoming jump from 0x004B, if 0xee9a31a2 == stack[-1] // Inputs[1] { @0343 storage[0x05] } 0340 5B JUMPDEST 0341 60 PUSH1 0x05 0343 54 SLOAD 0344 61 PUSH2 0x02a3 0347 90 SWAP1 0348 60 PUSH1 0x01 034A 60 PUSH1 0x01 034C 60 PUSH1 0xa0 034E 1B SHL 034F 03 SUB 0350 16 AND 0351 81 DUP2 0352 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0347 stack[0] = 0x02a3 // @0350 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x05] // } // Block ends with unconditional jump to 0x02a3 label_0353: // Incoming jump from 0x0056, if 0xf242432a == stack[-1] // Inputs[1] { @035A msg.data.length } 0353 5B JUMPDEST 0354 61 PUSH2 0x0227 0357 61 PUSH2 0x0361 035A 36 CALLDATASIZE 035B 60 PUSH1 0x04 035D 61 PUSH2 0x1c65 0360 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0354 stack[0] = 0x0227 // @0357 stack[1] = 0x0361 // @035A stack[2] = msg.data.length // @035B stack[3] = 0x04 // } // Block ends with call to 0x1c65, returns to 0x0361 label_0361: // Incoming return from call to 0x1C65 at 0x0360 0361 5B JUMPDEST 0362 61 PUSH2 0x0dba 0365 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dba label_0366: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @036D msg.data.length } 0366 5B JUMPDEST 0367 61 PUSH2 0x0227 036A 61 PUSH2 0x0374 036D 36 CALLDATASIZE 036E 60 PUSH1 0x04 0370 61 PUSH2 0x1b6c 0373 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0367 stack[0] = 0x0227 // @036A stack[1] = 0x0374 // @036D stack[2] = msg.data.length // @036E stack[3] = 0x04 // } // Block ends with call to 0x1b6c, returns to 0x0374 label_0374: // Incoming return from call to 0x1B6C at 0x0373 0374 5B JUMPDEST 0375 61 PUSH2 0x0e55 0378 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e55 label_0379: // Incoming jump from 0x072C // Incoming jump from 0x01A3 // Inputs[1] { @0384 stack[-2] } 0379 5B JUMPDEST 037A 60 PUSH1 0x00 037C 60 PUSH1 0x01 037E 60 PUSH1 0x01 0380 60 PUSH1 0xa0 0382 1B SHL 0383 03 SUB 0384 83 DUP4 0385 16 AND 0386 61 PUSH2 0x03fc 0389 57 *JUMPI // Stack delta = +1 // Outputs[1] { @037A stack[0] = 0x00 } // Block ends with conditional jump to 0x03fc, if stack[-2] & (0x01 << 0xa0) - 0x01 label_038A: // Incoming jump from 0x0389, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @038C memory[0x40:0x60] } 038A 60 PUSH1 0x40 038C 51 MLOAD 038D 62 PUSH3 0x461bcd 0391 60 PUSH1 0xe5 0393 1B SHL 0394 81 DUP2 0395 52 MSTORE 0396 60 PUSH1 0x20 0398 60 PUSH1 0x04 039A 82 DUP3 039B 01 ADD 039C 52 MSTORE 039D 60 PUSH1 0x2b 039F 60 PUSH1 0x24 03A1 82 DUP3 03A2 01 ADD 03A3 52 MSTORE 03A4 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 03C5 60 PUSH1 0x44 03C7 82 DUP3 03C8 01 ADD 03C9 52 MSTORE 03CA 7F PUSH32 0x65726f2061646472657373000000000000000000000000000000000000000000 03EB 60 PUSH1 0x64 03ED 82 DUP3 03EE 01 ADD 03EF 52 MSTORE 03F0 60 PUSH1 0x84 03F2 01 ADD // Stack delta = +1 // Outputs[6] // { // @0395 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @039C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @03A3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @03C9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @03EF memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373000000000000000000000000000000000000000000 // @03F2 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_03F3: // Incoming jump from 0x1241 // Incoming jump from 0x0EAE // Incoming jump from 0x0672 // Incoming jump from 0x087E // Incoming jump from 0x097E // Incoming jump from 0x08DA // Incoming jump from 0x09E9 // Incoming jump from 0x0F2A // Incoming jump from 0x0E47 // Incoming jump from 0x150F // Incoming jump from 0x0B54 // Incoming jump from 0x0A8E // Incoming jump from 0x07CC // Incoming jump from 0x03F2 // Incoming jump from 0x0BAB // Incoming jump from 0x082A // Inputs[3] // { // @03F6 memory[0x40:0x60] // @03F8 stack[-1] // @03FB memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 03F3 5B JUMPDEST 03F4 60 PUSH1 0x40 03F6 51 MLOAD 03F7 80 DUP1 03F8 91 SWAP2 03F9 03 SUB 03FA 90 SWAP1 03FB FD *REVERT // Stack delta = -1 // Outputs[1] { @03FB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_03FC: // Incoming jump from 0x0389, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0400 stack[-2] // @040C memory[0x00:0x40] // @0415 stack[-3] // @041E memory[0x00:0x40] // @041F storage[keccak256(memory[0x00:0x40])] // @0420 stack[-4] // } 03FC 5B JUMPDEST 03FD 50 POP 03FE 60 PUSH1 0x00 0400 90 SWAP1 0401 81 DUP2 0402 52 MSTORE 0403 60 PUSH1 0x20 0405 81 DUP2 0406 81 DUP2 0407 52 MSTORE 0408 60 PUSH1 0x40 040A 80 DUP1 040B 83 DUP4 040C 20 SHA3 040D 60 PUSH1 0x01 040F 60 PUSH1 0x01 0411 60 PUSH1 0xa0 0413 1B SHL 0414 03 SUB 0415 94 SWAP5 0416 90 SWAP1 0417 94 SWAP5 0418 16 AND 0419 83 DUP4 041A 52 MSTORE 041B 92 SWAP3 041C 90 SWAP1 041D 52 MSTORE 041E 20 SHA3 041F 54 SLOAD 0420 90 SWAP1 0421 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0402 memory[0x00:0x20] = stack[-2] // @0407 memory[0x20:0x40] = 0x00 // @041A memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @041D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0420 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0422: // Incoming jump from 0x01C9 // Inputs[1] { @042E stack[-1] } 0422 5B JUMPDEST 0423 60 PUSH1 0x00 0425 60 PUSH1 0x01 0427 60 PUSH1 0x01 0429 60 PUSH1 0xe0 042B 1B SHL 042C 03 SUB 042D 19 NOT 042E 82 DUP3 042F 16 AND 0430 7F PUSH32 0xd9b67a2600000000000000000000000000000000000000000000000000000000 0451 14 EQ 0452 80 DUP1 0453 61 PUSH2 0x0485 0456 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0423 stack[0] = 0x00 // @0451 stack[1] = 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0485, if 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0457: // Incoming jump from 0x0456, if not 0xd9b67a2600000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0461 stack[-3] } 0457 50 POP 0458 60 PUSH1 0x01 045A 60 PUSH1 0x01 045C 60 PUSH1 0xe0 045E 1B SHL 045F 03 SUB 0460 19 NOT 0461 82 DUP3 0462 16 AND 0463 7F PUSH32 0x0e89341c00000000000000000000000000000000000000000000000000000000 0484 14 EQ 0485 5B JUMPDEST 0486 80 DUP1 0487 61 PUSH2 0x04b9 048A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0484 stack[-1] = 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x04b9, if 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_048B: // Incoming jump from 0x048A, if not stack[-1] // Incoming jump from 0x048A, if not 0x0e89341c00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[2] // { // @04B6 stack[-3] // @04BA stack[-4] // } 048B 50 POP 048C 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 04AD 60 PUSH1 0x01 04AF 60 PUSH1 0x01 04B1 60 PUSH1 0xe0 04B3 1B SHL 04B4 03 SUB 04B5 19 NOT 04B6 83 DUP4 04B7 16 AND 04B8 14 EQ 04B9 5B JUMPDEST 04BA 92 SWAP3 04BB 91 SWAP2 04BC 50 POP 04BD 50 POP 04BE 56 *JUMP // Stack delta = -3 // Outputs[1] { @04BA stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to stack[-4] label_04BF: // Incoming call from 0x01E1, returns to 0x01E2 // Inputs[1] { @04C3 storage[0x0a] } 04BF 5B JUMPDEST 04C0 60 PUSH1 0x0a 04C2 80 DUP1 04C3 54 SLOAD 04C4 61 PUSH2 0x04cc 04C7 90 SWAP1 04C8 61 PUSH2 0x213d 04CB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @04C0 stack[0] = 0x0a // @04C7 stack[1] = 0x04cc // @04C7 stack[2] = storage[0x0a] // } // Block ends with call to 0x213d, returns to 0x04CC label_04CC: // Incoming return from call to 0x213D at 0x0A0F // Incoming return from call to 0x213D at 0x04CB // Incoming return from call to 0x213D at 0x0A02 // Inputs[4] // { // @04CD stack[-1] // @04DC memory[0x40:0x60] // @04E4 stack[-2] // @04EF storage[stack[-2]] // } 04CC 5B JUMPDEST 04CD 80 DUP1 04CE 60 PUSH1 0x1f 04D0 01 ADD 04D1 60 PUSH1 0x20 04D3 80 DUP1 04D4 91 SWAP2 04D5 04 DIV 04D6 02 MUL 04D7 60 PUSH1 0x20 04D9 01 ADD 04DA 60 PUSH1 0x40 04DC 51 MLOAD 04DD 90 SWAP1 04DE 81 DUP2 04DF 01 ADD 04E0 60 PUSH1 0x40 04E2 52 MSTORE 04E3 80 DUP1 04E4 92 SWAP3 04E5 91 SWAP2 04E6 90 SWAP1 04E7 81 DUP2 04E8 81 DUP2 04E9 52 MSTORE 04EA 60 PUSH1 0x20 04EC 01 ADD 04ED 82 DUP3 04EE 80 DUP1 04EF 54 SLOAD 04F0 61 PUSH2 0x04f8 04F3 90 SWAP1 04F4 61 PUSH2 0x213d 04F7 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @04E2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @04E4 stack[-2] = memory[0x40:0x60] // @04E5 stack[-1] = stack[-2] // @04E6 stack[0] = stack[-1] // @04E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @04EC stack[1] = 0x20 + memory[0x40:0x60] // @04ED stack[2] = stack[-2] // @04F3 stack[4] = storage[stack[-2]] // @04F3 stack[3] = 0x04f8 // } // Block ends with call to 0x213d, returns to 0x04F8 label_04F8: // Incoming return from call to 0x213D at 0x04F7 // Inputs[1] { @04F9 stack[-1] } 04F8 5B JUMPDEST 04F9 80 DUP1 04FA 15 ISZERO 04FB 61 PUSH2 0x0545 04FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0545, if !stack[-1] label_04FF: // Incoming jump from 0x04FE, if not !stack[-1] // Inputs[1] { @04FF stack[-1] } 04FF 80 DUP1 0500 60 PUSH1 0x1f 0502 10 LT 0503 61 PUSH2 0x051a 0506 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x051a, if 0x1f < stack[-1] label_0507: // Incoming jump from 0x0506, if not 0x1f < stack[-1] // Inputs[4] // { // @050B stack[-2] // @050C storage[stack[-2]] // @050F stack[-3] // @0511 stack[-1] // } 0507 61 PUSH2 0x0100 050A 80 DUP1 050B 83 DUP4 050C 54 SLOAD 050D 04 DIV 050E 02 MUL 050F 83 DUP4 0510 52 MSTORE 0511 91 SWAP2 0512 60 PUSH1 0x20 0514 01 ADD 0515 91 SWAP2 0516 61 PUSH2 0x0545 0519 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0510 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0515 stack[-1] = stack[-1] // @0515 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0545 label_051A: // Incoming jump from 0x0506, if 0x1f < stack[-1] // Inputs[5] // { // @051B stack[-3] // @051C stack[-1] // @051E stack[-2] // @0526 memory[0x00:0x20] // @052A storage[keccak256(memory[0x00:0x20])] // } 051A 5B JUMPDEST 051B 82 DUP3 051C 01 ADD 051D 91 SWAP2 051E 90 SWAP1 051F 60 PUSH1 0x00 0521 52 MSTORE 0522 60 PUSH1 0x20 0524 60 PUSH1 0x00 0526 20 SHA3 0527 90 SWAP1 0528 5B JUMPDEST 0529 81 DUP2 052A 54 SLOAD 052B 81 DUP2 052C 52 MSTORE 052D 90 SWAP1 052E 60 PUSH1 0x01 0530 01 ADD 0531 90 SWAP1 0532 60 PUSH1 0x20 0534 01 ADD 0535 80 DUP1 0536 83 DUP4 0537 11 GT 0538 61 PUSH2 0x0528 053B 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @051D stack[-3] = stack[-3] + stack[-1] // @0521 memory[0x00:0x20] = stack[-2] // @052C memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0531 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0534 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0528, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_053C: // Incoming jump from 0x053B, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x053B, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @053C stack[-3] // @053D stack[-1] // } 053C 82 DUP3 053D 90 SWAP1 053E 03 SUB 053F 60 PUSH1 0x1f 0541 16 AND 0542 82 DUP3 0543 01 ADD 0544 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0544 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0544 stack[-1] = stack[-3] // } // Block continues label_0545: // Incoming jump from 0x0519 // Incoming jump from 0x04FE, if !stack[-1] // Incoming jump from 0x0544 // Inputs[1] { @054B stack[-7] } 0545 5B JUMPDEST 0546 50 POP 0547 50 POP 0548 50 POP 0549 50 POP 054A 50 POP 054B 81 DUP2 054C 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_054D: // Incoming jump from 0x0201 // Inputs[1] { @0553 stack[-1] } 054D 5B JUMPDEST 054E 60 PUSH1 0x60 0550 61 PUSH2 0x04b9 0553 82 DUP3 0554 61 PUSH2 0x0cc2 0557 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @054E stack[0] = 0x60 // @0550 stack[1] = 0x04b9 // @0553 stack[2] = stack[-1] // } // Block ends with call to 0x0cc2, returns to 0x04B9 0558 5B JUMPDEST 0559 60 PUSH1 0x01 055B 60 PUSH1 0x01 055D 60 PUSH1 0xa0 055F 1B SHL 0560 03 SUB 0561 85 DUP6 0562 16 AND 0563 33 CALLER 0564 14 EQ 0565 80 DUP1 0566 61 PUSH2 0x0574 0569 57 *JUMPI 056A 50 POP 056B 61 PUSH2 0x0574 056E 85 DUP6 056F 33 CALLER 0570 61 PUSH2 0x0312 0573 56 *JUMP 0574 5B JUMPDEST 0575 61 PUSH2 0x05e6 0578 57 *JUMPI 0579 60 PUSH1 0x40 057B 51 MLOAD 057C 62 PUSH3 0x461bcd 0580 60 PUSH1 0xe5 0582 1B SHL 0583 81 DUP2 0584 52 MSTORE 0585 60 PUSH1 0x20 0587 60 PUSH1 0x04 0589 82 DUP3 058A 01 ADD 058B 52 MSTORE 058C 60 PUSH1 0x32 058E 60 PUSH1 0x24 0590 82 DUP3 0591 01 ADD 0592 52 MSTORE 0593 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 05B4 60 PUSH1 0x44 05B6 82 DUP3 05B7 01 ADD 05B8 52 MSTORE 05B9 7F PUSH32 0x6f776e6572206e6f7220617070726f7665640000000000000000000000000000 05DA 60 PUSH1 0x64 05DC 82 DUP3 05DD 01 ADD 05DE 52 MSTORE 05DF 60 PUSH1 0x84 05E1 01 ADD 05E2 61 PUSH2 0x03f3 05E5 56 *JUMP 05E6 5B JUMPDEST 05E7 61 PUSH2 0x05f3 05EA 85 DUP6 05EB 85 DUP6 05EC 85 DUP6 05ED 85 DUP6 05EE 85 DUP6 05EF 61 PUSH2 0x0f37 05F2 56 *JUMP label_05F3: // Incoming return from call to 0x17FF at 0x125B // Incoming jump from 0x0BB7, if !(0x00 < stack[-3]) // Inputs[1] { @05F9 stack[-6] } 05F3 5B JUMPDEST 05F4 50 POP 05F5 50 POP 05F6 50 POP 05F7 50 POP 05F8 50 POP 05F9 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_05FA: // Incoming jump from 0x023B // Inputs[4] // { // @05FD stack[-1] // @05FE memory[stack[-1]:stack[-1] + 0x20] // @05FF stack[-2] // @0600 memory[stack[-2]:stack[-2] + 0x20] // } 05FA 5B JUMPDEST 05FB 60 PUSH1 0x60 05FD 81 DUP2 05FE 51 MLOAD 05FF 83 DUP4 0600 51 MLOAD 0601 14 EQ 0602 61 PUSH2 0x0673 0605 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05FB stack[0] = 0x60 } // Block ends with conditional jump to 0x0673, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] label_0606: // Incoming jump from 0x0605, if not memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @0608 memory[0x40:0x60] } 0606 60 PUSH1 0x40 0608 51 MLOAD 0609 62 PUSH3 0x461bcd 060D 60 PUSH1 0xe5 060F 1B SHL 0610 81 DUP2 0611 52 MSTORE 0612 60 PUSH1 0x20 0614 60 PUSH1 0x04 0616 82 DUP3 0617 01 ADD 0618 52 MSTORE 0619 60 PUSH1 0x29 061B 60 PUSH1 0x24 061D 82 DUP3 061E 01 ADD 061F 52 MSTORE 0620 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 0641 60 PUSH1 0x44 0643 82 DUP3 0644 01 ADD 0645 52 MSTORE 0646 7F PUSH32 0x206d69736d617463680000000000000000000000000000000000000000000000 0667 60 PUSH1 0x64 0669 82 DUP3 066A 01 ADD 066B 52 MSTORE 066C 60 PUSH1 0x84 066E 01 ADD 066F 61 PUSH2 0x03f3 0672 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0611 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0618 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @061F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0645 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 // @066B memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x206d69736d617463680000000000000000000000000000000000000000000000 // @066E stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_0673: // Incoming jump from 0x0605, if memory[stack[-2]:stack[-2] + 0x20] == memory[stack[-1]:stack[-1] + 0x20] // Inputs[2] // { // @0676 stack[-3] // @0677 memory[stack[-3]:stack[-3] + 0x20] // } 0673 5B JUMPDEST 0674 60 PUSH1 0x00 0676 83 DUP4 0677 51 MLOAD 0678 67 PUSH8 0xffffffffffffffff 0681 81 DUP2 0682 11 GT 0683 15 ISZERO 0684 61 PUSH2 0x069d 0687 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0674 stack[0] = 0x00 // @0677 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // } // Block ends with conditional jump to 0x069d, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_0688: // Incoming jump from 0x0687, if not !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @069C memory[0x00:0x24] } 0688 63 PUSH4 0x4e487b71 068D 60 PUSH1 0xe0 068F 1B SHL 0690 60 PUSH1 0x00 0692 52 MSTORE 0693 60 PUSH1 0x41 0695 60 PUSH1 0x04 0697 52 MSTORE 0698 60 PUSH1 0x24 069A 60 PUSH1 0x00 069C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0692 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0697 memory[0x04:0x24] = 0x41 // @069C revert(memory[0x00:0x24]); // } // Block terminates label_069D: // Incoming jump from 0x0687, if !(memory[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @06A0 memory[0x40:0x60] // @06A1 stack[-1] // } 069D 5B JUMPDEST 069E 60 PUSH1 0x40 06A0 51 MLOAD 06A1 90 SWAP1 06A2 80 DUP1 06A3 82 DUP3 06A4 52 MSTORE 06A5 80 DUP1 06A6 60 PUSH1 0x20 06A8 02 MUL 06A9 60 PUSH1 0x20 06AB 01 ADD 06AC 82 DUP3 06AD 01 ADD 06AE 60 PUSH1 0x40 06B0 52 MSTORE 06B1 80 DUP1 06B2 15 ISZERO 06B3 61 PUSH2 0x06c6 06B6 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @06A1 stack[-1] = memory[0x40:0x60] // @06A1 stack[0] = stack[-1] // @06A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06B0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x06c6, if !stack[-1] label_06B7: // Incoming jump from 0x06B6, if not !stack[-1] // Inputs[7] // { // @06B7 stack[-2] // @06BD stack[-1] // @06C0 msg.data.length // @06C2 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @06C8 stack[-3] // @06CD stack[-6] // @06CE memory[stack[-6]:stack[-6] + 0x20] // } 06B7 81 DUP2 06B8 60 PUSH1 0x20 06BA 01 ADD 06BB 60 PUSH1 0x20 06BD 82 DUP3 06BE 02 MUL 06BF 80 DUP1 06C0 36 CALLDATASIZE 06C1 83 DUP4 06C2 37 CALLDATACOPY 06C3 01 ADD 06C4 90 SWAP1 06C5 50 POP 06C6 5B JUMPDEST 06C7 50 POP 06C8 90 SWAP1 06C9 50 POP 06CA 60 PUSH1 0x00 06CC 5B JUMPDEST 06CD 84 DUP5 06CE 51 MLOAD 06CF 81 DUP2 06D0 10 LT 06D1 15 ISZERO 06D2 61 PUSH2 0x0768 06D5 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @06C2 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @06C8 stack[-3] = stack[-2] // @06CA stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0768, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_06D6: // Incoming jump from 0x06D5, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x06D5, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x06D5, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @06D9 stack[-5] // @06DA stack[-1] // @06DC memory[stack[-5]:stack[-5] + 0x20] // } 06D6 61 PUSH2 0x072d 06D9 85 DUP6 06DA 82 DUP3 06DB 81 DUP2 06DC 51 MLOAD 06DD 81 DUP2 06DE 10 LT 06DF 61 PUSH2 0x06f8 06E2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06D6 stack[0] = 0x072d // @06D9 stack[1] = stack[-5] // @06DA stack[2] = stack[-1] // } // Block ends with conditional call to 0x06f8, returns to 0x072D, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_06E3: // Incoming jump from 0x06E2, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[1] { @06F7 memory[0x00:0x24] } 06E3 63 PUSH4 0x4e487b71 06E8 60 PUSH1 0xe0 06EA 1B SHL 06EB 60 PUSH1 0x00 06ED 52 MSTORE 06EE 60 PUSH1 0x32 06F0 60 PUSH1 0x04 06F2 52 MSTORE 06F3 60 PUSH1 0x24 06F5 60 PUSH1 0x00 06F7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @06ED memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @06F2 memory[0x04:0x24] = 0x32 // @06F7 revert(memory[0x00:0x24]); // } // Block terminates label_06F8: // Incoming call from 0x06E2, returns to 0x072D, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[6] // { // @06FB stack[-1] // @06FF stack[-2] // @0700 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0701 stack[-7] // @0702 stack[-4] // @0704 memory[stack[-7]:stack[-7] + 0x20] // } 06F8 5B JUMPDEST 06F9 60 PUSH1 0x20 06FB 02 MUL 06FC 60 PUSH1 0x20 06FE 01 ADD 06FF 01 ADD 0700 51 MLOAD 0701 85 DUP6 0702 83 DUP4 0703 81 DUP2 0704 51 MLOAD 0705 81 DUP2 0706 10 LT 0707 61 PUSH2 0x0720 070A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0700 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0701 stack[-1] = stack[-7] // @0702 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x0720, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] label_070B: // Incoming jump from 0x070A, if not stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[1] { @071F memory[0x00:0x24] } 070B 63 PUSH4 0x4e487b71 0710 60 PUSH1 0xe0 0712 1B SHL 0713 60 PUSH1 0x00 0715 52 MSTORE 0716 60 PUSH1 0x32 0718 60 PUSH1 0x04 071A 52 MSTORE 071B 60 PUSH1 0x24 071D 60 PUSH1 0x00 071F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0715 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @071A memory[0x04:0x24] = 0x32 // @071F revert(memory[0x00:0x24]); // } // Block terminates label_0720: // Incoming jump from 0x070A, if stack[-4] < memory[stack[-7]:stack[-7] + 0x20] // Inputs[3] // { // @0723 stack[-1] // @0727 stack[-2] // @0728 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0720 5B JUMPDEST 0721 60 PUSH1 0x20 0723 02 MUL 0724 60 PUSH1 0x20 0726 01 ADD 0727 01 ADD 0728 51 MLOAD 0729 61 PUSH2 0x0379 072C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0728 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0379 label_072D: // Incoming return from call to 0x06F8 at 0x06E2 // Inputs[3] // { // @072E stack[-3] // @072F stack[-2] // @0731 memory[stack[-3]:stack[-3] + 0x20] // } 072D 5B JUMPDEST 072E 82 DUP3 072F 82 DUP3 0730 81 DUP2 0731 51 MLOAD 0732 81 DUP2 0733 10 LT 0734 61 PUSH2 0x074d 0737 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @072E stack[0] = stack[-3] // @072F stack[1] = stack[-2] // } // Block ends with conditional jump to 0x074d, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_0738: // Incoming jump from 0x0737, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[1] { @074C memory[0x00:0x24] } 0738 63 PUSH4 0x4e487b71 073D 60 PUSH1 0xe0 073F 1B SHL 0740 60 PUSH1 0x00 0742 52 MSTORE 0743 60 PUSH1 0x32 0745 60 PUSH1 0x04 0747 52 MSTORE 0748 60 PUSH1 0x24 074A 60 PUSH1 0x00 074C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0742 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0747 memory[0x04:0x24] = 0x32 // @074C revert(memory[0x00:0x24]); // } // Block terminates label_074D: // Incoming jump from 0x0737, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0750 stack[-1] // @0753 stack[-2] // @0758 stack[-3] // @075C stack[-4] // } 074D 5B JUMPDEST 074E 60 PUSH1 0x20 0750 90 SWAP1 0751 81 DUP2 0752 02 MUL 0753 91 SWAP2 0754 90 SWAP1 0755 91 SWAP2 0756 01 ADD 0757 01 ADD 0758 52 MSTORE 0759 61 PUSH2 0x0761 075C 81 DUP2 075D 61 PUSH2 0x21a5 0760 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0758 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0759 stack[-3] = 0x0761 // @075C stack[-2] = stack[-4] // } // Block ends with call to 0x21a5, returns to 0x0761 label_0761: // Incoming return from call to 0x21A5 at 0x0760 // Inputs[2] // { // @0762 stack[-2] // @0762 stack[-1] // } 0761 5B JUMPDEST 0762 90 SWAP1 0763 50 POP 0764 61 PUSH2 0x06cc 0767 56 *JUMP // Stack delta = -1 // Outputs[1] { @0762 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x06cc label_0768: // Incoming jump from 0x06D5, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x06D5, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x06D5, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[3] // { // @076A stack[-2] // @076A stack[-6] // @076B stack[-5] // } 0768 5B JUMPDEST 0769 50 POP 076A 93 SWAP4 076B 92 SWAP3 076C 50 POP 076D 50 POP 076E 50 POP 076F 56 *JUMP // Stack delta = -5 // Outputs[1] { @076A stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0770: // Incoming jump from 0x025B // Inputs[2] // { // @0773 storage[0x05] // @0780 msg.sender // } 0770 5B JUMPDEST 0771 60 PUSH1 0x05 0773 54 SLOAD 0774 60 PUSH1 0x00 0776 90 SWAP1 0777 60 PUSH1 0x01 0779 60 PUSH1 0x01 077B 60 PUSH1 0xa0 077D 1B SHL 077E 03 SUB 077F 16 AND 0780 33 CALLER 0781 14 EQ 0782 61 PUSH2 0x07cd 0785 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0776 stack[0] = 0x00 } // Block ends with conditional jump to 0x07cd, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] label_0786: // Incoming jump from 0x0785, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[1] { @0788 memory[0x40:0x60] } 0786 60 PUSH1 0x40 0788 51 MLOAD 0789 62 PUSH3 0x461bcd 078D 60 PUSH1 0xe5 078F 1B SHL 0790 81 DUP2 0791 52 MSTORE 0792 60 PUSH1 0x20 0794 60 PUSH1 0x04 0796 82 DUP3 0797 01 ADD 0798 52 MSTORE 0799 60 PUSH1 0x0a 079B 60 PUSH1 0x24 079D 82 DUP3 079E 01 ADD 079F 52 MSTORE 07A0 7F PUSH32 0x4e6f742042726964676500000000000000000000000000000000000000000000 07C1 60 PUSH1 0x44 07C3 82 DUP3 07C4 01 ADD 07C5 52 MSTORE 07C6 60 PUSH1 0x64 07C8 01 ADD 07C9 61 PUSH2 0x03f3 07CC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0791 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0798 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @079F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x0a // @07C5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f742042726964676500000000000000000000000000000000000000000000 // @07C8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_07CD: // Incoming jump from 0x0785, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[1] { @07D0 stack[-2] } 07CD 5B JUMPDEST 07CE 60 PUSH1 0x00 07D0 82 DUP3 07D1 11 GT 07D2 80 DUP1 07D3 15 ISZERO 07D4 61 PUSH2 0x07df 07D7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07D1 stack[0] = stack[-2] > 0x00 } // Block ends with conditional jump to 0x07df, if !(stack[-2] > 0x00) label_07D8: // Incoming jump from 0x07D7, if not !(stack[-2] > 0x00) // Inputs[1] { @07DC stack[-3] } 07D8 50 POP 07D9 61 PUSH2 0x01f4 07DC 82 DUP3 07DD 11 GT 07DE 15 ISZERO 07DF 5B JUMPDEST 07E0 61 PUSH2 0x082b 07E3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x082b, if !(stack[-3] > 0x01f4) label_07E4: // Incoming jump from 0x07E3, if not stack[-1] // Incoming jump from 0x07E3, if not !(stack[-3] > 0x01f4) // Inputs[1] { @07E6 memory[0x40:0x60] } 07E4 60 PUSH1 0x40 07E6 51 MLOAD 07E7 62 PUSH3 0x461bcd 07EB 60 PUSH1 0xe5 07ED 1B SHL 07EE 81 DUP2 07EF 52 MSTORE 07F0 60 PUSH1 0x20 07F2 60 PUSH1 0x04 07F4 82 DUP3 07F5 01 ADD 07F6 52 MSTORE 07F7 60 PUSH1 0x12 07F9 60 PUSH1 0x24 07FB 82 DUP3 07FC 01 ADD 07FD 52 MSTORE 07FE 7F PUSH32 0x546f6b656e206f7574206f6620626f756e640000000000000000000000000000 081F 60 PUSH1 0x44 0821 82 DUP3 0822 01 ADD 0823 52 MSTORE 0824 60 PUSH1 0x64 0826 01 ADD 0827 61 PUSH2 0x03f3 082A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @07EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07F6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07FD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0823 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x546f6b656e206f7574206f6620626f756e640000000000000000000000000000 // @0826 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_082B: // Incoming jump from 0x07E3, if stack[-1] // Incoming jump from 0x07E3, if !(stack[-3] > 0x01f4) // Inputs[1] { @0831 storage[0x09] } 082B 5B JUMPDEST 082C 61 PUSH2 0x01f4 082F 60 PUSH1 0x09 0831 54 SLOAD 0832 11 GT 0833 15 ISZERO 0834 61 PUSH2 0x087f 0837 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x087f, if !(storage[0x09] > 0x01f4) label_0838: // Incoming jump from 0x0837, if not !(storage[0x09] > 0x01f4) // Inputs[1] { @083A memory[0x40:0x60] } 0838 60 PUSH1 0x40 083A 51 MLOAD 083B 62 PUSH3 0x461bcd 083F 60 PUSH1 0xe5 0841 1B SHL 0842 81 DUP2 0843 52 MSTORE 0844 60 PUSH1 0x20 0846 60 PUSH1 0x04 0848 82 DUP3 0849 01 ADD 084A 52 MSTORE 084B 60 PUSH1 0x12 084D 60 PUSH1 0x24 084F 82 DUP3 0850 01 ADD 0851 52 MSTORE 0852 7F PUSH32 0x4d617820737570706c7920726561636865640000000000000000000000000000 0873 60 PUSH1 0x44 0875 82 DUP3 0876 01 ADD 0877 52 MSTORE 0878 60 PUSH1 0x64 087A 01 ADD 087B 61 PUSH2 0x03f3 087E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0843 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @084A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0851 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0877 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d617820737570706c7920726561636865640000000000000000000000000000 // @087A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_087F: // Incoming jump from 0x0837, if !(storage[0x09] > 0x01f4) // Inputs[3] // { // @0882 stack[-2] // @088D memory[0x00:0x40] // @088E storage[keccak256(memory[0x00:0x40])] // } 087F 5B JUMPDEST 0880 60 PUSH1 0x00 0882 82 DUP3 0883 81 DUP2 0884 52 MSTORE 0885 60 PUSH1 0x07 0887 60 PUSH1 0x20 0889 52 MSTORE 088A 60 PUSH1 0x40 088C 90 SWAP1 088D 20 SHA3 088E 54 SLOAD 088F 15 ISZERO 0890 61 PUSH2 0x08db 0893 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0884 memory[0x00:0x20] = stack[-2] // @0889 memory[0x20:0x40] = 0x07 // } // Block ends with conditional jump to 0x08db, if !storage[keccak256(memory[0x00:0x40])] label_0894: // Incoming jump from 0x0893, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0896 memory[0x40:0x60] } 0894 60 PUSH1 0x40 0896 51 MLOAD 0897 62 PUSH3 0x461bcd 089B 60 PUSH1 0xe5 089D 1B SHL 089E 81 DUP2 089F 52 MSTORE 08A0 60 PUSH1 0x20 08A2 60 PUSH1 0x04 08A4 82 DUP3 08A5 01 ADD 08A6 52 MSTORE 08A7 60 PUSH1 0x06 08A9 60 PUSH1 0x24 08AB 82 DUP3 08AC 01 ADD 08AD 52 MSTORE 08AE 7F PUSH32 0x4578697374730000000000000000000000000000000000000000000000000000 08CF 60 PUSH1 0x44 08D1 82 DUP3 08D2 01 ADD 08D3 52 MSTORE 08D4 60 PUSH1 0x64 08D6 01 ADD 08D7 61 PUSH2 0x03f3 08DA 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @089F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08A6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08AD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x06 // @08D3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4578697374730000000000000000000000000000000000000000000000000000 // @08D6 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_08DB: // Incoming jump from 0x0893, if !storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @08DE stack[-2] // @08E9 memory[0x00:0x40] // @08F1 storage[0x09] // } 08DB 5B JUMPDEST 08DC 60 PUSH1 0x00 08DE 82 DUP3 08DF 81 DUP2 08E0 52 MSTORE 08E1 60 PUSH1 0x07 08E3 60 PUSH1 0x20 08E5 52 MSTORE 08E6 60 PUSH1 0x40 08E8 81 DUP2 08E9 20 SHA3 08EA 60 PUSH1 0x01 08EC 90 SWAP1 08ED 55 SSTORE 08EE 60 PUSH1 0x09 08F0 80 DUP1 08F1 54 SLOAD 08F2 91 SWAP2 08F3 61 PUSH2 0x08fb 08F6 83 DUP4 08F7 61 PUSH2 0x21a5 08FA 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @08E0 memory[0x00:0x20] = stack[-2] // @08E5 memory[0x20:0x40] = 0x07 // @08ED storage[keccak256(memory[0x00:0x40])] = 0x01 // @08EE stack[1] = 0x09 // @08F2 stack[2] = 0x00 // @08F2 stack[0] = storage[0x09] // @08F3 stack[3] = 0x08fb // @08F6 stack[4] = storage[0x09] // } // Block ends with call to 0x21a5, returns to 0x08FB label_08FB: // Incoming return from call to 0x21A5 at 0x08FA // Inputs[6] // { // @08FC stack[-1] // @08FC stack[-3] // @08FD stack[-2] // @0904 stack[-7] // @0905 stack[-6] // @090A memory[0x40:0x60] // } 08FB 5B JUMPDEST 08FC 91 SWAP2 08FD 90 SWAP1 08FE 50 POP 08FF 55 SSTORE 0900 50 POP 0901 61 PUSH2 0x091c 0904 83 DUP4 0905 83 DUP4 0906 60 PUSH1 0x01 0908 60 PUSH1 0x40 090A 51 MLOAD 090B 80 DUP1 090C 60 PUSH1 0x20 090E 01 ADD 090F 60 PUSH1 0x40 0911 52 MSTORE 0912 80 DUP1 0913 60 PUSH1 0x00 0915 81 DUP2 0916 52 MSTORE 0917 50 POP 0918 61 PUSH2 0x11c6 091B 56 *JUMP // Stack delta = +1 // Outputs[8] // { // @08FF storage[stack[-3]] = stack[-1] // @0901 stack[-4] = 0x091c // @0904 stack[-3] = stack[-7] // @0905 stack[-2] = stack[-6] // @0906 stack[-1] = 0x01 // @090A stack[0] = memory[0x40:0x60] // @0911 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0916 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x11c6 091C 5B JUMPDEST 091D 50 POP 091E 60 PUSH1 0x01 0920 92 SWAP3 0921 91 SWAP2 0922 50 POP 0923 50 POP 0924 56 *JUMP label_0925: // Incoming jump from 0x026E // Inputs[2] // { // @0928 storage[0x03] // @0932 msg.sender // } 0925 5B JUMPDEST 0926 60 PUSH1 0x03 0928 54 SLOAD 0929 60 PUSH1 0x01 092B 60 PUSH1 0x01 092D 60 PUSH1 0xa0 092F 1B SHL 0930 03 SUB 0931 16 AND 0932 33 CALLER 0933 14 EQ 0934 61 PUSH2 0x097f 0937 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x097f, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0938: // Incoming jump from 0x0937, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @093A memory[0x40:0x60] } 0938 60 PUSH1 0x40 093A 51 MLOAD 093B 62 PUSH3 0x461bcd 093F 60 PUSH1 0xe5 0941 1B SHL 0942 81 DUP2 0943 52 MSTORE 0944 60 PUSH1 0x20 0946 60 PUSH1 0x04 0948 82 DUP3 0949 01 ADD 094A 81 DUP2 094B 90 SWAP1 094C 52 MSTORE 094D 60 PUSH1 0x24 094F 82 DUP3 0950 01 ADD 0951 52 MSTORE 0952 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0973 60 PUSH1 0x44 0975 82 DUP3 0976 01 ADD 0977 52 MSTORE 0978 60 PUSH1 0x64 097A 01 ADD 097B 61 PUSH2 0x03f3 097E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0943 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @094C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0951 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0977 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @097A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_097F: // Incoming jump from 0x0937, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[2] // { // @0985 stack[-2] // @0986 stack[-1] // } 097F 5B JUMPDEST 0980 61 PUSH2 0x098b 0983 60 PUSH1 0x06 0985 83 DUP4 0986 83 DUP4 0987 61 PUSH2 0x1963 098A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0980 stack[0] = 0x098b // @0983 stack[1] = 0x06 // @0985 stack[2] = stack[-2] // @0986 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1963 098B 5B JUMPDEST 098C 50 POP 098D 50 POP 098E 50 POP 098F 56 *JUMP label_0990: // Incoming call from 0x0276, returns to 0x0227 // Inputs[2] // { // @0993 storage[0x03] // @099D msg.sender // } 0990 5B JUMPDEST 0991 60 PUSH1 0x03 0993 54 SLOAD 0994 60 PUSH1 0x01 0996 60 PUSH1 0x01 0998 60 PUSH1 0xa0 099A 1B SHL 099B 03 SUB 099C 16 AND 099D 33 CALLER 099E 14 EQ 099F 61 PUSH2 0x09ea 09A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09ea, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_09A3: // Incoming jump from 0x09A2, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @09A5 memory[0x40:0x60] } 09A3 60 PUSH1 0x40 09A5 51 MLOAD 09A6 62 PUSH3 0x461bcd 09AA 60 PUSH1 0xe5 09AC 1B SHL 09AD 81 DUP2 09AE 52 MSTORE 09AF 60 PUSH1 0x20 09B1 60 PUSH1 0x04 09B3 82 DUP3 09B4 01 ADD 09B5 81 DUP2 09B6 90 SWAP1 09B7 52 MSTORE 09B8 60 PUSH1 0x24 09BA 82 DUP3 09BB 01 ADD 09BC 52 MSTORE 09BD 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 09DE 60 PUSH1 0x44 09E0 82 DUP3 09E1 01 ADD 09E2 52 MSTORE 09E3 60 PUSH1 0x64 09E5 01 ADD 09E6 61 PUSH2 0x03f3 09E9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @09AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09B7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09BC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @09E2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @09E5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_09EA: // Incoming jump from 0x09A2, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] 09EA 5B JUMPDEST 09EB 61 PUSH2 0x09f4 09EE 60 PUSH1 0x00 09F0 61 PUSH2 0x12ec 09F3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @09EB stack[0] = 0x09f4 // @09EE stack[1] = 0x00 // } // Block ends with call to 0x12ec, returns to 0x09F4 label_09F4: // Incoming return from call to 0x12EC at 0x09F3 // Inputs[1] { @09F5 stack[-1] } 09F4 5B JUMPDEST 09F5 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_09F6: // Incoming call from 0x02C2, returns to 0x01E2 // Inputs[1] { @09FA storage[0x0b] } 09F6 5B JUMPDEST 09F7 60 PUSH1 0x0b 09F9 80 DUP1 09FA 54 SLOAD 09FB 61 PUSH2 0x04cc 09FE 90 SWAP1 09FF 61 PUSH2 0x213d 0A02 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @09F7 stack[0] = 0x0b // @09FE stack[1] = 0x04cc // @09FE stack[2] = storage[0x0b] // } // Block ends with call to 0x213d, returns to 0x04CC label_0A03: // Incoming call from 0x02CA, returns to 0x01E2 // Inputs[1] { @0A07 storage[0x06] } 0A03 5B JUMPDEST 0A04 60 PUSH1 0x06 0A06 80 DUP1 0A07 54 SLOAD 0A08 61 PUSH2 0x04cc 0A0B 90 SWAP1 0A0C 61 PUSH2 0x213d 0A0F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A04 stack[0] = 0x06 // @0A0B stack[1] = 0x04cc // @0A0B stack[2] = storage[0x06] // } // Block ends with call to 0x213d, returns to 0x04CC label_0A10: // Incoming jump from 0x02DD // Inputs[2] // { // @0A11 msg.sender // @0A1A stack[-2] // } 0A10 5B JUMPDEST 0A11 33 CALLER 0A12 60 PUSH1 0x01 0A14 60 PUSH1 0x01 0A16 60 PUSH1 0xa0 0A18 1B SHL 0A19 03 SUB 0A1A 83 DUP4 0A1B 16 AND 0A1C 14 EQ 0A1D 15 ISZERO 0A1E 61 PUSH2 0x0a8f 0A21 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a8f, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) label_0A22: // Incoming jump from 0x0A21, if not !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[1] { @0A24 memory[0x40:0x60] } 0A22 60 PUSH1 0x40 0A24 51 MLOAD 0A25 62 PUSH3 0x461bcd 0A29 60 PUSH1 0xe5 0A2B 1B SHL 0A2C 81 DUP2 0A2D 52 MSTORE 0A2E 60 PUSH1 0x20 0A30 60 PUSH1 0x04 0A32 82 DUP3 0A33 01 ADD 0A34 52 MSTORE 0A35 60 PUSH1 0x29 0A37 60 PUSH1 0x24 0A39 82 DUP3 0A3A 01 ADD 0A3B 52 MSTORE 0A3C 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 0A5D 60 PUSH1 0x44 0A5F 82 DUP3 0A60 01 ADD 0A61 52 MSTORE 0A62 7F PUSH32 0x20666f722073656c660000000000000000000000000000000000000000000000 0A83 60 PUSH1 0x64 0A85 82 DUP3 0A86 01 ADD 0A87 52 MSTORE 0A88 60 PUSH1 0x84 0A8A 01 ADD 0A8B 61 PUSH2 0x03f3 0A8E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0A2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A34 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A3B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0A61 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @0A87 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x20666f722073656c660000000000000000000000000000000000000000000000 // @0A8A stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_0A8F: // Incoming jump from 0x0A21, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[10] // { // @0A90 msg.sender // @0AA1 memory[0x00:0x40] // @0AAA stack[-2] // @0AB5 memory[0x00:0x40] // @0AB7 storage[keccak256(memory[0x00:0x40])] // @0ABC stack[-1] // @0AC6 memory[0x40:0x60] // @0AF2 memory[0x40:0x60] // @0AF7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0AFA stack[-3] // } 0A8F 5B JUMPDEST 0A90 33 CALLER 0A91 60 PUSH1 0x00 0A93 81 DUP2 0A94 81 DUP2 0A95 52 MSTORE 0A96 60 PUSH1 0x01 0A98 60 PUSH1 0x20 0A9A 90 SWAP1 0A9B 81 DUP2 0A9C 52 MSTORE 0A9D 60 PUSH1 0x40 0A9F 80 DUP1 0AA0 83 DUP4 0AA1 20 SHA3 0AA2 60 PUSH1 0x01 0AA4 60 PUSH1 0x01 0AA6 60 PUSH1 0xa0 0AA8 1B SHL 0AA9 03 SUB 0AAA 87 DUP8 0AAB 16 AND 0AAC 80 DUP1 0AAD 85 DUP6 0AAE 52 MSTORE 0AAF 90 SWAP1 0AB0 83 DUP4 0AB1 52 MSTORE 0AB2 92 SWAP3 0AB3 81 DUP2 0AB4 90 SWAP1 0AB5 20 SHA3 0AB6 80 DUP1 0AB7 54 SLOAD 0AB8 60 PUSH1 0xff 0ABA 19 NOT 0ABB 16 AND 0ABC 86 DUP7 0ABD 15 ISZERO 0ABE 15 ISZERO 0ABF 90 SWAP1 0AC0 81 DUP2 0AC1 17 OR 0AC2 90 SWAP1 0AC3 91 SWAP2 0AC4 55 SSTORE 0AC5 90 SWAP1 0AC6 51 MLOAD 0AC7 90 SWAP1 0AC8 81 DUP2 0AC9 52 MSTORE 0ACA 91 SWAP2 0ACB 92 SWAP3 0ACC 91 SWAP2 0ACD 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0AEE 91 SWAP2 0AEF 01 ADD 0AF0 60 PUSH1 0x40 0AF2 51 MLOAD 0AF3 80 DUP1 0AF4 91 SWAP2 0AF5 03 SUB 0AF6 90 SWAP1 0AF7 A3 LOG3 0AF8 50 POP 0AF9 50 POP 0AFA 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0A95 memory[0x00:0x20] = msg.sender // @0A9C memory[0x20:0x40] = 0x01 // @0AAE memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0AB1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0AC4 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0AC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0AF7 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_0AFB: // Incoming jump from 0x02F0 // Inputs[2] // { // @0AFE storage[0x03] // @0B08 msg.sender // } 0AFB 5B JUMPDEST 0AFC 60 PUSH1 0x03 0AFE 54 SLOAD 0AFF 60 PUSH1 0x01 0B01 60 PUSH1 0x01 0B03 60 PUSH1 0xa0 0B05 1B SHL 0B06 03 SUB 0B07 16 AND 0B08 33 CALLER 0B09 14 EQ 0B0A 61 PUSH2 0x0b55 0B0D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b55, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0B0E: // Incoming jump from 0x0B0D, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0B10 memory[0x40:0x60] } 0B0E 60 PUSH1 0x40 0B10 51 MLOAD 0B11 62 PUSH3 0x461bcd 0B15 60 PUSH1 0xe5 0B17 1B SHL 0B18 81 DUP2 0B19 52 MSTORE 0B1A 60 PUSH1 0x20 0B1C 60 PUSH1 0x04 0B1E 82 DUP3 0B1F 01 ADD 0B20 81 DUP2 0B21 90 SWAP1 0B22 52 MSTORE 0B23 60 PUSH1 0x24 0B25 82 DUP3 0B26 01 ADD 0B27 52 MSTORE 0B28 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0B49 60 PUSH1 0x44 0B4B 82 DUP3 0B4C 01 ADD 0B4D 52 MSTORE 0B4E 60 PUSH1 0x64 0B50 01 ADD 0B51 61 PUSH2 0x03f3 0B54 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B19 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B22 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B27 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0B4D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0B50 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_0B55: // Incoming jump from 0x0B0D, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0B58 storage[0x08] } 0B55 5B JUMPDEST 0B56 60 PUSH1 0x08 0B58 54 SLOAD 0B59 60 PUSH1 0x02 0B5B 60 PUSH1 0xff 0B5D 90 SWAP1 0B5E 91 SWAP2 0B5F 16 AND 0B60 10 LT 0B61 61 PUSH2 0x0bac 0B64 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bac, if storage[0x08] & 0xff < 0x02 label_0B65: // Incoming jump from 0x0B64, if not storage[0x08] & 0xff < 0x02 // Inputs[1] { @0B67 memory[0x40:0x60] } 0B65 60 PUSH1 0x40 0B67 51 MLOAD 0B68 62 PUSH3 0x461bcd 0B6C 60 PUSH1 0xe5 0B6E 1B SHL 0B6F 81 DUP2 0B70 52 MSTORE 0B71 60 PUSH1 0x20 0B73 60 PUSH1 0x04 0B75 82 DUP3 0B76 01 ADD 0B77 52 MSTORE 0B78 60 PUSH1 0x06 0B7A 60 PUSH1 0x24 0B7C 82 DUP3 0B7D 01 ADD 0B7E 52 MSTORE 0B7F 7F PUSH32 0x4c6f636b65640000000000000000000000000000000000000000000000000000 0BA0 60 PUSH1 0x44 0BA2 82 DUP3 0BA3 01 ADD 0BA4 52 MSTORE 0BA5 60 PUSH1 0x64 0BA7 01 ADD 0BA8 61 PUSH2 0x03f3 0BAB 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B77 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B7E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x06 // @0BA4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4c6f636b65640000000000000000000000000000000000000000000000000000 // @0BA7 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_0BAC: // Incoming jump from 0x0B64, if storage[0x08] & 0xff < 0x02 // Inputs[1] { @0BB0 stack[-3] } 0BAC 5B JUMPDEST 0BAD 60 PUSH1 0x00 0BAF 5B JUMPDEST 0BB0 83 DUP4 0BB1 81 DUP2 0BB2 10 LT 0BB3 15 ISZERO 0BB4 61 PUSH2 0x05f3 0BB7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BAD stack[0] = 0x00 } // Block ends with conditional jump to 0x05f3, if !(0x00 < stack[-3]) label_0BB8: // Incoming jump from 0x0BB7, if not !(0x00 < stack[-3]) // Inputs[3] // { // @0BBE stack[-3] // @0BBF stack[-2] // @0BC0 stack[-1] // } 0BB8 60 PUSH1 0x01 0BBA 60 PUSH1 0x07 0BBC 60 PUSH1 0x00 0BBE 85 DUP6 0BBF 85 DUP6 0BC0 85 DUP6 0BC1 81 DUP2 0BC2 81 DUP2 0BC3 10 LT 0BC4 61 PUSH2 0x0bdd 0BC7 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0BB8 stack[0] = 0x01 // @0BBA stack[1] = 0x07 // @0BBC stack[2] = 0x00 // @0BBE stack[3] = stack[-3] // @0BBF stack[4] = stack[-2] // @0BC0 stack[5] = stack[-1] // } // Block ends with conditional jump to 0x0bdd, if stack[-1] < stack[-2] label_0BC8: // Incoming jump from 0x0BC7, if not stack[-1] < stack[-2] // Inputs[1] { @0BDC memory[0x00:0x24] } 0BC8 63 PUSH4 0x4e487b71 0BCD 60 PUSH1 0xe0 0BCF 1B SHL 0BD0 60 PUSH1 0x00 0BD2 52 MSTORE 0BD3 60 PUSH1 0x32 0BD5 60 PUSH1 0x04 0BD7 52 MSTORE 0BD8 60 PUSH1 0x24 0BDA 60 PUSH1 0x00 0BDC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0BD2 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0BD7 memory[0x04:0x24] = 0x32 // @0BDC revert(memory[0x00:0x24]); // } // Block terminates label_0BDD: // Incoming jump from 0x0BC7, if stack[-1] < stack[-2] // Inputs[9] // { // @0BDE stack[-2] // @0BDE stack[-1] // @0BE3 stack[-3] // @0BE4 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0BE5 stack[-4] // @0BEA stack[-5] // @0BF2 memory[0x00:0x00 + 0x20 + 0x20 + stack[-4]] // @0BF3 stack[-6] // @0BFC storage[0x09] // } 0BDD 5B JUMPDEST 0BDE 90 SWAP1 0BDF 50 POP 0BE0 60 PUSH1 0x20 0BE2 02 MUL 0BE3 01 ADD 0BE4 35 CALLDATALOAD 0BE5 81 DUP2 0BE6 52 MSTORE 0BE7 60 PUSH1 0x20 0BE9 01 ADD 0BEA 90 SWAP1 0BEB 81 DUP2 0BEC 52 MSTORE 0BED 60 PUSH1 0x20 0BEF 01 ADD 0BF0 60 PUSH1 0x00 0BF2 20 SHA3 0BF3 81 DUP2 0BF4 90 SWAP1 0BF5 55 SSTORE 0BF6 50 POP 0BF7 60 PUSH1 0x09 0BF9 60 PUSH1 0x00 0BFB 81 DUP2 0BFC 54 SLOAD 0BFD 80 DUP1 0BFE 92 SWAP3 0BFF 91 SWAP2 0C00 90 SWAP1 0C01 61 PUSH2 0x0c09 0C04 90 SWAP1 0C05 61 PUSH2 0x21a5 0C08 56 *JUMP // Stack delta = -1 // Outputs[8] // { // @0BE6 memory[stack[-4]:stack[-4] + 0x20] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0BEC memory[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] = stack[-5] // @0BF5 storage[keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-4]])] = stack[-6] // @0BFE stack[-6] = storage[0x09] // @0BFF stack[-5] = 0x09 // @0C00 stack[-4] = 0x00 // @0C04 stack[-3] = 0x0c09 // @0C04 stack[-2] = storage[0x09] // } // Block ends with call to 0x21a5, returns to 0x0C09 label_0C09: // Incoming return from call to 0x21A5 at 0x0C08 // Inputs[4] // { // @0C0A stack[-2] // @0C0A stack[-1] // @0C0B stack[-3] // @0C12 storage[0x08] // } 0C09 5B JUMPDEST 0C0A 90 SWAP1 0C0B 91 SWAP2 0C0C 55 SSTORE 0C0D 50 POP 0C0E 50 POP 0C0F 60 PUSH1 0x08 0C11 80 DUP1 0C12 54 SLOAD 0C13 60 PUSH1 0xff 0C15 16 AND 0C16 90 SWAP1 0C17 60 PUSH1 0x00 0C19 61 PUSH2 0x0c21 0C1C 83 DUP4 0C1D 61 PUSH2 0x21c0 0C20 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C0C storage[stack[-3]] = stack[-1] // @0C16 stack[-4] = 0xff & storage[0x08] // @0C16 stack[-3] = 0x08 // @0C17 stack[-2] = 0x00 // @0C19 stack[-1] = 0x0c21 // @0C1C stack[0] = 0xff & storage[0x08] // } // Block ends with call to 0x21c0, returns to 0x0C21 label_0C21: // Incoming return from call to 0x21C0 at 0x0C20 // Inputs[7] // { // @0C22 stack[-3] // @0C22 stack[-1] // @0C23 stack[-2] // @0C29 storage[stack[-3]] // @0C3E stack[-9] // @0C3F stack[-8] // @0C40 stack[-5] // } 0C21 5B JUMPDEST 0C22 91 SWAP2 0C23 90 SWAP1 0C24 61 PUSH2 0x0100 0C27 0A EXP 0C28 81 DUP2 0C29 54 SLOAD 0C2A 81 DUP2 0C2B 60 PUSH1 0xff 0C2D 02 MUL 0C2E 19 NOT 0C2F 16 AND 0C30 90 SWAP1 0C31 83 DUP4 0C32 60 PUSH1 0xff 0C34 16 AND 0C35 02 MUL 0C36 17 OR 0C37 90 SWAP1 0C38 55 SSTORE 0C39 50 POP 0C3A 50 POP 0C3B 61 PUSH2 0x0cb0 0C3E 85 DUP6 0C3F 85 DUP6 0C40 83 DUP4 0C41 81 DUP2 0C42 81 DUP2 0C43 10 LT 0C44 61 PUSH2 0x0c5d 0C47 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0C38 storage[stack[-3]] = (0xff & stack[-1]) * 0x0100 ** stack[-2] | (~(0xff * 0x0100 ** stack[-2]) & storage[stack[-3]]) // @0C3B stack[-4] = 0x0cb0 // @0C3E stack[-3] = stack[-9] // @0C3F stack[-2] = stack[-8] // @0C40 stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x0c5d, if stack[-5] < stack[-8] label_0C48: // Incoming jump from 0x0C47, if not stack[-5] < stack[-8] // Inputs[1] { @0C5C memory[0x00:0x24] } 0C48 63 PUSH4 0x4e487b71 0C4D 60 PUSH1 0xe0 0C4F 1B SHL 0C50 60 PUSH1 0x00 0C52 52 MSTORE 0C53 60 PUSH1 0x32 0C55 60 PUSH1 0x04 0C57 52 MSTORE 0C58 60 PUSH1 0x24 0C5A 60 PUSH1 0x00 0C5C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0C52 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0C57 memory[0x04:0x24] = 0x32 // @0C5C revert(memory[0x00:0x24]); // } // Block terminates label_0C5D: // Incoming jump from 0x0C47, if stack[-5] < stack[-8] // Inputs[3] // { // @0C5E stack[-1] // @0C5E stack[-2] // @0C63 stack[-3] // } 0C5D 5B JUMPDEST 0C5E 90 SWAP1 0C5F 50 POP 0C60 60 PUSH1 0x20 0C62 02 MUL 0C63 01 ADD 0C64 60 PUSH1 0x20 0C66 81 DUP2 0C67 01 ADD 0C68 90 SWAP1 0C69 61 PUSH2 0x0c72 0C6C 91 SWAP2 0C6D 90 SWAP1 0C6E 61 PUSH2 0x1b6c 0C71 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0C6C stack[-3] = 0x0c72 // @0C6D stack[-1] = 0x20 * stack[-1] + stack[-3] // @0C6D stack[-2] = 0x20 * stack[-1] + stack[-3] + 0x20 // } // Block ends with call to 0x1b6c, returns to 0x0C72 label_0C72: // Incoming return from call to 0x1B6C at 0x0C71 // Inputs[3] // { // @0C73 stack[-5] // @0C74 stack[-4] // @0C75 stack[-3] // } 0C72 5B JUMPDEST 0C73 84 DUP5 0C74 84 DUP5 0C75 84 DUP5 0C76 81 DUP2 0C77 81 DUP2 0C78 10 LT 0C79 61 PUSH2 0x0c92 0C7C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0C73 stack[0] = stack[-5] // @0C74 stack[1] = stack[-4] // @0C75 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x0c92, if stack[-3] < stack[-4] label_0C7D: // Incoming jump from 0x0C7C, if not stack[-3] < stack[-4] // Inputs[1] { @0C91 memory[0x00:0x24] } 0C7D 63 PUSH4 0x4e487b71 0C82 60 PUSH1 0xe0 0C84 1B SHL 0C85 60 PUSH1 0x00 0C87 52 MSTORE 0C88 60 PUSH1 0x32 0C8A 60 PUSH1 0x04 0C8C 52 MSTORE 0C8D 60 PUSH1 0x24 0C8F 60 PUSH1 0x00 0C91 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0C87 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0C8C memory[0x04:0x24] = 0x32 // @0C91 revert(memory[0x00:0x24]); // } // Block terminates label_0C92: // Incoming jump from 0x0C7C, if stack[-3] < stack[-4] // Inputs[5] // { // @0C93 stack[-1] // @0C93 stack[-2] // @0C98 stack[-3] // @0C99 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0C9E memory[0x40:0x60] // } 0C92 5B JUMPDEST 0C93 90 SWAP1 0C94 50 POP 0C95 60 PUSH1 0x20 0C97 02 MUL 0C98 01 ADD 0C99 35 CALLDATALOAD 0C9A 60 PUSH1 0x01 0C9C 60 PUSH1 0x40 0C9E 51 MLOAD 0C9F 80 DUP1 0CA0 60 PUSH1 0x20 0CA2 01 ADD 0CA3 60 PUSH1 0x40 0CA5 52 MSTORE 0CA6 80 DUP1 0CA7 60 PUSH1 0x00 0CA9 81 DUP2 0CAA 52 MSTORE 0CAB 50 POP 0CAC 61 PUSH2 0x11c6 0CAF 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @0C99 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // @0C9A stack[-2] = 0x01 // @0C9E stack[-1] = memory[0x40:0x60] // @0CA5 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0CAA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x11c6 0CB0 5B JUMPDEST 0CB1 80 DUP1 0CB2 61 PUSH2 0x0cba 0CB5 81 DUP2 0CB6 61 PUSH2 0x21a5 0CB9 56 *JUMP 0CBA 5B JUMPDEST 0CBB 91 SWAP2 0CBC 50 POP 0CBD 50 POP 0CBE 61 PUSH2 0x0baf 0CC1 56 *JUMP label_0CC2: // Incoming jump from 0x0303 // Incoming call from 0x0557, returns to 0x04B9 0CC2 5B JUMPDEST 0CC3 60 PUSH1 0x60 0CC5 61 PUSH2 0x0ccc 0CC8 61 PUSH2 0x19e7 0CCB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CC3 stack[0] = 0x60 // @0CC5 stack[1] = 0x0ccc // } // Block ends with call to 0x19e7, returns to 0x0CCC label_0CCC: // Incoming return from call to 0x19E7 at 0x0CCB // Inputs[1] { @0CD0 storage[0x06] } 0CCC 5B JUMPDEST 0CCD 60 PUSH1 0x06 0CCF 80 DUP1 0CD0 54 SLOAD 0CD1 61 PUSH2 0x0cd9 0CD4 90 SWAP1 0CD5 61 PUSH2 0x213d 0CD8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CCD stack[0] = 0x06 // @0CD4 stack[1] = 0x0cd9 // @0CD4 stack[2] = storage[0x06] // } // Block ends with call to 0x213d, returns to 0x0CD9 label_0CD9: // Incoming return from call to 0x213D at 0x0CD8 // Inputs[4] // { // @0CDA stack[-1] // @0CE9 memory[0x40:0x60] // @0CF1 stack[-2] // @0CFC storage[stack[-2]] // } 0CD9 5B JUMPDEST 0CDA 80 DUP1 0CDB 60 PUSH1 0x1f 0CDD 01 ADD 0CDE 60 PUSH1 0x20 0CE0 80 DUP1 0CE1 91 SWAP2 0CE2 04 DIV 0CE3 02 MUL 0CE4 60 PUSH1 0x20 0CE6 01 ADD 0CE7 60 PUSH1 0x40 0CE9 51 MLOAD 0CEA 90 SWAP1 0CEB 81 DUP2 0CEC 01 ADD 0CED 60 PUSH1 0x40 0CEF 52 MSTORE 0CF0 80 DUP1 0CF1 92 SWAP3 0CF2 91 SWAP2 0CF3 90 SWAP1 0CF4 81 DUP2 0CF5 81 DUP2 0CF6 52 MSTORE 0CF7 60 PUSH1 0x20 0CF9 01 ADD 0CFA 82 DUP3 0CFB 80 DUP1 0CFC 54 SLOAD 0CFD 61 PUSH2 0x0d05 0D00 90 SWAP1 0D01 61 PUSH2 0x213d 0D04 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0CEF memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0CF1 stack[-2] = memory[0x40:0x60] // @0CF2 stack[-1] = stack[-2] // @0CF3 stack[0] = stack[-1] // @0CF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0CF9 stack[1] = 0x20 + memory[0x40:0x60] // @0CFA stack[2] = stack[-2] // @0D00 stack[4] = storage[stack[-2]] // @0D00 stack[3] = 0x0d05 // } // Block ends with call to 0x213d, returns to 0x0D05 label_0D05: // Incoming return from call to 0x213D at 0x0D04 // Inputs[1] { @0D06 stack[-1] } 0D05 5B JUMPDEST 0D06 80 DUP1 0D07 15 ISZERO 0D08 61 PUSH2 0x0d52 0D0B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d52, if !stack[-1] label_0D0C: // Incoming jump from 0x0D0B, if not !stack[-1] // Inputs[1] { @0D0C stack[-1] } 0D0C 80 DUP1 0D0D 60 PUSH1 0x1f 0D0F 10 LT 0D10 61 PUSH2 0x0d27 0D13 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d27, if 0x1f < stack[-1] label_0D14: // Incoming jump from 0x0D13, if not 0x1f < stack[-1] // Inputs[4] // { // @0D18 stack[-2] // @0D19 storage[stack[-2]] // @0D1C stack[-3] // @0D1E stack[-1] // } 0D14 61 PUSH2 0x0100 0D17 80 DUP1 0D18 83 DUP4 0D19 54 SLOAD 0D1A 04 DIV 0D1B 02 MUL 0D1C 83 DUP4 0D1D 52 MSTORE 0D1E 91 SWAP2 0D1F 60 PUSH1 0x20 0D21 01 ADD 0D22 91 SWAP2 0D23 61 PUSH2 0x0d52 0D26 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0D1D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0D22 stack[-1] = stack[-1] // @0D22 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0d52 label_0D27: // Incoming jump from 0x0D13, if 0x1f < stack[-1] // Inputs[5] // { // @0D28 stack[-3] // @0D29 stack[-1] // @0D2B stack[-2] // @0D33 memory[0x00:0x20] // @0D37 storage[keccak256(memory[0x00:0x20])] // } 0D27 5B JUMPDEST 0D28 82 DUP3 0D29 01 ADD 0D2A 91 SWAP2 0D2B 90 SWAP1 0D2C 60 PUSH1 0x00 0D2E 52 MSTORE 0D2F 60 PUSH1 0x20 0D31 60 PUSH1 0x00 0D33 20 SHA3 0D34 90 SWAP1 0D35 5B JUMPDEST 0D36 81 DUP2 0D37 54 SLOAD 0D38 81 DUP2 0D39 52 MSTORE 0D3A 90 SWAP1 0D3B 60 PUSH1 0x01 0D3D 01 ADD 0D3E 90 SWAP1 0D3F 60 PUSH1 0x20 0D41 01 ADD 0D42 80 DUP1 0D43 83 DUP4 0D44 11 GT 0D45 61 PUSH2 0x0d35 0D48 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0D2A stack[-3] = stack[-3] + stack[-1] // @0D2E memory[0x00:0x20] = stack[-2] // @0D39 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0D3E stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0D41 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0d35, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0D49: // Incoming jump from 0x0D48, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0D48, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0D49 stack[-3] // @0D4A stack[-1] // } 0D49 82 DUP3 0D4A 90 SWAP1 0D4B 03 SUB 0D4C 60 PUSH1 0x1f 0D4E 16 AND 0D4F 82 DUP3 0D50 01 ADD 0D51 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0D51 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0D51 stack[-1] = stack[-3] // } // Block continues label_0D52: // Incoming jump from 0x0D26 // Incoming jump from 0x0D0B, if !stack[-1] // Incoming jump from 0x0D51 // Inputs[1] { @0D58 stack[-7] } 0D52 5B JUMPDEST 0D53 50 POP 0D54 50 POP 0D55 50 POP 0D56 50 POP 0D57 50 POP 0D58 81 DUP2 0D59 60 PUSH1 0x00 0D5B 60 PUSH1 0x02 0D5D 81 DUP2 0D5E 10 LT 0D5F 61 PUSH2 0x0d78 0D62 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @0D58 stack[-5] = stack[-7] // @0D59 stack[-4] = 0x00 // } // Block ends with conditional jump to 0x0d78, if 0x00 < 0x02 label_0D63: // Incoming jump from 0x0D62, if not 0x00 < 0x02 // Inputs[1] { @0D77 memory[0x00:0x24] } 0D63 63 PUSH4 0x4e487b71 0D68 60 PUSH1 0xe0 0D6A 1B SHL 0D6B 60 PUSH1 0x00 0D6D 52 MSTORE 0D6E 60 PUSH1 0x32 0D70 60 PUSH1 0x04 0D72 52 MSTORE 0D73 60 PUSH1 0x24 0D75 60 PUSH1 0x00 0D77 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0D6D memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0D72 memory[0x04:0x24] = 0x32 // @0D77 revert(memory[0x00:0x24]); // } // Block terminates label_0D78: // Incoming jump from 0x0D62, if 0x00 < 0x02 // Inputs[4] // { // @0D7B stack[-1] // @0D7C stack[-2] // @0D7D stack[-3] // @0D81 stack[-6] // } 0D78 5B JUMPDEST 0D79 60 PUSH1 0x20 0D7B 02 MUL 0D7C 01 ADD 0D7D 52 MSTORE 0D7E 61 PUSH2 0x0d86 0D81 83 DUP4 0D82 61 PUSH2 0x1356 0D85 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0D7D memory[0x20 * stack[-1] + stack[-2]:0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] // @0D7E stack[-3] = 0x0d86 // @0D81 stack[-2] = stack[-6] // } // Block ends with call to 0x1356, returns to 0x0D86 label_0D86: // Incoming return from call to 0x1356 at 0x0D85 // Inputs[4] // { // @0D8A stack[-2] // @0D8C stack[-1] // @0D90 memory[stack[-2]:stack[-2] + 0x20] // @0D93 memory[0x40:0x60] // } 0D86 5B JUMPDEST 0D87 60 PUSH1 0x20 0D89 80 DUP1 0D8A 83 DUP4 0D8B 01 ADD 0D8C 82 DUP3 0D8D 90 SWAP1 0D8E 52 MSTORE 0D8F 82 DUP3 0D90 51 MLOAD 0D91 60 PUSH1 0x40 0D93 51 MLOAD 0D94 60 PUSH1 0x00 0D96 93 SWAP4 0D97 61 PUSH2 0x0da2 0D9A 93 SWAP4 0D9B 90 SWAP1 0D9C 91 SWAP2 0D9D 01 ADD 0D9E 61 PUSH2 0x1f82 0DA1 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @0D8E memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-1] // @0D90 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @0D96 stack[-1] = 0x00 // @0D9A stack[0] = 0x0da2 // @0D9C stack[2] = stack[-1] // @0D9D stack[3] = memory[0x40:0x60] + 0x20 // } // Block ends with call to 0x1f82, returns to 0x0DA2 label_0DA2: // Incoming return from call to 0x1F82 at 0x0DA1 // Inputs[4] // { // @0DA6 memory[0x40:0x60] // @0DAB stack[-1] // @0DB3 stack[-6] // @0DB4 stack[-5] // } 0DA2 5B JUMPDEST 0DA3 60 PUSH1 0x40 0DA5 80 DUP1 0DA6 51 MLOAD 0DA7 60 PUSH1 0x1f 0DA9 19 NOT 0DAA 81 DUP2 0DAB 84 DUP5 0DAC 03 SUB 0DAD 01 ADD 0DAE 81 DUP2 0DAF 52 MSTORE 0DB0 91 SWAP2 0DB1 90 SWAP1 0DB2 52 MSTORE 0DB3 94 SWAP5 0DB4 93 SWAP4 0DB5 50 POP 0DB6 50 POP 0DB7 50 POP 0DB8 50 POP 0DB9 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @0DAF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + ~0x1f // @0DB2 memory[0x40:0x60] = stack[-1] // @0DB3 stack[-6] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-6] label_0DBA: // Incoming jump from 0x0365 // Inputs[2] // { // @0DC3 stack[-5] // @0DC5 msg.sender // } 0DBA 5B JUMPDEST 0DBB 60 PUSH1 0x01 0DBD 60 PUSH1 0x01 0DBF 60 PUSH1 0xa0 0DC1 1B SHL 0DC2 03 SUB 0DC3 85 DUP6 0DC4 16 AND 0DC5 33 CALLER 0DC6 14 EQ 0DC7 80 DUP1 0DC8 61 PUSH2 0x0dd6 0DCB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DC6 stack[0] = msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x0dd6, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 label_0DCC: // Incoming jump from 0x0DCB, if not msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0DD0 stack[-6] // @0DD1 msg.sender // } 0DCC 50 POP 0DCD 61 PUSH2 0x0dd6 0DD0 85 DUP6 0DD1 33 CALLER 0DD2 61 PUSH2 0x0312 0DD5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DCD stack[-1] = 0x0dd6 // @0DD0 stack[0] = stack[-6] // @0DD1 stack[1] = msg.sender // } // Block ends with call to 0x0312, returns to 0x0DD6 label_0DD6: // Incoming jump from 0x0DCB, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x0312 at 0x0DD5 // Inputs[1] { @0DDA stack[-1] } 0DD6 5B JUMPDEST 0DD7 61 PUSH2 0x0e48 0DDA 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e48, if stack[-1] label_0DDB: // Incoming jump from 0x0DDA, if not stack[-1] // Inputs[1] { @0DDD memory[0x40:0x60] } 0DDB 60 PUSH1 0x40 0DDD 51 MLOAD 0DDE 62 PUSH3 0x461bcd 0DE2 60 PUSH1 0xe5 0DE4 1B SHL 0DE5 81 DUP2 0DE6 52 MSTORE 0DE7 60 PUSH1 0x20 0DE9 60 PUSH1 0x04 0DEB 82 DUP3 0DEC 01 ADD 0DED 52 MSTORE 0DEE 60 PUSH1 0x29 0DF0 60 PUSH1 0x24 0DF2 82 DUP3 0DF3 01 ADD 0DF4 52 MSTORE 0DF5 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 0E16 60 PUSH1 0x44 0E18 82 DUP3 0E19 01 ADD 0E1A 52 MSTORE 0E1B 7F PUSH32 0x20617070726f7665640000000000000000000000000000000000000000000000 0E3C 60 PUSH1 0x64 0E3E 82 DUP3 0E3F 01 ADD 0E40 52 MSTORE 0E41 60 PUSH1 0x84 0E43 01 ADD 0E44 61 PUSH2 0x03f3 0E47 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0DE6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DED memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DF4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0E1A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 // @0E40 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x20617070726f7665640000000000000000000000000000000000000000000000 // @0E43 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_0E48: // Incoming jump from 0x0DDA, if stack[-1] // Inputs[5] // { // @0E4C stack[-5] // @0E4D stack[-4] // @0E4E stack[-3] // @0E4F stack[-2] // @0E50 stack[-1] // } 0E48 5B JUMPDEST 0E49 61 PUSH2 0x05f3 0E4C 85 DUP6 0E4D 85 DUP6 0E4E 85 DUP6 0E4F 85 DUP6 0E50 85 DUP6 0E51 61 PUSH2 0x14ac 0E54 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0E49 stack[0] = 0x05f3 // @0E4C stack[1] = stack[-5] // @0E4D stack[2] = stack[-4] // @0E4E stack[3] = stack[-3] // @0E4F stack[4] = stack[-2] // @0E50 stack[5] = stack[-1] // } // Block ends with unconditional jump to 0x14ac label_0E55: // Incoming jump from 0x0378 // Inputs[2] // { // @0E58 storage[0x03] // @0E62 msg.sender // } 0E55 5B JUMPDEST 0E56 60 PUSH1 0x03 0E58 54 SLOAD 0E59 60 PUSH1 0x01 0E5B 60 PUSH1 0x01 0E5D 60 PUSH1 0xa0 0E5F 1B SHL 0E60 03 SUB 0E61 16 AND 0E62 33 CALLER 0E63 14 EQ 0E64 61 PUSH2 0x0eaf 0E67 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eaf, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0E68: // Incoming jump from 0x0E67, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0E6A memory[0x40:0x60] } 0E68 60 PUSH1 0x40 0E6A 51 MLOAD 0E6B 62 PUSH3 0x461bcd 0E6F 60 PUSH1 0xe5 0E71 1B SHL 0E72 81 DUP2 0E73 52 MSTORE 0E74 60 PUSH1 0x20 0E76 60 PUSH1 0x04 0E78 82 DUP3 0E79 01 ADD 0E7A 81 DUP2 0E7B 90 SWAP1 0E7C 52 MSTORE 0E7D 60 PUSH1 0x24 0E7F 82 DUP3 0E80 01 ADD 0E81 52 MSTORE 0E82 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0EA3 60 PUSH1 0x44 0EA5 82 DUP3 0EA6 01 ADD 0EA7 52 MSTORE 0EA8 60 PUSH1 0x64 0EAA 01 ADD 0EAB 61 PUSH2 0x03f3 0EAE 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0E73 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E7C memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E81 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0EA7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0EAA stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_0EAF: // Incoming jump from 0x0E67, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0EB8 stack[-1] } 0EAF 5B JUMPDEST 0EB0 60 PUSH1 0x01 0EB2 60 PUSH1 0x01 0EB4 60 PUSH1 0xa0 0EB6 1B SHL 0EB7 03 SUB 0EB8 81 DUP2 0EB9 16 AND 0EBA 61 PUSH2 0x0f2b 0EBD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f2b, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0EBE: // Incoming jump from 0x0EBD, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0EC0 memory[0x40:0x60] } 0EBE 60 PUSH1 0x40 0EC0 51 MLOAD 0EC1 62 PUSH3 0x461bcd 0EC5 60 PUSH1 0xe5 0EC7 1B SHL 0EC8 81 DUP2 0EC9 52 MSTORE 0ECA 60 PUSH1 0x20 0ECC 60 PUSH1 0x04 0ECE 82 DUP3 0ECF 01 ADD 0ED0 52 MSTORE 0ED1 60 PUSH1 0x26 0ED3 60 PUSH1 0x24 0ED5 82 DUP3 0ED6 01 ADD 0ED7 52 MSTORE 0ED8 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0EF9 60 PUSH1 0x44 0EFB 82 DUP3 0EFC 01 ADD 0EFD 52 MSTORE 0EFE 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 0F1F 60 PUSH1 0x64 0F21 82 DUP3 0F22 01 ADD 0F23 52 MSTORE 0F24 60 PUSH1 0x84 0F26 01 ADD 0F27 61 PUSH2 0x03f3 0F2A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0EC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0ED0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0ED7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0EFD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0F23 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @0F26 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_0F2B: // Incoming jump from 0x0EBD, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0F2F stack[-1] } 0F2B 5B JUMPDEST 0F2C 61 PUSH2 0x0f34 0F2F 81 DUP2 0F30 61 PUSH2 0x12ec 0F33 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F2C stack[0] = 0x0f34 // @0F2F stack[1] = stack[-1] // } // Block ends with call to 0x12ec, returns to 0x0F34 label_0F34: // Incoming jump from 0x22E9, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x12EC at 0x0F33 // Inputs[1] { @0F36 stack[-2] } 0F34 5B JUMPDEST 0F35 50 POP 0F36 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 0F37 5B JUMPDEST 0F38 81 DUP2 0F39 51 MLOAD 0F3A 83 DUP4 0F3B 51 MLOAD 0F3C 14 EQ 0F3D 61 PUSH2 0x0fae 0F40 57 *JUMPI 0F41 60 PUSH1 0x40 0F43 51 MLOAD 0F44 62 PUSH3 0x461bcd 0F48 60 PUSH1 0xe5 0F4A 1B SHL 0F4B 81 DUP2 0F4C 52 MSTORE 0F4D 60 PUSH1 0x20 0F4F 60 PUSH1 0x04 0F51 82 DUP3 0F52 01 ADD 0F53 52 MSTORE 0F54 60 PUSH1 0x28 0F56 60 PUSH1 0x24 0F58 82 DUP3 0F59 01 ADD 0F5A 52 MSTORE 0F5B 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 0F7C 60 PUSH1 0x44 0F7E 82 DUP3 0F7F 01 ADD 0F80 52 MSTORE 0F81 7F PUSH32 0x6d69736d61746368000000000000000000000000000000000000000000000000 0FA2 60 PUSH1 0x64 0FA4 82 DUP3 0FA5 01 ADD 0FA6 52 MSTORE 0FA7 60 PUSH1 0x84 0FA9 01 ADD 0FAA 61 PUSH2 0x03f3 0FAD 56 *JUMP 0FAE 5B JUMPDEST 0FAF 60 PUSH1 0x01 0FB1 60 PUSH1 0x01 0FB3 60 PUSH1 0xa0 0FB5 1B SHL 0FB6 03 SUB 0FB7 84 DUP5 0FB8 16 AND 0FB9 61 PUSH2 0x1012 0FBC 57 *JUMPI 0FBD 60 PUSH1 0x40 0FBF 51 MLOAD 0FC0 62 PUSH3 0x461bcd 0FC4 60 PUSH1 0xe5 0FC6 1B SHL 0FC7 81 DUP2 0FC8 52 MSTORE 0FC9 60 PUSH1 0x20 0FCB 60 PUSH1 0x04 0FCD 82 DUP3 0FCE 01 ADD 0FCF 52 MSTORE 0FD0 60 PUSH1 0x25 0FD2 60 PUSH1 0x24 0FD4 82 DUP3 0FD5 01 ADD 0FD6 52 MSTORE 0FD7 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 0FF8 60 PUSH1 0x44 0FFA 82 DUP3 0FFB 01 ADD 0FFC 52 MSTORE 0FFD 64 PUSH5 0x6472657373 1003 60 PUSH1 0xd8 1005 1B SHL 1006 60 PUSH1 0x64 1008 82 DUP3 1009 01 ADD 100A 52 MSTORE 100B 60 PUSH1 0x84 100D 01 ADD 100E 61 PUSH2 0x03f3 1011 56 *JUMP 1012 5B JUMPDEST 1013 33 CALLER 1014 60 PUSH1 0x00 1016 5B JUMPDEST 1017 84 DUP5 1018 51 MLOAD 1019 81 DUP2 101A 10 LT 101B 15 ISZERO 101C 61 PUSH2 0x1158 101F 57 *JUMPI 1020 60 PUSH1 0x00 1022 85 DUP6 1023 82 DUP3 1024 81 DUP2 1025 51 MLOAD 1026 81 DUP2 1027 10 LT 1028 61 PUSH2 0x1041 102B 57 *JUMPI 102C 63 PUSH4 0x4e487b71 1031 60 PUSH1 0xe0 1033 1B SHL 1034 60 PUSH1 0x00 1036 52 MSTORE 1037 60 PUSH1 0x32 1039 60 PUSH1 0x04 103B 52 MSTORE 103C 60 PUSH1 0x24 103E 60 PUSH1 0x00 1040 FD *REVERT 1041 5B JUMPDEST 1042 60 PUSH1 0x20 1044 02 MUL 1045 60 PUSH1 0x20 1047 01 ADD 1048 01 ADD 1049 51 MLOAD 104A 90 SWAP1 104B 50 POP 104C 60 PUSH1 0x00 104E 85 DUP6 104F 83 DUP4 1050 81 DUP2 1051 51 MLOAD 1052 81 DUP2 1053 10 LT 1054 61 PUSH2 0x106d 1057 57 *JUMPI 1058 63 PUSH4 0x4e487b71 105D 60 PUSH1 0xe0 105F 1B SHL 1060 60 PUSH1 0x00 1062 52 MSTORE 1063 60 PUSH1 0x32 1065 60 PUSH1 0x04 1067 52 MSTORE 1068 60 PUSH1 0x24 106A 60 PUSH1 0x00 106C FD *REVERT 106D 5B JUMPDEST 106E 60 PUSH1 0x20 1070 90 SWAP1 1071 81 DUP2 1072 02 MUL 1073 91 SWAP2 1074 90 SWAP1 1075 91 SWAP2 1076 01 ADD 1077 81 DUP2 1078 01 ADD 1079 51 MLOAD 107A 60 PUSH1 0x00 107C 84 DUP5 107D 81 DUP2 107E 52 MSTORE 107F 80 DUP1 1080 83 DUP4 1081 52 MSTORE 1082 60 PUSH1 0x40 1084 80 DUP1 1085 82 DUP3 1086 20 SHA3 1087 60 PUSH1 0x01 1089 60 PUSH1 0x01 108B 60 PUSH1 0xa0 108D 1B SHL 108E 03 SUB 108F 8E DUP15 1090 16 AND 1091 83 DUP4 1092 52 MSTORE 1093 90 SWAP1 1094 93 SWAP4 1095 52 MSTORE 1096 91 SWAP2 1097 90 SWAP1 1098 91 SWAP2 1099 20 SHA3 109A 54 SLOAD 109B 90 SWAP1 109C 91 SWAP2 109D 50 POP 109E 81 DUP2 109F 81 DUP2 10A0 10 LT 10A1 15 ISZERO 10A2 61 PUSH2 0x1100 10A5 57 *JUMPI 10A6 60 PUSH1 0x40 10A8 51 MLOAD 10A9 62 PUSH3 0x461bcd 10AD 60 PUSH1 0xe5 10AF 1B SHL 10B0 81 DUP2 10B1 52 MSTORE 10B2 60 PUSH1 0x20 10B4 60 PUSH1 0x04 10B6 82 DUP3 10B7 01 ADD 10B8 52 MSTORE 10B9 60 PUSH1 0x2a 10BB 60 PUSH1 0x24 10BD 82 DUP3 10BE 01 ADD 10BF 52 MSTORE 10C0 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 10E1 60 PUSH1 0x44 10E3 82 DUP3 10E4 01 ADD 10E5 52 MSTORE 10E6 69 PUSH10 0x39103a3930b739b332b9 10F1 60 PUSH1 0xb1 10F3 1B SHL 10F4 60 PUSH1 0x64 10F6 82 DUP3 10F7 01 ADD 10F8 52 MSTORE 10F9 60 PUSH1 0x84 10FB 01 ADD 10FC 61 PUSH2 0x03f3 10FF 56 *JUMP 1100 5B JUMPDEST 1101 60 PUSH1 0x00 1103 83 DUP4 1104 81 DUP2 1105 52 MSTORE 1106 60 PUSH1 0x20 1108 81 DUP2 1109 81 DUP2 110A 52 MSTORE 110B 60 PUSH1 0x40 110D 80 DUP1 110E 83 DUP4 110F 20 SHA3 1110 60 PUSH1 0x01 1112 60 PUSH1 0x01 1114 60 PUSH1 0xa0 1116 1B SHL 1117 03 SUB 1118 8E DUP15 1119 81 DUP2 111A 16 AND 111B 85 DUP6 111C 52 MSTORE 111D 92 SWAP3 111E 52 MSTORE 111F 80 DUP1 1120 83 DUP4 1121 20 SHA3 1122 85 DUP6 1123 85 DUP6 1124 03 SUB 1125 90 SWAP1 1126 55 SSTORE 1127 90 SWAP1 1128 8B DUP12 1129 16 AND 112A 82 DUP3 112B 52 MSTORE 112C 81 DUP2 112D 20 SHA3 112E 80 DUP1 112F 54 SLOAD 1130 84 DUP5 1131 92 SWAP3 1132 90 SWAP1 1133 61 PUSH2 0x113d 1136 90 SWAP1 1137 84 DUP5 1138 90 SWAP1 1139 61 PUSH2 0x20ca 113C 56 *JUMP 113D 5B JUMPDEST 113E 92 SWAP3 113F 50 POP 1140 50 POP 1141 81 DUP2 1142 90 SWAP1 1143 55 SSTORE 1144 50 POP 1145 50 POP 1146 50 POP 1147 50 POP 1148 80 DUP1 1149 61 PUSH2 0x1151 114C 90 SWAP1 114D 61 PUSH2 0x21a5 1150 56 *JUMP 1151 5B JUMPDEST 1152 90 SWAP1 1153 50 POP 1154 61 PUSH2 0x1016 1157 56 *JUMP 1158 5B JUMPDEST 1159 50 POP 115A 84 DUP5 115B 60 PUSH1 0x01 115D 60 PUSH1 0x01 115F 60 PUSH1 0xa0 1161 1B SHL 1162 03 SUB 1163 16 AND 1164 86 DUP7 1165 60 PUSH1 0x01 1167 60 PUSH1 0x01 1169 60 PUSH1 0xa0 116B 1B SHL 116C 03 SUB 116D 16 AND 116E 82 DUP3 116F 60 PUSH1 0x01 1171 60 PUSH1 0x01 1173 60 PUSH1 0xa0 1175 1B SHL 1176 03 SUB 1177 16 AND 1178 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 1199 87 DUP8 119A 87 DUP8 119B 60 PUSH1 0x40 119D 51 MLOAD 119E 61 PUSH2 0x11a8 11A1 92 SWAP3 11A2 91 SWAP2 11A3 90 SWAP1 11A4 61 PUSH2 0x2065 11A7 56 *JUMP 11A8 5B JUMPDEST 11A9 60 PUSH1 0x40 11AB 51 MLOAD 11AC 80 DUP1 11AD 91 SWAP2 11AE 03 SUB 11AF 90 SWAP1 11B0 A4 LOG4 11B1 61 PUSH2 0x11be 11B4 81 DUP2 11B5 87 DUP8 11B6 87 DUP8 11B7 87 DUP8 11B8 87 DUP8 11B9 87 DUP8 11BA 61 PUSH2 0x164a 11BD 56 *JUMP 11BE 5B JUMPDEST 11BF 50 POP 11C0 50 POP 11C1 50 POP 11C2 50 POP 11C3 50 POP 11C4 50 POP 11C5 56 *JUMP label_11C6: // Incoming jump from 0x0CAF // Incoming jump from 0x091B // Inputs[1] { @11CF stack[-4] } 11C6 5B JUMPDEST 11C7 60 PUSH1 0x01 11C9 60 PUSH1 0x01 11CB 60 PUSH1 0xa0 11CD 1B SHL 11CE 03 SUB 11CF 84 DUP5 11D0 16 AND 11D1 61 PUSH2 0x1242 11D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1242, if stack[-4] & (0x01 << 0xa0) - 0x01 label_11D5: // Incoming jump from 0x11D4, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @11D7 memory[0x40:0x60] } 11D5 60 PUSH1 0x40 11D7 51 MLOAD 11D8 62 PUSH3 0x461bcd 11DC 60 PUSH1 0xe5 11DE 1B SHL 11DF 81 DUP2 11E0 52 MSTORE 11E1 60 PUSH1 0x20 11E3 60 PUSH1 0x04 11E5 82 DUP3 11E6 01 ADD 11E7 52 MSTORE 11E8 60 PUSH1 0x21 11EA 60 PUSH1 0x24 11EC 82 DUP3 11ED 01 ADD 11EE 52 MSTORE 11EF 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 1210 60 PUSH1 0x44 1212 82 DUP3 1213 01 ADD 1214 52 MSTORE 1215 7F PUSH32 0x7300000000000000000000000000000000000000000000000000000000000000 1236 60 PUSH1 0x64 1238 82 DUP3 1239 01 ADD 123A 52 MSTORE 123B 60 PUSH1 0x84 123D 01 ADD 123E 61 PUSH2 0x03f3 1241 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @11E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11E7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11EE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @1214 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @123A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7300000000000000000000000000000000000000000000000000000000000000 // @123D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_1242: // Incoming jump from 0x11D4, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1243 msg.sender // @124A stack[-4] // @124E stack[-3] // } 1242 5B JUMPDEST 1243 33 CALLER 1244 61 PUSH2 0x125c 1247 81 DUP2 1248 60 PUSH1 0x00 124A 87 DUP8 124B 61 PUSH2 0x1253 124E 88 DUP9 124F 61 PUSH2 0x17ff 1252 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1243 stack[0] = msg.sender // @1244 stack[1] = 0x125c // @1247 stack[2] = msg.sender // @1248 stack[3] = 0x00 // @124A stack[4] = stack[-4] // @124B stack[5] = 0x1253 // @124E stack[6] = stack[-3] // } // Block ends with call to 0x17ff, returns to 0x1253 label_1253: // Incoming return from call to 0x17FF at 0x151F // Incoming return from call to 0x17FF at 0x1252 // Inputs[1] { @1257 stack[-8] } 1253 5B JUMPDEST 1254 61 PUSH2 0x05f3 1257 88 DUP9 1258 61 PUSH2 0x17ff 125B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1254 stack[0] = 0x05f3 // @1257 stack[1] = stack[-8] // } // Block ends with call to 0x17ff, returns to 0x05F3 125C 5B JUMPDEST 125D 60 PUSH1 0x00 125F 84 DUP5 1260 81 DUP2 1261 52 MSTORE 1262 60 PUSH1 0x20 1264 81 DUP2 1265 81 DUP2 1266 52 MSTORE 1267 60 PUSH1 0x40 1269 80 DUP1 126A 83 DUP4 126B 20 SHA3 126C 60 PUSH1 0x01 126E 60 PUSH1 0x01 1270 60 PUSH1 0xa0 1272 1B SHL 1273 03 SUB 1274 89 DUP10 1275 16 AND 1276 84 DUP5 1277 52 MSTORE 1278 90 SWAP1 1279 91 SWAP2 127A 52 MSTORE 127B 81 DUP2 127C 20 SHA3 127D 80 DUP1 127E 54 SLOAD 127F 85 DUP6 1280 92 SWAP3 1281 90 SWAP1 1282 61 PUSH2 0x128c 1285 90 SWAP1 1286 84 DUP5 1287 90 SWAP1 1288 61 PUSH2 0x20ca 128B 56 *JUMP 128C 5B JUMPDEST 128D 90 SWAP1 128E 91 SWAP2 128F 55 SSTORE 1290 50 POP 1291 50 POP 1292 60 PUSH1 0x40 1294 80 DUP1 1295 51 MLOAD 1296 85 DUP6 1297 81 DUP2 1298 52 MSTORE 1299 60 PUSH1 0x20 129B 81 DUP2 129C 01 ADD 129D 85 DUP6 129E 90 SWAP1 129F 52 MSTORE 12A0 60 PUSH1 0x01 12A2 60 PUSH1 0x01 12A4 60 PUSH1 0xa0 12A6 1B SHL 12A7 03 SUB 12A8 80 DUP1 12A9 88 DUP9 12AA 16 AND 12AB 92 SWAP3 12AC 60 PUSH1 0x00 12AE 92 SWAP3 12AF 91 SWAP2 12B0 85 DUP6 12B1 16 AND 12B2 91 SWAP2 12B3 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 12D4 91 SWAP2 12D5 01 ADD 12D6 60 PUSH1 0x40 12D8 51 MLOAD 12D9 80 DUP1 12DA 91 SWAP2 12DB 03 SUB 12DC 90 SWAP1 12DD A4 LOG4 12DE 61 PUSH2 0x05f3 12E1 81 DUP2 12E2 60 PUSH1 0x00 12E4 87 DUP8 12E5 87 DUP8 12E6 87 DUP8 12E7 87 DUP8 12E8 61 PUSH2 0x1858 12EB 56 *JUMP label_12EC: // Incoming call from 0x0F33, returns to 0x0F34 // Incoming call from 0x09F3, returns to 0x09F4 // Inputs[5] // { // @12F0 storage[0x03] // @12F9 stack[-1] // @1326 memory[0x40:0x60] // @1352 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1355 stack[-2] // } 12EC 5B JUMPDEST 12ED 60 PUSH1 0x03 12EF 80 DUP1 12F0 54 SLOAD 12F1 60 PUSH1 0x01 12F3 60 PUSH1 0x01 12F5 60 PUSH1 0xa0 12F7 1B SHL 12F8 03 SUB 12F9 83 DUP4 12FA 81 DUP2 12FB 16 AND 12FC 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 131D 83 DUP4 131E 16 AND 131F 81 DUP2 1320 17 OR 1321 90 SWAP1 1322 93 SWAP4 1323 55 SSTORE 1324 60 PUSH1 0x40 1326 51 MLOAD 1327 91 SWAP2 1328 16 AND 1329 91 SWAP2 132A 90 SWAP1 132B 82 DUP3 132C 90 SWAP1 132D 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 134E 90 SWAP1 134F 60 PUSH1 0x00 1351 90 SWAP1 1352 A3 LOG3 1353 50 POP 1354 50 POP 1355 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1323 storage[0x03] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x03] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) // @1352 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x03] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1356: // Incoming call from 0x0D85, returns to 0x0D86 // Inputs[1] { @1359 stack[-1] } 1356 5B JUMPDEST 1357 60 PUSH1 0x60 1359 81 DUP2 135A 61 PUSH2 0x1396 135D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1357 stack[0] = 0x60 } // Block ends with conditional jump to 0x1396, if stack[-1] label_135E: // Incoming jump from 0x135D, if not stack[-1] // Inputs[2] // { // @1363 memory[0x40:0x60] // @1394 stack[-3] // } 135E 50 POP 135F 50 POP 1360 60 PUSH1 0x40 1362 80 DUP1 1363 51 MLOAD 1364 80 DUP1 1365 82 DUP3 1366 01 ADD 1367 90 SWAP1 1368 91 SWAP2 1369 52 MSTORE 136A 60 PUSH1 0x01 136C 81 DUP2 136D 52 MSTORE 136E 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 138F 60 PUSH1 0x20 1391 82 DUP3 1392 01 ADD 1393 52 MSTORE 1394 90 SWAP1 1395 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1369 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @136D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1393 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @1394 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1396: // Incoming jump from 0x135D, if stack[-1] // Inputs[1] { @1397 stack[-2] } 1396 5B JUMPDEST 1397 81 DUP2 1398 60 PUSH1 0x00 139A 5B JUMPDEST 139B 81 DUP2 139C 15 ISZERO 139D 61 PUSH2 0x13c0 13A0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1397 stack[0] = stack[-2] // @1398 stack[1] = 0x00 // } // Block ends with conditional jump to 0x13c0, if !stack[-2] label_13A1: // Incoming jump from 0x13A0, if not !stack[-2] // Incoming jump from 0x13A0, if not !stack[-2] // Inputs[1] { @13A1 stack[-1] } 13A1 80 DUP1 13A2 61 PUSH2 0x13aa 13A5 81 DUP2 13A6 61 PUSH2 0x21a5 13A9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13A1 stack[0] = stack[-1] // @13A2 stack[1] = 0x13aa // @13A5 stack[2] = stack[-1] // } // Block ends with call to 0x21a5, returns to 0x13AA label_13AA: // Incoming return from call to 0x21A5 at 0x13A9 // Inputs[4] // { // @13AB stack[-1] // @13AB stack[-3] // @13B0 stack[-2] // @13B4 stack[-4] // } 13AA 5B JUMPDEST 13AB 91 SWAP2 13AC 50 POP 13AD 61 PUSH2 0x13b9 13B0 90 SWAP1 13B1 50 POP 13B2 60 PUSH1 0x0a 13B4 83 DUP4 13B5 61 PUSH2 0x20e2 13B8 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @13AB stack[-3] = stack[-1] // @13B0 stack[-2] = 0x13b9 // @13B2 stack[-1] = 0x0a // @13B4 stack[0] = stack[-4] // } // Block ends with call to 0x20e2, returns to 0x13B9 label_13B9: // Incoming return from call to 0x20E2 at 0x13B8 // Inputs[2] // { // @13BA stack[-1] // @13BA stack[-3] // } 13B9 5B JUMPDEST 13BA 91 SWAP2 13BB 50 POP 13BC 61 PUSH2 0x139a 13BF 56 *JUMP // Stack delta = -1 // Outputs[1] { @13BA stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x139a label_13C0: // Incoming jump from 0x13A0, if !stack[-2] // Incoming jump from 0x13A0, if !stack[-2] // Inputs[1] { @13C3 stack[-1] } 13C0 5B JUMPDEST 13C1 60 PUSH1 0x00 13C3 81 DUP2 13C4 67 PUSH8 0xffffffffffffffff 13CD 81 DUP2 13CE 11 GT 13CF 15 ISZERO 13D0 61 PUSH2 0x13e9 13D3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13C1 stack[0] = 0x00 // @13C3 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x13e9, if !(stack[-1] > 0xffffffffffffffff) label_13D4: // Incoming jump from 0x13D3, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @13E8 memory[0x00:0x24] } 13D4 63 PUSH4 0x4e487b71 13D9 60 PUSH1 0xe0 13DB 1B SHL 13DC 60 PUSH1 0x00 13DE 52 MSTORE 13DF 60 PUSH1 0x41 13E1 60 PUSH1 0x04 13E3 52 MSTORE 13E4 60 PUSH1 0x24 13E6 60 PUSH1 0x00 13E8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @13DE memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @13E3 memory[0x04:0x24] = 0x41 // @13E8 revert(memory[0x00:0x24]); // } // Block terminates label_13E9: // Incoming jump from 0x13D3, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @13EC memory[0x40:0x60] // @13ED stack[-1] // } 13E9 5B JUMPDEST 13EA 60 PUSH1 0x40 13EC 51 MLOAD 13ED 90 SWAP1 13EE 80 DUP1 13EF 82 DUP3 13F0 52 MSTORE 13F1 80 DUP1 13F2 60 PUSH1 0x1f 13F4 01 ADD 13F5 60 PUSH1 0x1f 13F7 19 NOT 13F8 16 AND 13F9 60 PUSH1 0x20 13FB 01 ADD 13FC 82 DUP3 13FD 01 ADD 13FE 60 PUSH1 0x40 1400 52 MSTORE 1401 80 DUP1 1402 15 ISZERO 1403 61 PUSH2 0x1413 1406 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @13ED stack[-1] = memory[0x40:0x60] // @13ED stack[0] = stack[-1] // @13F0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1400 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1413, if !stack[-1] label_1407: // Incoming jump from 0x1406, if not !stack[-1] // Inputs[6] // { // @1409 stack[-2] // @140B stack[-1] // @140D msg.data.length // @140F msg.data[msg.data.length:msg.data.length + stack[-1]] // @1415 stack[-3] // @1418 stack[-7] // } 1407 60 PUSH1 0x20 1409 82 DUP3 140A 01 ADD 140B 81 DUP2 140C 80 DUP1 140D 36 CALLDATASIZE 140E 83 DUP4 140F 37 CALLDATACOPY 1410 01 ADD 1411 90 SWAP1 1412 50 POP 1413 5B JUMPDEST 1414 50 POP 1415 90 SWAP1 1416 50 POP 1417 5B JUMPDEST 1418 84 DUP5 1419 15 ISZERO 141A 61 PUSH2 0x14a4 141D 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @140F memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1415 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x14a4, if !stack[-7] label_141E: // Incoming jump from 0x141D, if not !stack[-5] // Incoming jump from 0x141D, if not !stack[-7] // Incoming jump from 0x141D, if not !stack[-7] // Inputs[1] { @1423 stack[-2] } 141E 61 PUSH2 0x1428 1421 60 PUSH1 0x01 1423 83 DUP4 1424 61 PUSH2 0x20f6 1427 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @141E stack[0] = 0x1428 // @1421 stack[1] = 0x01 // @1423 stack[2] = stack[-2] // } // Block ends with call to 0x20f6, returns to 0x1428 label_1428: // Incoming return from call to 0x20F6 at 0x1427 // Inputs[3] // { // @1429 stack[-3] // @1429 stack[-1] // @1430 stack[-6] // } 1428 5B JUMPDEST 1429 91 SWAP2 142A 50 POP 142B 61 PUSH2 0x1435 142E 60 PUSH1 0x0a 1430 86 DUP7 1431 61 PUSH2 0x21e0 1434 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1429 stack[-3] = stack[-1] // @142B stack[-1] = 0x1435 // @142E stack[0] = 0x0a // @1430 stack[1] = stack[-6] // } // Block ends with call to 0x21e0, returns to 0x1435 label_1435: // Incoming return from call to 0x21E0 at 0x1434 // Inputs[1] { @1439 stack[-1] } 1435 5B JUMPDEST 1436 61 PUSH2 0x1440 1439 90 SWAP1 143A 60 PUSH1 0x30 143C 61 PUSH2 0x20ca 143F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1439 stack[0] = stack[-1] // @1439 stack[-1] = 0x1440 // @143A stack[1] = 0x30 // } // Block ends with call to 0x20ca, returns to 0x1440 label_1440: // Incoming return from call to 0x20CA at 0x143F // Inputs[4] // { // @1443 stack[-1] // @1444 stack[-2] // @1445 stack[-3] // @1447 memory[stack[-2]:stack[-2] + 0x20] // } 1440 5B JUMPDEST 1441 60 PUSH1 0xf8 1443 1B SHL 1444 81 DUP2 1445 83 DUP4 1446 81 DUP2 1447 51 MLOAD 1448 81 DUP2 1449 10 LT 144A 61 PUSH2 0x1463 144D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1443 stack[-1] = stack[-1] << 0xf8 // @1444 stack[0] = stack[-2] // @1445 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1463, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_144E: // Incoming jump from 0x144D, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @1462 memory[0x00:0x24] } 144E 63 PUSH4 0x4e487b71 1453 60 PUSH1 0xe0 1455 1B SHL 1456 60 PUSH1 0x00 1458 52 MSTORE 1459 60 PUSH1 0x32 145B 60 PUSH1 0x04 145D 52 MSTORE 145E 60 PUSH1 0x24 1460 60 PUSH1 0x00 1462 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1458 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @145D memory[0x04:0x24] = 0x32 // @1462 revert(memory[0x00:0x24]); // } // Block terminates label_1463: // Incoming jump from 0x144D, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1466 stack[-1] // @1467 stack[-2] // @1468 stack[-3] // @1498 stack[-8] // } 1463 5B JUMPDEST 1464 60 PUSH1 0x20 1466 01 ADD 1467 01 ADD 1468 90 SWAP1 1469 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1489 19 NOT 148A 16 AND 148B 90 SWAP1 148C 81 DUP2 148D 60 PUSH1 0x00 148F 1A BYTE 1490 90 SWAP1 1491 53 MSTORE8 1492 50 POP 1493 61 PUSH2 0x149d 1496 60 PUSH1 0x0a 1498 86 DUP7 1499 61 PUSH2 0x20e2 149C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1491 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @1493 stack[-3] = 0x149d // @1496 stack[-2] = 0x0a // @1498 stack[-1] = stack[-8] // } // Block ends with call to 0x20e2, returns to 0x149D label_149D: // Incoming return from call to 0x20E2 at 0x149C // Inputs[2] // { // @149E stack[-6] // @149E stack[-1] // } 149D 5B JUMPDEST 149E 94 SWAP5 149F 50 POP 14A0 61 PUSH2 0x1417 14A3 56 *JUMP // Stack delta = -1 // Outputs[1] { @149E stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1417 label_14A4: // Incoming jump from 0x141D, if !stack[-5] // Incoming jump from 0x141D, if !stack[-7] // Incoming jump from 0x141D, if !stack[-7] // Inputs[3] // { // @14A5 stack[-6] // @14A5 stack[-1] // @14A6 stack[-5] // } 14A4 5B JUMPDEST 14A5 94 SWAP5 14A6 93 SWAP4 14A7 50 POP 14A8 50 POP 14A9 50 POP 14AA 50 POP 14AB 56 *JUMP // Stack delta = -5 // Outputs[1] { @14A5 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_14AC: // Incoming jump from 0x0E54 // Inputs[1] { @14B5 stack[-4] } 14AC 5B JUMPDEST 14AD 60 PUSH1 0x01 14AF 60 PUSH1 0x01 14B1 60 PUSH1 0xa0 14B3 1B SHL 14B4 03 SUB 14B5 84 DUP5 14B6 16 AND 14B7 61 PUSH2 0x1510 14BA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1510, if stack[-4] & (0x01 << 0xa0) - 0x01 label_14BB: // Incoming jump from 0x14BA, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14BD memory[0x40:0x60] } 14BB 60 PUSH1 0x40 14BD 51 MLOAD 14BE 62 PUSH3 0x461bcd 14C2 60 PUSH1 0xe5 14C4 1B SHL 14C5 81 DUP2 14C6 52 MSTORE 14C7 60 PUSH1 0x20 14C9 60 PUSH1 0x04 14CB 82 DUP3 14CC 01 ADD 14CD 52 MSTORE 14CE 60 PUSH1 0x25 14D0 60 PUSH1 0x24 14D2 82 DUP3 14D3 01 ADD 14D4 52 MSTORE 14D5 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 14F6 60 PUSH1 0x44 14F8 82 DUP3 14F9 01 ADD 14FA 52 MSTORE 14FB 64 PUSH5 0x6472657373 1501 60 PUSH1 0xd8 1503 1B SHL 1504 60 PUSH1 0x64 1506 82 DUP3 1507 01 ADD 1508 52 MSTORE 1509 60 PUSH1 0x84 150B 01 ADD 150C 61 PUSH2 0x03f3 150F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @14C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14CD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14D4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @14FA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 // @1508 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6472657373 << 0xd8 // @150B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x03f3 label_1510: // Incoming jump from 0x14BA, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @1511 msg.sender // @1516 stack[-5] // @1517 stack[-4] // @151B stack[-3] // } 1510 5B JUMPDEST 1511 33 CALLER 1512 61 PUSH2 0x1520 1515 81 DUP2 1516 87 DUP8 1517 87 DUP8 1518 61 PUSH2 0x1253 151B 88 DUP9 151C 61 PUSH2 0x17ff 151F 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1511 stack[0] = msg.sender // @1512 stack[1] = 0x1520 // @1515 stack[2] = msg.sender // @1516 stack[3] = stack[-5] // @1517 stack[4] = stack[-4] // @1518 stack[5] = 0x1253 // @151B stack[6] = stack[-3] // } // Block ends with call to 0x17ff, returns to 0x1253 1520 5B JUMPDEST 1521 60 PUSH1 0x00 1523 84 DUP5 1524 81 DUP2 1525 52 MSTORE 1526 60 PUSH1 0x20 1528 81 DUP2 1529 81 DUP2 152A 52 MSTORE 152B 60 PUSH1 0x40 152D 80 DUP1 152E 83 DUP4 152F 20 SHA3 1530 60 PUSH1 0x01 1532 60 PUSH1 0x01 1534 60 PUSH1 0xa0 1536 1B SHL 1537 03 SUB 1538 8A DUP11 1539 16 AND 153A 84 DUP5 153B 52 MSTORE 153C 90 SWAP1 153D 91 SWAP2 153E 52 MSTORE 153F 90 SWAP1 1540 20 SHA3 1541 54 SLOAD 1542 83 DUP4 1543 81 DUP2 1544 10 LT 1545 15 ISZERO 1546 61 PUSH2 0x15a4 1549 57 *JUMPI 154A 60 PUSH1 0x40 154C 51 MLOAD 154D 62 PUSH3 0x461bcd 1551 60 PUSH1 0xe5 1553 1B SHL 1554 81 DUP2 1555 52 MSTORE 1556 60 PUSH1 0x20 1558 60 PUSH1 0x04 155A 82 DUP3 155B 01 ADD 155C 52 MSTORE 155D 60 PUSH1 0x2a 155F 60 PUSH1 0x24 1561 82 DUP3 1562 01 ADD 1563 52 MSTORE 1564 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 1585 60 PUSH1 0x44 1587 82 DUP3 1588 01 ADD 1589 52 MSTORE 158A 69 PUSH10 0x39103a3930b739b332b9 1595 60 PUSH1 0xb1 1597 1B SHL 1598 60 PUSH1 0x64 159A 82 DUP3 159B 01 ADD 159C 52 MSTORE 159D 60 PUSH1 0x84 159F 01 ADD 15A0 61 PUSH2 0x03f3 15A3 56 *JUMP 15A4 5B JUMPDEST 15A5 60 PUSH1 0x00 15A7 85 DUP6 15A8 81 DUP2 15A9 52 MSTORE 15AA 60 PUSH1 0x20 15AC 81 DUP2 15AD 81 DUP2 15AE 52 MSTORE 15AF 60 PUSH1 0x40 15B1 80 DUP1 15B2 83 DUP4 15B3 20 SHA3 15B4 60 PUSH1 0x01 15B6 60 PUSH1 0x01 15B8 60 PUSH1 0xa0 15BA 1B SHL 15BB 03 SUB 15BC 8B DUP12 15BD 81 DUP2 15BE 16 AND 15BF 85 DUP6 15C0 52 MSTORE 15C1 92 SWAP3 15C2 52 MSTORE 15C3 80 DUP1 15C4 83 DUP4 15C5 20 SHA3 15C6 87 DUP8 15C7 85 DUP6 15C8 03 SUB 15C9 90 SWAP1 15CA 55 SSTORE 15CB 90 SWAP1 15CC 88 DUP9 15CD 16 AND 15CE 82 DUP3 15CF 52 MSTORE 15D0 81 DUP2 15D1 20 SHA3 15D2 80 DUP1 15D3 54 SLOAD 15D4 86 DUP7 15D5 92 SWAP3 15D6 90 SWAP1 15D7 61 PUSH2 0x15e1 15DA 90 SWAP1 15DB 84 DUP5 15DC 90 SWAP1 15DD 61 PUSH2 0x20ca 15E0 56 *JUMP 15E1 5B JUMPDEST 15E2 90 SWAP1 15E3 91 SWAP2 15E4 55 SSTORE 15E5 50 POP 15E6 50 POP 15E7 60 PUSH1 0x40 15E9 80 DUP1 15EA 51 MLOAD 15EB 86 DUP7 15EC 81 DUP2 15ED 52 MSTORE 15EE 60 PUSH1 0x20 15F0 81 DUP2 15F1 01 ADD 15F2 86 DUP7 15F3 90 SWAP1 15F4 52 MSTORE 15F5 60 PUSH1 0x01 15F7 60 PUSH1 0x01 15F9 60 PUSH1 0xa0 15FB 1B SHL 15FC 03 SUB 15FD 80 DUP1 15FE 89 DUP10 15FF 16 AND 1600 92 SWAP3 1601 8A DUP11 1602 82 DUP3 1603 16 AND 1604 92 SWAP3 1605 91 SWAP2 1606 86 DUP7 1607 16 AND 1608 91 SWAP2 1609 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 162A 91 SWAP2 162B 01 ADD 162C 60 PUSH1 0x40 162E 51 MLOAD 162F 80 DUP1 1630 91 SWAP2 1631 03 SUB 1632 90 SWAP1 1633 A4 LOG4 1634 61 PUSH2 0x1641 1637 82 DUP3 1638 88 DUP9 1639 88 DUP9 163A 88 DUP9 163B 88 DUP9 163C 88 DUP9 163D 61 PUSH2 0x1858 1640 56 *JUMP 1641 5B JUMPDEST 1642 50 POP 1643 50 POP 1644 50 POP 1645 50 POP 1646 50 POP 1647 50 POP 1648 50 POP 1649 56 *JUMP 164A 5B JUMPDEST 164B 60 PUSH1 0x01 164D 60 PUSH1 0x01 164F 60 PUSH1 0xa0 1651 1B SHL 1652 03 SUB 1653 84 DUP5 1654 16 AND 1655 3B EXTCODESIZE 1656 15 ISZERO 1657 61 PUSH2 0x11be 165A 57 *JUMPI 165B 60 PUSH1 0x40 165D 51 MLOAD 165E 63 PUSH4 0xbc197c81 1663 60 PUSH1 0xe0 1665 1B SHL 1666 81 DUP2 1667 52 MSTORE 1668 60 PUSH1 0x01 166A 60 PUSH1 0x01 166C 60 PUSH1 0xa0 166E 1B SHL 166F 03 SUB 1670 85 DUP6 1671 16 AND 1672 90 SWAP1 1673 63 PUSH4 0xbc197c81 1678 90 SWAP1 1679 61 PUSH2 0x168e 167C 90 SWAP1 167D 89 DUP10 167E 90 SWAP1 167F 89 DUP10 1680 90 SWAP1 1681 88 DUP9 1682 90 SWAP1 1683 88 DUP9 1684 90 SWAP1 1685 88 DUP9 1686 90 SWAP1 1687 60 PUSH1 0x04 1689 01 ADD 168A 61 PUSH2 0x1fb1 168D 56 *JUMP 168E 5B JUMPDEST 168F 60 PUSH1 0x20 1691 60 PUSH1 0x40 1693 51 MLOAD 1694 80 DUP1 1695 83 DUP4 1696 03 SUB 1697 81 DUP2 1698 60 PUSH1 0x00 169A 87 DUP8 169B 80 DUP1 169C 3B EXTCODESIZE 169D 15 ISZERO 169E 80 DUP1 169F 15 ISZERO 16A0 61 PUSH2 0x16a8 16A3 57 *JUMPI 16A4 60 PUSH1 0x00 16A6 80 DUP1 16A7 FD *REVERT 16A8 5B JUMPDEST 16A9 50 POP 16AA 5A GAS 16AB F1 CALL 16AC 92 SWAP3 16AD 50 POP 16AE 50 POP 16AF 50 POP 16B0 80 DUP1 16B1 15 ISZERO 16B2 61 PUSH2 0x16d8 16B5 57 *JUMPI 16B6 50 POP 16B7 60 PUSH1 0x40 16B9 80 DUP1 16BA 51 MLOAD 16BB 60 PUSH1 0x1f 16BD 3D RETURNDATASIZE 16BE 90 SWAP1 16BF 81 DUP2 16C0 01 ADD 16C1 60 PUSH1 0x1f 16C3 19 NOT 16C4 16 AND 16C5 82 DUP3 16C6 01 ADD 16C7 90 SWAP1 16C8 92 SWAP3 16C9 52 MSTORE 16CA 61 PUSH2 0x16d5 16CD 91 SWAP2 16CE 81 DUP2 16CF 01 ADD 16D0 90 SWAP1 16D1 61 PUSH2 0x1e7b 16D4 56 *JUMP 16D5 5B JUMPDEST 16D6 60 PUSH1 0x01 16D8 5B JUMPDEST 16D9 61 PUSH2 0x178e 16DC 57 *JUMPI 16DD 61 PUSH2 0x16e4 16E0 61 PUSH2 0x2236 16E3 56 *JUMP 16E4 5B JUMPDEST 16E5 80 DUP1 16E6 63 PUSH4 0x08c379a0 16EB 14 EQ 16EC 15 ISZERO 16ED 61 PUSH2 0x171e 16F0 57 *JUMPI 16F1 50 POP 16F2 61 PUSH2 0x16f9 16F5 61 PUSH2 0x224e 16F8 56 *JUMP 16F9 5B JUMPDEST 16FA 80 DUP1 16FB 61 PUSH2 0x1704 16FE 57 *JUMPI 16FF 50 POP 1700 61 PUSH2 0x1720 1703 56 *JUMP 1704 5B JUMPDEST 1705 80 DUP1 1706 60 PUSH1 0x40 1708 51 MLOAD 1709 62 PUSH3 0x461bcd 170D 60 PUSH1 0xe5 170F 1B SHL 1710 81 DUP2 1711 52 MSTORE 1712 60 PUSH1 0x04 1714 01 ADD 1715 61 PUSH2 0x03f3 1718 91 SWAP2 1719 90 SWAP1 171A 61 PUSH2 0x2093 171D 56 *JUMP 171E 5B JUMPDEST 171F 50 POP 1720 5B JUMPDEST 1721 60 PUSH1 0x40 1723 51 MLOAD 1724 62 PUSH3 0x461bcd 1728 60 PUSH1 0xe5 172A 1B SHL 172B 81 DUP2 172C 52 MSTORE 172D 60 PUSH1 0x20 172F 60 PUSH1 0x04 1731 82 DUP3 1732 01 ADD 1733 52 MSTORE 1734 60 PUSH1 0x34 1736 60 PUSH1 0x24 1738 82 DUP3 1739 01 ADD 173A 52 MSTORE 173B 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 175C 60 PUSH1 0x44 175E 82 DUP3 175F 01 ADD 1760 52 MSTORE 1761 7F PUSH32 0x526563656976657220696d706c656d656e746572000000000000000000000000 1782 60 PUSH1 0x64 1784 82 DUP3 1785 01 ADD 1786 52 MSTORE 1787 60 PUSH1 0x84 1789 01 ADD 178A 61 PUSH2 0x03f3 178D 56 *JUMP 178E 5B JUMPDEST 178F 60 PUSH1 0x01 1791 60 PUSH1 0x01 1793 60 PUSH1 0xe0 1795 1B SHL 1796 03 SUB 1797 19 NOT 1798 81 DUP2 1799 16 AND 179A 63 PUSH4 0xbc197c81 179F 60 PUSH1 0xe0 17A1 1B SHL 17A2 14 EQ 17A3 61 PUSH2 0x1641 17A6 57 *JUMPI 17A7 60 PUSH1 0x40 17A9 51 MLOAD 17AA 62 PUSH3 0x461bcd 17AE 60 PUSH1 0xe5 17B0 1B SHL 17B1 81 DUP2 17B2 52 MSTORE 17B3 60 PUSH1 0x20 17B5 60 PUSH1 0x04 17B7 82 DUP3 17B8 01 ADD 17B9 52 MSTORE 17BA 60 PUSH1 0x28 17BC 60 PUSH1 0x24 17BE 82 DUP3 17BF 01 ADD 17C0 52 MSTORE 17C1 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 17E2 60 PUSH1 0x44 17E4 82 DUP3 17E5 01 ADD 17E6 52 MSTORE 17E7 67 PUSH8 0x6420746f6b656e73 17F0 60 PUSH1 0xc0 17F2 1B SHL 17F3 60 PUSH1 0x64 17F5 82 DUP3 17F6 01 ADD 17F7 52 MSTORE 17F8 60 PUSH1 0x84 17FA 01 ADD 17FB 61 PUSH2 0x03f3 17FE 56 *JUMP label_17FF: // Incoming call from 0x151F, returns to 0x1253 // Incoming call from 0x125B, returns to 0x05F3 // Incoming call from 0x1252, returns to 0x1253 // Inputs[5] // { // @1803 memory[0x40:0x60] // @181D msg.data.length // @181F msg.data[msg.data.length:msg.data.length + 0x20] // @1826 stack[-1] // @182B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 17FF 5B JUMPDEST 1800 60 PUSH1 0x40 1802 80 DUP1 1803 51 MLOAD 1804 60 PUSH1 0x01 1806 80 DUP1 1807 82 DUP3 1808 52 MSTORE 1809 81 DUP2 180A 83 DUP4 180B 01 ADD 180C 90 SWAP1 180D 92 SWAP3 180E 52 MSTORE 180F 60 PUSH1 0x60 1811 91 SWAP2 1812 60 PUSH1 0x00 1814 91 SWAP2 1815 90 SWAP1 1816 60 PUSH1 0x20 1818 80 DUP1 1819 83 DUP4 181A 01 ADD 181B 90 SWAP1 181C 80 DUP1 181D 36 CALLDATASIZE 181E 83 DUP4 181F 37 CALLDATACOPY 1820 01 ADD 1821 90 SWAP1 1822 50 POP 1823 50 POP 1824 90 SWAP1 1825 50 POP 1826 82 DUP3 1827 81 DUP2 1828 60 PUSH1 0x00 182A 81 DUP2 182B 51 MLOAD 182C 81 DUP2 182D 10 LT 182E 61 PUSH2 0x1847 1831 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @1808 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @180E memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1811 stack[0] = 0x60 // @181F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[msg.data.length:msg.data.length + 0x20] // @1824 stack[1] = memory[0x40:0x60] // @1826 stack[2] = stack[-1] // @1827 stack[3] = memory[0x40:0x60] // @1828 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1847, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_1832: // Incoming jump from 0x1831, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[1] { @1846 memory[0x00:0x24] } 1832 63 PUSH4 0x4e487b71 1837 60 PUSH1 0xe0 1839 1B SHL 183A 60 PUSH1 0x00 183C 52 MSTORE 183D 60 PUSH1 0x32 183F 60 PUSH1 0x04 1841 52 MSTORE 1842 60 PUSH1 0x24 1844 60 PUSH1 0x00 1846 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @183C memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1841 memory[0x04:0x24] = 0x32 // @1846 revert(memory[0x00:0x24]); // } // Block terminates label_1847: // Incoming jump from 0x1831, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[6] // { // @184A stack[-1] // @184D stack[-2] // @1852 stack[-3] // @1853 stack[-7] // @1853 stack[-4] // @1854 stack[-6] // } 1847 5B JUMPDEST 1848 60 PUSH1 0x20 184A 90 SWAP1 184B 81 DUP2 184C 02 MUL 184D 91 SWAP2 184E 90 SWAP1 184F 91 SWAP2 1850 01 ADD 1851 01 ADD 1852 52 MSTORE 1853 92 SWAP3 1854 91 SWAP2 1855 50 POP 1856 50 POP 1857 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1852 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @1853 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] 1858 5B JUMPDEST 1859 60 PUSH1 0x01 185B 60 PUSH1 0x01 185D 60 PUSH1 0xa0 185F 1B SHL 1860 03 SUB 1861 84 DUP5 1862 16 AND 1863 3B EXTCODESIZE 1864 15 ISZERO 1865 61 PUSH2 0x11be 1868 57 *JUMPI 1869 60 PUSH1 0x40 186B 51 MLOAD 186C 63 PUSH4 0xf23a6e61 1871 60 PUSH1 0xe0 1873 1B SHL 1874 81 DUP2 1875 52 MSTORE 1876 60 PUSH1 0x01 1878 60 PUSH1 0x01 187A 60 PUSH1 0xa0 187C 1B SHL 187D 03 SUB 187E 85 DUP6 187F 16 AND 1880 90 SWAP1 1881 63 PUSH4 0xf23a6e61 1886 90 SWAP1 1887 61 PUSH2 0x189c 188A 90 SWAP1 188B 89 DUP10 188C 90 SWAP1 188D 89 DUP10 188E 90 SWAP1 188F 88 DUP9 1890 90 SWAP1 1891 88 DUP9 1892 90 SWAP1 1893 88 DUP9 1894 90 SWAP1 1895 60 PUSH1 0x04 1897 01 ADD 1898 61 PUSH2 0x200f 189B 56 *JUMP 189C 5B JUMPDEST 189D 60 PUSH1 0x20 189F 60 PUSH1 0x40 18A1 51 MLOAD 18A2 80 DUP1 18A3 83 DUP4 18A4 03 SUB 18A5 81 DUP2 18A6 60 PUSH1 0x00 18A8 87 DUP8 18A9 80 DUP1 18AA 3B EXTCODESIZE 18AB 15 ISZERO 18AC 80 DUP1 18AD 15 ISZERO 18AE 61 PUSH2 0x18b6 18B1 57 *JUMPI 18B2 60 PUSH1 0x00 18B4 80 DUP1 18B5 FD *REVERT 18B6 5B JUMPDEST 18B7 50 POP 18B8 5A GAS 18B9 F1 CALL 18BA 92 SWAP3 18BB 50 POP 18BC 50 POP 18BD 50 POP 18BE 80 DUP1 18BF 15 ISZERO 18C0 61 PUSH2 0x18e6 18C3 57 *JUMPI 18C4 50 POP 18C5 60 PUSH1 0x40 18C7 80 DUP1 18C8 51 MLOAD 18C9 60 PUSH1 0x1f 18CB 3D RETURNDATASIZE 18CC 90 SWAP1 18CD 81 DUP2 18CE 01 ADD 18CF 60 PUSH1 0x1f 18D1 19 NOT 18D2 16 AND 18D3 82 DUP3 18D4 01 ADD 18D5 90 SWAP1 18D6 92 SWAP3 18D7 52 MSTORE 18D8 61 PUSH2 0x18e3 18DB 91 SWAP2 18DC 81 DUP2 18DD 01 ADD 18DE 90 SWAP1 18DF 61 PUSH2 0x1e7b 18E2 56 *JUMP 18E3 5B JUMPDEST 18E4 60 PUSH1 0x01 18E6 5B JUMPDEST 18E7 61 PUSH2 0x18f2 18EA 57 *JUMPI 18EB 61 PUSH2 0x16e4 18EE 61 PUSH2 0x2236 18F1 56 *JUMP 18F2 5B JUMPDEST 18F3 60 PUSH1 0x01 18F5 60 PUSH1 0x01 18F7 60 PUSH1 0xe0 18F9 1B SHL 18FA 03 SUB 18FB 19 NOT 18FC 81 DUP2 18FD 16 AND 18FE 63 PUSH4 0xf23a6e61 1903 60 PUSH1 0xe0 1905 1B SHL 1906 14 EQ 1907 61 PUSH2 0x1641 190A 57 *JUMPI 190B 60 PUSH1 0x40 190D 51 MLOAD 190E 62 PUSH3 0x461bcd 1912 60 PUSH1 0xe5 1914 1B SHL 1915 81 DUP2 1916 52 MSTORE 1917 60 PUSH1 0x20 1919 60 PUSH1 0x04 191B 82 DUP3 191C 01 ADD 191D 52 MSTORE 191E 60 PUSH1 0x28 1920 60 PUSH1 0x24 1922 82 DUP3 1923 01 ADD 1924 52 MSTORE 1925 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 1946 60 PUSH1 0x44 1948 82 DUP3 1949 01 ADD 194A 52 MSTORE 194B 67 PUSH8 0x6420746f6b656e73 1954 60 PUSH1 0xc0 1956 1B SHL 1957 60 PUSH1 0x64 1959 82 DUP3 195A 01 ADD 195B 52 MSTORE 195C 60 PUSH1 0x84 195E 01 ADD 195F 61 PUSH2 0x03f3 1962 56 *JUMP label_1963: // Incoming jump from 0x098A // Inputs[2] // { // @1964 stack[-3] // @1966 storage[stack[-3]] // } 1963 5B JUMPDEST 1964 82 DUP3 1965 80 DUP1 1966 54 SLOAD 1967 61 PUSH2 0x196f 196A 90 SWAP1 196B 61 PUSH2 0x213d 196E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1964 stack[0] = stack[-3] // @196A stack[1] = 0x196f // @196A stack[2] = storage[stack[-3]] // } // Block ends with call to 0x213d, returns to 0x196F label_196F: // Incoming return from call to 0x213D at 0x196E // Inputs[5] // { // @1970 stack[-1] // @1970 stack[-2] // @1978 memory[0x00:0x20] // @1983 stack[-4] // @1984 stack[-3] // } 196F 5B JUMPDEST 1970 90 SWAP1 1971 60 PUSH1 0x00 1973 52 MSTORE 1974 60 PUSH1 0x20 1976 60 PUSH1 0x00 1978 20 SHA3 1979 90 SWAP1 197A 60 PUSH1 0x1f 197C 01 ADD 197D 60 PUSH1 0x20 197F 90 SWAP1 1980 04 DIV 1981 81 DUP2 1982 01 ADD 1983 92 SWAP3 1984 82 DUP3 1985 61 PUSH2 0x1991 1988 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1973 memory[0x00:0x20] = stack[-2] // @1979 stack[-2] = keccak256(memory[0x00:0x20]) // @1983 stack[-1] = stack[-4] // @1983 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1991, if stack[-3] label_1989: // Incoming jump from 0x1988, if not stack[-3] // Inputs[1] { @198B stack[-5] } 1989 60 PUSH1 0x00 198B 85 DUP6 198C 55 SSTORE 198D 61 PUSH2 0x19d7 1990 56 *JUMP // Stack delta = +0 // Outputs[1] { @198C storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x19d7 label_1991: // Incoming jump from 0x1988, if stack[-3] // Inputs[1] { @1992 stack[-3] } 1991 5B JUMPDEST 1992 82 DUP3 1993 60 PUSH1 0x1f 1995 10 LT 1996 61 PUSH2 0x19aa 1999 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19aa, if 0x1f < stack[-3] label_199A: // Incoming jump from 0x1999, if not 0x1f < stack[-3] // Inputs[4] // { // @199A stack[-3] // @19A0 stack[-1] // @19A1 msg.data[stack[-1]:stack[-1] + 0x20] // @19A4 stack[-5] // } 199A 82 DUP3 199B 80 DUP1 199C 01 ADD 199D 60 PUSH1 0xff 199F 19 NOT 19A0 82 DUP3 19A1 35 CALLDATALOAD 19A2 16 AND 19A3 17 OR 19A4 85 DUP6 19A5 55 SSTORE 19A6 61 PUSH2 0x19d7 19A9 56 *JUMP // Stack delta = +0 // Outputs[1] { @19A5 storage[stack[-5]] = (msg.data[stack[-1]:stack[-1] + 0x20] & ~0xff) | stack[-3] + stack[-3] } // Block ends with unconditional jump to 0x19d7 label_19AA: // Incoming jump from 0x1999, if 0x1f < stack[-3] // Inputs[2] // { // @19AB stack[-3] // @19B1 stack[-5] // } 19AA 5B JUMPDEST 19AB 82 DUP3 19AC 80 DUP1 19AD 01 ADD 19AE 60 PUSH1 0x01 19B0 01 ADD 19B1 85 DUP6 19B2 55 SSTORE 19B3 82 DUP3 19B4 15 ISZERO 19B5 61 PUSH2 0x19d7 19B8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @19B2 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x19d7, if !stack[-3] label_19B9: // Incoming jump from 0x19B8, if not !stack[-3] // Inputs[2] // { // @19B9 stack[-3] // @19B9 stack[-1] // } 19B9 91 SWAP2 19BA 82 DUP3 19BB 01 ADD 19BC 5B JUMPDEST 19BD 82 DUP3 19BE 81 DUP2 19BF 11 GT 19C0 15 ISZERO 19C1 61 PUSH2 0x19d7 19C4 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @19B9 stack[-3] = stack[-1] // @19BB stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x19d7, if !(stack[-1] + stack[-3] > stack[-1]) label_19C5: // Incoming jump from 0x19C4, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x19C4, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @19C5 stack[-3] // @19C6 msg.data[stack[-3]:stack[-3] + 0x20] // @19C7 stack[-2] // @19C9 stack[-1] // } 19C5 82 DUP3 19C6 35 CALLDATALOAD 19C7 82 DUP3 19C8 55 SSTORE 19C9 91 SWAP2 19CA 60 PUSH1 0x20 19CC 01 ADD 19CD 91 SWAP2 19CE 90 SWAP1 19CF 60 PUSH1 0x01 19D1 01 ADD 19D2 90 SWAP1 19D3 61 PUSH2 0x19bc 19D6 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @19C8 storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @19CD stack[-3] = 0x20 + stack[-3] // @19D2 stack[-2] = 0x01 + stack[-2] // @19D2 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x19bc label_19D7: // Incoming jump from 0x19B8, if !stack[-3] // Incoming jump from 0x19A9 // Incoming jump from 0x19C4, if !(stack[-1] > stack[-3]) // Incoming jump from 0x1990 // Incoming jump from 0x19C4, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @19DC stack[-4] // @19DD stack[-3] // } 19D7 5B JUMPDEST 19D8 50 POP 19D9 61 PUSH2 0x19e3 19DC 92 SWAP3 19DD 91 SWAP2 19DE 50 POP 19DF 61 PUSH2 0x1a0e 19E2 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @19DC stack[-4] = 0x19e3 // @19DD stack[-3] = stack[-4] // } // Block ends with call to 0x1a0e, returns to 0x19E3 label_19E3: // Incoming jump from 0x1A17, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1A17, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1A0E at 0x19E2 // Inputs[2] // { // @19E5 stack[-2] // @19E5 stack[-3] // } 19E3 5B JUMPDEST 19E4 50 POP 19E5 90 SWAP1 19E6 56 *JUMP // Stack delta = -2 // Outputs[1] { @19E5 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_19E7: // Incoming call from 0x0CCB, returns to 0x0CCC // Inputs[1] { @19EA memory[0x40:0x60] } 19E7 5B JUMPDEST 19E8 60 PUSH1 0x40 19EA 51 MLOAD 19EB 80 DUP1 19EC 60 PUSH1 0x40 19EE 01 ADD 19EF 60 PUSH1 0x40 19F1 52 MSTORE 19F2 80 DUP1 19F3 60 PUSH1 0x02 19F5 90 SWAP1 19F6 5B JUMPDEST 19F7 60 PUSH1 0x60 19F9 81 DUP2 19FA 52 MSTORE 19FB 60 PUSH1 0x20 19FD 01 ADD 19FE 90 SWAP1 19FF 60 PUSH1 0x01 1A01 90 SWAP1 1A02 03 SUB 1A03 90 SWAP1 1A04 81 DUP2 1A05 61 PUSH2 0x19f6 1A08 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @19EA stack[0] = memory[0x40:0x60] // @19F1 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @19FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x60 // @1A03 stack[1] = 0x02 - 0x01 // @1A03 stack[2] = 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x19f6, if 0x02 - 0x01 label_1A09: // Incoming jump from 0x1A08, if not 0x02 - 0x01 // Incoming jump from 0x1A08, if not stack[-2] - 0x01 // Inputs[4] // { // @1A09 stack[-1] // @1A09 stack[-2] // @1A0C stack[-4] // @1A0C stack[-3] // } 1A09 90 SWAP1 1A0A 50 POP 1A0B 50 POP 1A0C 90 SWAP1 1A0D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A0C stack[-4] = stack[-3] } // Block ends with unconditional jump to stack[-4] label_1A0E: // Incoming call from 0x19E2, returns to 0x19E3 // Inputs[2] // { // @1A10 stack[-1] // @1A11 stack[-2] // } 1A0E 5B JUMPDEST 1A0F 5B JUMPDEST 1A10 80 DUP1 1A11 82 DUP3 1A12 11 GT 1A13 15 ISZERO 1A14 61 PUSH2 0x19e3 1A17 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x19e3, if !(stack[-2] > stack[-1]) label_1A18: // Incoming jump from 0x1A17, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1A17, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1A1A stack[-1] } 1A18 60 PUSH1 0x00 1A1A 81 DUP2 1A1B 55 SSTORE 1A1C 60 PUSH1 0x01 1A1E 01 ADD 1A1F 61 PUSH2 0x1a0f 1A22 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1A1B storage[stack[-1]] = 0x00 // @1A1E stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1a0f label_1A23: // Incoming call from 0x1CE2, returns to 0x1CE3 // Incoming call from 0x1BA7, returns to 0x1BA8 // Incoming call from 0x1C84, returns to 0x1C85 // Incoming call from 0x1B85, returns to 0x1B86 // Incoming call from 0x1C92, returns to 0x1C93 // Incoming call from 0x1D1C, returns to 0x1D1D // Incoming call from 0x1BEC, returns to 0x1BED // Incoming call from 0x1E1D, returns to 0x1E1E // Incoming call from 0x1BDE, returns to 0x1BDF // Incoming call from 0x1BB5, returns to 0x1BB6 // Inputs[2] // { // @1A24 stack[-1] // @1A25 msg.data[stack[-1]:stack[-1] + 0x20] // } 1A23 5B JUMPDEST 1A24 80 DUP1 1A25 35 CALLDATALOAD 1A26 60 PUSH1 0x01 1A28 60 PUSH1 0x01 1A2A 60 PUSH1 0xa0 1A2C 1B SHL 1A2D 03 SUB 1A2E 81 DUP2 1A2F 16 AND 1A30 81 DUP2 1A31 14 EQ 1A32 61 PUSH2 0x1a3a 1A35 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A25 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1a3a, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1A36: // Incoming jump from 0x1A35, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1A39 memory[0x00:0x00] } 1A36 60 PUSH1 0x00 1A38 80 DUP1 1A39 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A39 revert(memory[0x00:0x00]); } // Block terminates label_1A3A: // Incoming jump from 0x1A35, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1A3B stack[-1] // @1A3B stack[-3] // @1A3C stack[-2] // } 1A3A 5B JUMPDEST 1A3B 91 SWAP2 1A3C 90 SWAP1 1A3D 50 POP 1A3E 56 *JUMP // Stack delta = -2 // Outputs[1] { @1A3B stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1A3F: // Incoming call from 0x1D62, returns to 0x1D63 // Incoming call from 0x1D87, returns to 0x1D88 // Inputs[2] // { // @1A43 stack[-2] // @1A46 stack[-1] // } 1A3F 5B JUMPDEST 1A40 60 PUSH1 0x00 1A42 80 DUP1 1A43 83 DUP4 1A44 60 PUSH1 0x1f 1A46 84 DUP5 1A47 01 ADD 1A48 12 SLT 1A49 61 PUSH2 0x1a50 1A4C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A40 stack[0] = 0x00 // @1A42 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a50, if stack[-1] + 0x1f i< stack[-2] label_1A4D: // Incoming jump from 0x1A4C, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1A4D stack[-2] // @1A4F memory[stack[-2]:stack[-2] + stack[-2]] // } 1A4D 81 DUP2 1A4E 82 DUP3 1A4F FD *REVERT // Stack delta = +0 // Outputs[1] { @1A4F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1A50: // Incoming jump from 0x1A4C, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1A52 stack[-3] // @1A53 msg.data[stack[-3]:stack[-3] + 0x20] // } 1A50 5B JUMPDEST 1A51 50 POP 1A52 81 DUP2 1A53 35 CALLDATALOAD 1A54 67 PUSH8 0xffffffffffffffff 1A5D 81 DUP2 1A5E 11 GT 1A5F 15 ISZERO 1A60 61 PUSH2 0x1a67 1A63 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A53 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1a67, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1A64: // Incoming jump from 0x1A63, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1A64 stack[-2] // @1A66 memory[stack[-2]:stack[-2] + stack[-2]] // } 1A64 81 DUP2 1A65 82 DUP3 1A66 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A66 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1A67: // Incoming jump from 0x1A63, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @1A6A stack[-3] // @1A6C stack[-2] // @1A6E stack[-4] // @1A71 stack[-1] // } 1A67 5B JUMPDEST 1A68 60 PUSH1 0x20 1A6A 83 DUP4 1A6B 01 ADD 1A6C 91 SWAP2 1A6D 50 POP 1A6E 83 DUP4 1A6F 60 PUSH1 0x20 1A71 82 DUP3 1A72 60 PUSH1 0x05 1A74 1B SHL 1A75 85 DUP6 1A76 01 ADD 1A77 01 ADD 1A78 11 GT 1A79 15 ISZERO 1A7A 61 PUSH2 0x1a82 1A7D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A6C stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x1a82, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_1A7E: // Incoming jump from 0x1A7D, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @1A81 memory[0x00:0x00] } 1A7E 60 PUSH1 0x00 1A80 80 DUP1 1A81 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A81 revert(memory[0x00:0x00]); } // Block terminates label_1A82: // Incoming jump from 0x1A7D, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[5] // { // @1A83 stack[-1] // @1A83 stack[-4] // @1A85 stack[-2] // @1A85 stack[-5] // @1A86 stack[-3] // } 1A82 5B JUMPDEST 1A83 92 SWAP3 1A84 50 POP 1A85 92 SWAP3 1A86 90 SWAP1 1A87 50 POP 1A88 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1A83 stack[-4] = stack[-1] // @1A85 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_1A89: // Incoming call from 0x1E54, returns to 0x1E55 // Incoming call from 0x1C14, returns to 0x1C15 // Incoming call from 0x1C35, returns to 0x1C36 // Inputs[2] // { // @1A8C stack[-2] // @1A8F stack[-1] // } 1A89 5B JUMPDEST 1A8A 60 PUSH1 0x00 1A8C 82 DUP3 1A8D 60 PUSH1 0x1f 1A8F 83 DUP4 1A90 01 ADD 1A91 12 SLT 1A92 61 PUSH2 0x1a99 1A95 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A8A stack[0] = 0x00 } // Block ends with conditional jump to 0x1a99, if stack[-1] + 0x1f i< stack[-2] label_1A96: // Incoming jump from 0x1A95, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1A96 stack[-1] // @1A98 memory[stack[-1]:stack[-1] + stack[-1]] // } 1A96 80 DUP1 1A97 81 DUP2 1A98 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A98 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1A99: // Incoming jump from 0x1A95, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1A9A stack[-2] // @1A9B msg.data[stack[-2]:stack[-2] + 0x20] // } 1A99 5B JUMPDEST 1A9A 81 DUP2 1A9B 35 CALLDATALOAD 1A9C 60 PUSH1 0x20 1A9E 61 PUSH2 0x1aa6 1AA1 82 DUP3 1AA2 61 PUSH2 0x20a6 1AA5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A9B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1A9C stack[1] = 0x20 // @1A9E stack[2] = 0x1aa6 // @1AA1 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x20a6, returns to 0x1AA6 label_1AA6: // Incoming return from call to 0x20A6 at 0x1AA5 // Inputs[2] // { // @1AA9 memory[0x40:0x60] // @1AAD stack[-1] // } 1AA6 5B JUMPDEST 1AA7 60 PUSH1 0x40 1AA9 51 MLOAD 1AAA 61 PUSH2 0x1ab3 1AAD 82 DUP3 1AAE 82 DUP3 1AAF 61 PUSH2 0x2178 1AB2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1AA9 stack[0] = memory[0x40:0x60] // @1AAA stack[1] = 0x1ab3 // @1AAD stack[2] = stack[-1] // @1AAE stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2178, returns to 0x1AB3 label_1AB3: // Incoming return from call to 0x2178 at 0x1AB2 // Inputs[6] // { // @1AB4 stack[-4] // @1AB5 stack[-1] // @1AB7 stack[-3] // @1ABA stack[-2] // @1ABC stack[-6] // @1AC8 stack[-7] // } 1AB3 5B JUMPDEST 1AB4 83 DUP4 1AB5 81 DUP2 1AB6 52 MSTORE 1AB7 82 DUP3 1AB8 81 DUP2 1AB9 01 ADD 1ABA 91 SWAP2 1ABB 50 POP 1ABC 85 DUP6 1ABD 83 DUP4 1ABE 01 ADD 1ABF 60 PUSH1 0x05 1AC1 85 DUP6 1AC2 90 SWAP1 1AC3 1B SHL 1AC4 87 DUP8 1AC5 01 ADD 1AC6 84 DUP5 1AC7 01 ADD 1AC8 88 DUP9 1AC9 10 LT 1ACA 15 ISZERO 1ACB 61 PUSH2 0x1ad2 1ACE 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1AB6 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1ABA stack[-2] = stack[-1] + stack[-3] // @1ABE stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1ad2, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_1ACF: // Incoming jump from 0x1ACE, if not !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1ACF stack[-6] // @1AD1 memory[stack[-6]:stack[-6] + stack[-6]] // } 1ACF 85 DUP6 1AD0 86 DUP7 1AD1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AD1 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_1AD2: // Incoming jump from 0x1ACE, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1AD3 stack[-6] // @1AD5 stack[-5] // } 1AD2 5B JUMPDEST 1AD3 85 DUP6 1AD4 5B JUMPDEST 1AD5 85 DUP6 1AD6 81 DUP2 1AD7 10 LT 1AD8 15 ISZERO 1AD9 61 PUSH2 0x1af0 1ADC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AD3 stack[0] = stack[-6] } // Block ends with conditional jump to 0x1af0, if !(stack[-6] < stack[-5]) label_1ADD: // Incoming jump from 0x1ADC, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x1ADC, if not !(stack[-6] < stack[-5]) // Inputs[5] // { // @1ADD stack[-2] // @1ADE msg.data[stack[-2]:stack[-2] + 0x20] // @1ADF stack[-4] // @1AE1 stack[-1] // @1AE2 stack[-5] // } 1ADD 81 DUP2 1ADE 35 CALLDATALOAD 1ADF 84 DUP5 1AE0 52 MSTORE 1AE1 92 SWAP3 1AE2 84 DUP5 1AE3 01 ADD 1AE4 92 SWAP3 1AE5 90 SWAP1 1AE6 84 DUP5 1AE7 01 ADD 1AE8 90 SWAP1 1AE9 60 PUSH1 0x01 1AEB 01 ADD 1AEC 61 PUSH2 0x1ad4 1AEF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1AE0 memory[stack[-4]:stack[-4] + 0x20] = msg.data[stack[-2]:stack[-2] + 0x20] // @1AE4 stack[-4] = stack[-5] + stack[-4] // @1AE8 stack[-2] = stack[-5] + stack[-2] // @1AEB stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1ad4 label_1AF0: // Incoming jump from 0x1ADC, if !(stack[-1] < stack[-6]) // Incoming jump from 0x1ADC, if !(stack[-6] < stack[-5]) // Inputs[4] // { // @1AF2 stack[-2] // @1AF2 stack[-3] // @1AF3 stack[-10] // @1AF4 stack[-9] // } 1AF0 5B JUMPDEST 1AF1 50 POP 1AF2 90 SWAP1 1AF3 97 SWAP8 1AF4 96 SWAP7 1AF5 50 POP 1AF6 50 POP 1AF7 50 POP 1AF8 50 POP 1AF9 50 POP 1AFA 50 POP 1AFB 50 POP 1AFC 56 *JUMP // Stack delta = -9 // Outputs[1] { @1AF3 stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_1AFD: // Incoming call from 0x1CC7, returns to 0x1C58 // Incoming call from 0x1C57, returns to 0x1C58 // Inputs[2] // { // @1B00 stack[-2] // @1B03 stack[-1] // } 1AFD 5B JUMPDEST 1AFE 60 PUSH1 0x00 1B00 82 DUP3 1B01 60 PUSH1 0x1f 1B03 83 DUP4 1B04 01 ADD 1B05 12 SLT 1B06 61 PUSH2 0x1b0d 1B09 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AFE stack[0] = 0x00 } // Block ends with conditional jump to 0x1b0d, if stack[-1] + 0x1f i< stack[-2] label_1B0A: // Incoming jump from 0x1B09, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1B0A stack[-1] // @1B0C memory[stack[-1]:stack[-1] + stack[-1]] // } 1B0A 80 DUP1 1B0B 81 DUP2 1B0C FD *REVERT // Stack delta = +0 // Outputs[1] { @1B0C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1B0D: // Incoming jump from 0x1B09, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1B0E stack[-2] // @1B0F msg.data[stack[-2]:stack[-2] + 0x20] // } 1B0D 5B JUMPDEST 1B0E 81 DUP2 1B0F 35 CALLDATALOAD 1B10 67 PUSH8 0xffffffffffffffff 1B19 81 DUP2 1B1A 11 GT 1B1B 15 ISZERO 1B1C 61 PUSH2 0x1b27 1B1F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B0F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1b27, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1B20: // Incoming jump from 0x1B1F, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 1B20 61 PUSH2 0x1b27 1B23 61 PUSH2 0x2220 1B26 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B20 stack[0] = 0x1b27 } // Block ends with unconditional jump to 0x2220 label_1B27: // Incoming jump from 0x1B1F, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1B2A memory[0x40:0x60] // @1B30 stack[-1] // } 1B27 5B JUMPDEST 1B28 60 PUSH1 0x40 1B2A 51 MLOAD 1B2B 61 PUSH2 0x1b3e 1B2E 60 PUSH1 0x1f 1B30 83 DUP4 1B31 01 ADD 1B32 60 PUSH1 0x1f 1B34 19 NOT 1B35 16 AND 1B36 60 PUSH1 0x20 1B38 01 ADD 1B39 82 DUP3 1B3A 61 PUSH2 0x2178 1B3D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B2A stack[0] = memory[0x40:0x60] // @1B2B stack[1] = 0x1b3e // @1B38 stack[2] = 0x20 + (~0x1f & stack[-1] + 0x1f) // @1B39 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2178, returns to 0x1B3E label_1B3E: // Incoming return from call to 0x2178 at 0x1B3D // Inputs[4] // { // @1B3F stack[-2] // @1B40 stack[-1] // @1B42 stack[-5] // @1B46 stack[-4] // } 1B3E 5B JUMPDEST 1B3F 81 DUP2 1B40 81 DUP2 1B41 52 MSTORE 1B42 84 DUP5 1B43 60 PUSH1 0x20 1B45 83 DUP4 1B46 86 DUP7 1B47 01 ADD 1B48 01 ADD 1B49 11 GT 1B4A 15 ISZERO 1B4B 61 PUSH2 0x1b52 1B4E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B41 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x1b52, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_1B4F: // Incoming jump from 0x1B4E, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[2] // { // @1B4F stack[-3] // @1B51 memory[stack[-3]:stack[-3] + stack[-3]] // } 1B4F 82 DUP3 1B50 83 DUP4 1B51 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B51 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1B52: // Incoming jump from 0x1B4E, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[7] // { // @1B53 stack[-2] // @1B56 stack[-4] // @1B5A stack[-1] // @1B5C msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @1B63 stack[-3] // @1B67 stack[-6] // @1B68 stack[-5] // } 1B52 5B JUMPDEST 1B53 81 DUP2 1B54 60 PUSH1 0x20 1B56 85 DUP6 1B57 01 ADD 1B58 60 PUSH1 0x20 1B5A 83 DUP4 1B5B 01 ADD 1B5C 37 CALLDATACOPY 1B5D 90 SWAP1 1B5E 81 DUP2 1B5F 01 ADD 1B60 60 PUSH1 0x20 1B62 01 ADD 1B63 91 SWAP2 1B64 90 SWAP1 1B65 91 SWAP2 1B66 52 MSTORE 1B67 92 SWAP3 1B68 91 SWAP2 1B69 50 POP 1B6A 50 POP 1B6B 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1B5C memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @1B66 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] = stack[-3] // @1B67 stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_1B6C: // Incoming call from 0x0C71, returns to 0x0C72 // Incoming call from 0x0373, returns to 0x0374 // Inputs[2] // { // @1B71 stack[-1] // @1B72 stack[-2] // } 1B6C 5B JUMPDEST 1B6D 60 PUSH1 0x00 1B6F 60 PUSH1 0x20 1B71 82 DUP3 1B72 84 DUP5 1B73 03 SUB 1B74 12 SLT 1B75 15 ISZERO 1B76 61 PUSH2 0x1b7d 1B79 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B6D stack[0] = 0x00 } // Block ends with conditional jump to 0x1b7d, if !(stack[-2] - stack[-1] i< 0x20) label_1B7A: // Incoming jump from 0x1B79, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1B7A stack[-1] // @1B7C memory[stack[-1]:stack[-1] + stack[-1]] // } 1B7A 80 DUP1 1B7B 81 DUP2 1B7C FD *REVERT // Stack delta = +0 // Outputs[1] { @1B7C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1B7D: // Incoming jump from 0x1B79, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1B81 stack[-2] } 1B7D 5B JUMPDEST 1B7E 61 PUSH2 0x1b86 1B81 82 DUP3 1B82 61 PUSH2 0x1a23 1B85 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1B7E stack[0] = 0x1b86 // @1B81 stack[1] = stack[-2] // } // Block ends with call to 0x1a23, returns to 0x1B86 label_1B86: // Incoming return from call to 0x22D8 at 0x1E7A // Incoming return from call to 0x1F56 at 0x20A5 // Incoming return from call to 0x1F1C at 0x2064 // Incoming return from call to 0x1A23 at 0x1B85 // Inputs[3] // { // @1B87 stack[-5] // @1B87 stack[-1] // @1B88 stack[-4] // } 1B86 5B JUMPDEST 1B87 93 SWAP4 1B88 92 SWAP3 1B89 50 POP 1B8A 50 POP 1B8B 50 POP 1B8C 56 *JUMP // Stack delta = -4 // Outputs[1] { @1B87 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1B8D: // Incoming call from 0x0311, returns to 0x0312 // Inputs[2] // { // @1B93 stack[-1] // @1B94 stack[-2] // } 1B8D 5B JUMPDEST 1B8E 60 PUSH1 0x00 1B90 80 DUP1 1B91 60 PUSH1 0x40 1B93 83 DUP4 1B94 85 DUP6 1B95 03 SUB 1B96 12 SLT 1B97 15 ISZERO 1B98 61 PUSH2 0x1b9f 1B9B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1B8E stack[0] = 0x00 // @1B90 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1b9f, if !(stack[-2] - stack[-1] i< 0x40) label_1B9C: // Incoming jump from 0x1B9B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1B9C stack[-1] // @1B9E memory[stack[-1]:stack[-1] + stack[-1]] // } 1B9C 80 DUP1 1B9D 81 DUP2 1B9E FD *REVERT // Stack delta = +0 // Outputs[1] { @1B9E revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1B9F: // Incoming jump from 0x1B9B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1BA3 stack[-3] } 1B9F 5B JUMPDEST 1BA0 61 PUSH2 0x1ba8 1BA3 83 DUP4 1BA4 61 PUSH2 0x1a23 1BA7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BA0 stack[0] = 0x1ba8 // @1BA3 stack[1] = stack[-3] // } // Block ends with call to 0x1a23, returns to 0x1BA8 label_1BA8: // Incoming return from call to 0x1A23 at 0x1BA7 // Inputs[3] // { // @1BA9 stack[-3] // @1BA9 stack[-1] // @1BB0 stack[-4] // } 1BA8 5B JUMPDEST 1BA9 91 SWAP2 1BAA 50 POP 1BAB 61 PUSH2 0x1bb6 1BAE 60 PUSH1 0x20 1BB0 84 DUP5 1BB1 01 ADD 1BB2 61 PUSH2 0x1a23 1BB5 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1BA9 stack[-3] = stack[-1] // @1BAB stack[-1] = 0x1bb6 // @1BB1 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1a23, returns to 0x1BB6 label_1BB6: // Incoming return from call to 0x1A23 at 0x1BB5 // Inputs[6] // { // @1BB7 stack[-2] // @1BB7 stack[-1] // @1BB9 stack[-5] // @1BBB stack[-3] // @1BBB stack[-6] // @1BBC stack[-4] // } 1BB6 5B JUMPDEST 1BB7 90 SWAP1 1BB8 50 POP 1BB9 92 SWAP3 1BBA 50 POP 1BBB 92 SWAP3 1BBC 90 SWAP1 1BBD 50 POP 1BBE 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1BB9 stack[-5] = stack[-1] // @1BBB stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1BBF: // Incoming jump from 0x0221 // Inputs[2] // { // @1BCA stack[-1] // @1BCB stack[-2] // } 1BBF 5B JUMPDEST 1BC0 60 PUSH1 0x00 1BC2 80 DUP1 1BC3 60 PUSH1 0x00 1BC5 80 DUP1 1BC6 60 PUSH1 0x00 1BC8 60 PUSH1 0xa0 1BCA 86 DUP7 1BCB 88 DUP9 1BCC 03 SUB 1BCD 12 SLT 1BCE 15 ISZERO 1BCF 61 PUSH2 0x1bd6 1BD2 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1BC0 stack[0] = 0x00 // @1BC2 stack[1] = 0x00 // @1BC3 stack[2] = 0x00 // @1BC5 stack[3] = 0x00 // @1BC6 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1bd6, if !(stack[-2] - stack[-1] i< 0xa0) label_1BD3: // Incoming jump from 0x1BD2, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1BD3 stack[-1] // @1BD5 memory[stack[-1]:stack[-1] + stack[-1]] // } 1BD3 80 DUP1 1BD4 81 DUP2 1BD5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BD5 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1BD6: // Incoming jump from 0x1BD2, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1BDA stack[-6] } 1BD6 5B JUMPDEST 1BD7 61 PUSH2 0x1bdf 1BDA 86 DUP7 1BDB 61 PUSH2 0x1a23 1BDE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1BD7 stack[0] = 0x1bdf // @1BDA stack[1] = stack[-6] // } // Block ends with call to 0x1a23, returns to 0x1BDF label_1BDF: // Incoming return from call to 0x1A23 at 0x1BDE // Inputs[3] // { // @1BE0 stack[-6] // @1BE0 stack[-1] // @1BE7 stack[-7] // } 1BDF 5B JUMPDEST 1BE0 94 SWAP5 1BE1 50 POP 1BE2 61 PUSH2 0x1bed 1BE5 60 PUSH1 0x20 1BE7 87 DUP8 1BE8 01 ADD 1BE9 61 PUSH2 0x1a23 1BEC 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1BE0 stack[-6] = stack[-1] // @1BE2 stack[-1] = 0x1bed // @1BE8 stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1a23, returns to 0x1BED label_1BED: // Incoming return from call to 0x1A23 at 0x1BEC // Inputs[4] // { // @1BEE stack[-5] // @1BEE stack[-1] // @1BF2 stack[-7] // @1BF4 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 1BED 5B JUMPDEST 1BEE 93 SWAP4 1BEF 50 POP 1BF0 60 PUSH1 0x40 1BF2 86 DUP7 1BF3 01 ADD 1BF4 35 CALLDATALOAD 1BF5 67 PUSH8 0xffffffffffffffff 1BFE 80 DUP1 1BFF 82 DUP3 1C00 11 GT 1C01 15 ISZERO 1C02 61 PUSH2 0x1c09 1C05 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1BEE stack[-5] = stack[-1] // @1BF4 stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1BF5 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1c09, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) label_1C06: // Incoming jump from 0x1C05, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1C06 stack[-3] // @1C08 memory[stack[-3]:stack[-3] + stack[-3]] // } 1C06 82 DUP3 1C07 83 DUP4 1C08 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C08 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1C09: // Incoming jump from 0x1C05, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1C0D stack[-9] // @1C0E stack[-2] // @1C0F stack[-8] // } 1C09 5B JUMPDEST 1C0A 61 PUSH2 0x1c15 1C0D 89 DUP10 1C0E 83 DUP4 1C0F 8A DUP11 1C10 01 ADD 1C11 61 PUSH2 0x1a89 1C14 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C0A stack[0] = 0x1c15 // @1C0D stack[1] = stack[-9] // @1C10 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x1a89, returns to 0x1C15 label_1C15: // Incoming return from call to 0x1A89 at 0x1C14 // Inputs[6] // { // @1C16 stack[-1] // @1C16 stack[-6] // @1C1A stack[-9] // @1C1C msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @1C1D stack[-3] // @1C1F stack[-2] // } 1C15 5B JUMPDEST 1C16 94 SWAP5 1C17 50 POP 1C18 60 PUSH1 0x60 1C1A 88 DUP9 1C1B 01 ADD 1C1C 35 CALLDATALOAD 1C1D 91 SWAP2 1C1E 50 POP 1C1F 80 DUP1 1C20 82 DUP3 1C21 11 GT 1C22 15 ISZERO 1C23 61 PUSH2 0x1c2a 1C26 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1C16 stack[-6] = stack[-1] // @1C1D stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1c2a, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_1C27: // Incoming jump from 0x1C26, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[2] // { // @1C27 stack[-3] // @1C29 memory[stack[-3]:stack[-3] + stack[-3]] // } 1C27 82 DUP3 1C28 83 DUP4 1C29 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C29 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1C2A: // Incoming jump from 0x1C26, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @1C2E stack[-9] // @1C2F stack[-2] // @1C30 stack[-8] // } 1C2A 5B JUMPDEST 1C2B 61 PUSH2 0x1c36 1C2E 89 DUP10 1C2F 83 DUP4 1C30 8A DUP11 1C31 01 ADD 1C32 61 PUSH2 0x1a89 1C35 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C2B stack[0] = 0x1c36 // @1C2E stack[1] = stack[-9] // @1C31 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x1a89, returns to 0x1C36 label_1C36: // Incoming return from call to 0x1A89 at 0x1C35 // Inputs[6] // { // @1C37 stack[-5] // @1C37 stack[-1] // @1C3B stack[-9] // @1C3D msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @1C3E stack[-3] // @1C40 stack[-2] // } 1C36 5B JUMPDEST 1C37 93 SWAP4 1C38 50 POP 1C39 60 PUSH1 0x80 1C3B 88 DUP9 1C3C 01 ADD 1C3D 35 CALLDATALOAD 1C3E 91 SWAP2 1C3F 50 POP 1C40 80 DUP1 1C41 82 DUP3 1C42 11 GT 1C43 15 ISZERO 1C44 61 PUSH2 0x1c4b 1C47 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1C37 stack[-5] = stack[-1] // @1C3E stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1c4b, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_1C48: // Incoming jump from 0x1C47, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[2] // { // @1C48 stack[-3] // @1C4A memory[stack[-3]:stack[-3] + stack[-3]] // } 1C48 82 DUP3 1C49 83 DUP4 1C4A FD *REVERT // Stack delta = +0 // Outputs[1] { @1C4A revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1C4B: // Incoming jump from 0x1C47, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @1C50 stack[-9] // @1C51 stack[-2] // @1C52 stack[-8] // } 1C4B 5B JUMPDEST 1C4C 50 POP 1C4D 61 PUSH2 0x1c58 1C50 88 DUP9 1C51 82 DUP3 1C52 89 DUP10 1C53 01 ADD 1C54 61 PUSH2 0x1afd 1C57 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1C4D stack[-1] = 0x1c58 // @1C50 stack[0] = stack[-9] // @1C53 stack[1] = stack[-8] + stack[-2] // } // Block ends with call to 0x1afd, returns to 0x1C58 label_1C58: // Incoming return from call to 0x1AFD at 0x1CC7 // Incoming return from call to 0x1AFD at 0x1C57 // Inputs[9] // { // @1C59 stack[-3] // @1C59 stack[-1] // @1C5C stack[-6] // @1C5D stack[-9] // @1C5F stack[-7] // @1C5F stack[-4] // @1C60 stack[-10] // @1C61 stack[-5] // @1C62 stack[-8] // } 1C58 5B JUMPDEST 1C59 91 SWAP2 1C5A 50 POP 1C5B 50 POP 1C5C 92 SWAP3 1C5D 95 SWAP6 1C5E 50 POP 1C5F 92 SWAP3 1C60 95 SWAP6 1C61 90 SWAP1 1C62 93 SWAP4 1C63 50 POP 1C64 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @1C5C stack[-6] = stack[-1] // @1C5D stack[-9] = stack[-6] // @1C5F stack[-7] = stack[-4] // @1C60 stack[-10] = stack[-7] // @1C62 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_1C65: // Incoming call from 0x0360, returns to 0x0361 // Inputs[2] // { // @1C70 stack[-1] // @1C71 stack[-2] // } 1C65 5B JUMPDEST 1C66 60 PUSH1 0x00 1C68 80 DUP1 1C69 60 PUSH1 0x00 1C6B 80 DUP1 1C6C 60 PUSH1 0x00 1C6E 60 PUSH1 0xa0 1C70 86 DUP7 1C71 88 DUP9 1C72 03 SUB 1C73 12 SLT 1C74 15 ISZERO 1C75 61 PUSH2 0x1c7c 1C78 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1C66 stack[0] = 0x00 // @1C68 stack[1] = 0x00 // @1C69 stack[2] = 0x00 // @1C6B stack[3] = 0x00 // @1C6C stack[4] = 0x00 // } // Block ends with conditional jump to 0x1c7c, if !(stack[-2] - stack[-1] i< 0xa0) label_1C79: // Incoming jump from 0x1C78, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1C79 stack[-1] // @1C7B memory[stack[-1]:stack[-1] + stack[-1]] // } 1C79 80 DUP1 1C7A 81 DUP2 1C7B FD *REVERT // Stack delta = +0 // Outputs[1] { @1C7B revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1C7C: // Incoming jump from 0x1C78, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1C80 stack[-6] } 1C7C 5B JUMPDEST 1C7D 61 PUSH2 0x1c85 1C80 86 DUP7 1C81 61 PUSH2 0x1a23 1C84 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1C7D stack[0] = 0x1c85 // @1C80 stack[1] = stack[-6] // } // Block ends with call to 0x1a23, returns to 0x1C85 label_1C85: // Incoming return from call to 0x1A23 at 0x1C84 // Inputs[3] // { // @1C86 stack[-6] // @1C86 stack[-1] // @1C8D stack[-7] // } 1C85 5B JUMPDEST 1C86 94 SWAP5 1C87 50 POP 1C88 61 PUSH2 0x1c93 1C8B 60 PUSH1 0x20 1C8D 87 DUP8 1C8E 01 ADD 1C8F 61 PUSH2 0x1a23 1C92 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1C86 stack[-6] = stack[-1] // @1C88 stack[-1] = 0x1c93 // @1C8E stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1a23, returns to 0x1C93 label_1C93: // Incoming return from call to 0x1A23 at 0x1C92 // Inputs[8] // { // @1C94 stack[-5] // @1C94 stack[-1] // @1C98 stack[-7] // @1C9A msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1C9B stack[-4] // @1CA1 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @1CA2 stack[-3] // @1CA8 msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 1C93 5B JUMPDEST 1C94 93 SWAP4 1C95 50 POP 1C96 60 PUSH1 0x40 1C98 86 DUP7 1C99 01 ADD 1C9A 35 CALLDATALOAD 1C9B 92 SWAP3 1C9C 50 POP 1C9D 60 PUSH1 0x60 1C9F 86 DUP7 1CA0 01 ADD 1CA1 35 CALLDATALOAD 1CA2 91 SWAP2 1CA3 50 POP 1CA4 60 PUSH1 0x80 1CA6 86 DUP7 1CA7 01 ADD 1CA8 35 CALLDATALOAD 1CA9 67 PUSH8 0xffffffffffffffff 1CB2 81 DUP2 1CB3 11 GT 1CB4 15 ISZERO 1CB5 61 PUSH2 0x1cbc 1CB8 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1C94 stack[-5] = stack[-1] // @1C9B stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1CA2 stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @1CA8 stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1cbc, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) label_1CB9: // Incoming jump from 0x1CB8, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1CB9 stack[-2] // @1CBB memory[stack[-2]:stack[-2] + stack[-2]] // } 1CB9 81 DUP2 1CBA 82 DUP3 1CBB FD *REVERT // Stack delta = +0 // Outputs[1] { @1CBB revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1CBC: // Incoming jump from 0x1CB8, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1CC0 stack[-8] // @1CC1 stack[-1] // @1CC2 stack[-7] // } 1CBC 5B JUMPDEST 1CBD 61 PUSH2 0x1c58 1CC0 88 DUP9 1CC1 82 DUP3 1CC2 89 DUP10 1CC3 01 ADD 1CC4 61 PUSH2 0x1afd 1CC7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1CBD stack[0] = 0x1c58 // @1CC0 stack[1] = stack[-8] // @1CC3 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x1afd, returns to 0x1C58 label_1CC8: // Incoming call from 0x02D8, returns to 0x02D9 // Inputs[2] // { // @1CCE stack[-1] // @1CCF stack[-2] // } 1CC8 5B JUMPDEST 1CC9 60 PUSH1 0x00 1CCB 80 DUP1 1CCC 60 PUSH1 0x40 1CCE 83 DUP4 1CCF 85 DUP6 1CD0 03 SUB 1CD1 12 SLT 1CD2 15 ISZERO 1CD3 61 PUSH2 0x1cda 1CD6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1CC9 stack[0] = 0x00 // @1CCB stack[1] = 0x00 // } // Block ends with conditional jump to 0x1cda, if !(stack[-2] - stack[-1] i< 0x40) label_1CD7: // Incoming jump from 0x1CD6, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1CD7 stack[-2] // @1CD9 memory[stack[-2]:stack[-2] + stack[-2]] // } 1CD7 81 DUP2 1CD8 82 DUP3 1CD9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CD9 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1CDA: // Incoming jump from 0x1CD6, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1CDE stack[-3] } 1CDA 5B JUMPDEST 1CDB 61 PUSH2 0x1ce3 1CDE 83 DUP4 1CDF 61 PUSH2 0x1a23 1CE2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1CDB stack[0] = 0x1ce3 // @1CDE stack[1] = stack[-3] // } // Block ends with call to 0x1a23, returns to 0x1CE3 label_1CE3: // Incoming return from call to 0x1A23 at 0x1CE2 // Inputs[4] // { // @1CE4 stack[-1] // @1CE4 stack[-3] // @1CE8 stack[-4] // @1CEA msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1CE3 5B JUMPDEST 1CE4 91 SWAP2 1CE5 50 POP 1CE6 60 PUSH1 0x20 1CE8 83 DUP4 1CE9 01 ADD 1CEA 35 CALLDATALOAD 1CEB 80 DUP1 1CEC 15 ISZERO 1CED 15 ISZERO 1CEE 81 DUP2 1CEF 14 EQ 1CF0 61 PUSH2 0x1cf7 1CF3 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1CE4 stack[-3] = stack[-1] // @1CEA stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1cf7, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1CF4: // Incoming jump from 0x1CF3, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @1CF4 stack[-2] // @1CF6 memory[stack[-2]:stack[-2] + stack[-2]] // } 1CF4 81 DUP2 1CF5 82 DUP3 1CF6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CF6 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1CF7: // Incoming jump from 0x1CF3, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1CF8 stack[-1] // @1CF9 stack[-2] // @1CFC stack[-5] // @1CFE stack[-6] // @1CFE stack[-3] // @1CFF stack[-4] // } 1CF7 5B JUMPDEST 1CF8 80 DUP1 1CF9 91 SWAP2 1CFA 50 POP 1CFB 50 POP 1CFC 92 SWAP3 1CFD 50 POP 1CFE 92 SWAP3 1CFF 90 SWAP1 1D00 50 POP 1D01 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1CFC stack[-5] = stack[-1] // @1CFE stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1D02: // Incoming call from 0x019E, returns to 0x019F // Incoming call from 0x0256, returns to 0x0257 // Inputs[2] // { // @1D08 stack[-1] // @1D09 stack[-2] // } 1D02 5B JUMPDEST 1D03 60 PUSH1 0x00 1D05 80 DUP1 1D06 60 PUSH1 0x40 1D08 83 DUP4 1D09 85 DUP6 1D0A 03 SUB 1D0B 12 SLT 1D0C 15 ISZERO 1D0D 61 PUSH2 0x1d14 1D10 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D03 stack[0] = 0x00 // @1D05 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d14, if !(stack[-2] - stack[-1] i< 0x40) label_1D11: // Incoming jump from 0x1D10, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D11 stack[-2] // @1D13 memory[stack[-2]:stack[-2] + stack[-2]] // } 1D11 81 DUP2 1D12 82 DUP3 1D13 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D13 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1D14: // Incoming jump from 0x1D10, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D18 stack[-3] } 1D14 5B JUMPDEST 1D15 61 PUSH2 0x1d1d 1D18 83 DUP4 1D19 61 PUSH2 0x1a23 1D1C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D15 stack[0] = 0x1d1d // @1D18 stack[1] = stack[-3] // } // Block ends with call to 0x1a23, returns to 0x1D1D label_1D1D: // Incoming return from call to 0x1A23 at 0x1D1C // Inputs[5] // { // @1D1E stack[-1] // @1D1E stack[-6] // @1D21 stack[-4] // @1D25 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1D26 stack[-5] // } 1D1D 5B JUMPDEST 1D1E 94 SWAP5 1D1F 60 PUSH1 0x20 1D21 93 SWAP4 1D22 90 SWAP1 1D23 93 SWAP4 1D24 01 ADD 1D25 35 CALLDATALOAD 1D26 93 SWAP4 1D27 50 POP 1D28 50 POP 1D29 50 POP 1D2A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1D1E stack[-6] = stack[-1] // @1D26 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1D2B: // Incoming call from 0x02EB, returns to 0x02EC // Inputs[2] // { // @1D34 stack[-1] // @1D35 stack[-2] // } 1D2B 5B JUMPDEST 1D2C 60 PUSH1 0x00 1D2E 80 DUP1 1D2F 60 PUSH1 0x00 1D31 80 DUP1 1D32 60 PUSH1 0x40 1D34 85 DUP6 1D35 87 DUP8 1D36 03 SUB 1D37 12 SLT 1D38 15 ISZERO 1D39 61 PUSH2 0x1d40 1D3C 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1D2C stack[0] = 0x00 // @1D2E stack[1] = 0x00 // @1D2F stack[2] = 0x00 // @1D31 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1d40, if !(stack[-2] - stack[-1] i< 0x40) label_1D3D: // Incoming jump from 0x1D3C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D3D stack[-4] // @1D3F memory[stack[-4]:stack[-4] + stack[-4]] // } 1D3D 83 DUP4 1D3E 84 DUP5 1D3F FD *REVERT // Stack delta = +0 // Outputs[1] { @1D3F revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1D40: // Incoming jump from 0x1D3C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D41 stack[-5] // @1D42 msg.data[stack[-5]:stack[-5] + 0x20] // } 1D40 5B JUMPDEST 1D41 84 DUP5 1D42 35 CALLDATALOAD 1D43 67 PUSH8 0xffffffffffffffff 1D4C 80 DUP1 1D4D 82 DUP3 1D4E 11 GT 1D4F 15 ISZERO 1D50 61 PUSH2 0x1d57 1D53 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D42 stack[0] = msg.data[stack[-5]:stack[-5] + 0x20] // @1D43 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1d57, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) label_1D54: // Incoming jump from 0x1D53, if not !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1D54 stack[-6] // @1D56 memory[stack[-6]:stack[-6] + stack[-6]] // } 1D54 85 DUP6 1D55 86 DUP7 1D56 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D56 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_1D57: // Incoming jump from 0x1D53, if !(msg.data[stack[-5]:stack[-5] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1D5B stack[-8] // @1D5C stack[-2] // @1D5D stack[-7] // } 1D57 5B JUMPDEST 1D58 61 PUSH2 0x1d63 1D5B 88 DUP9 1D5C 83 DUP4 1D5D 89 DUP10 1D5E 01 ADD 1D5F 61 PUSH2 0x1a3f 1D62 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D58 stack[0] = 0x1d63 // @1D5B stack[1] = stack[-8] // @1D5E stack[2] = stack[-7] + stack[-2] // } // Block ends with call to 0x1a3f, returns to 0x1D63 label_1D63: // Incoming return from call to 0x1A3F at 0x1D62 // Inputs[8] // { // @1D64 stack[-2] // @1D64 stack[-1] // @1D65 stack[-8] // @1D67 stack[-7] // @1D6B stack[-9] // @1D6D msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // @1D6E stack[-4] // @1D70 stack[-3] // } 1D63 5B JUMPDEST 1D64 90 SWAP1 1D65 96 SWAP7 1D66 50 POP 1D67 94 SWAP5 1D68 50 POP 1D69 60 PUSH1 0x20 1D6B 87 DUP8 1D6C 01 ADD 1D6D 35 CALLDATALOAD 1D6E 91 SWAP2 1D6F 50 POP 1D70 80 DUP1 1D71 82 DUP3 1D72 11 GT 1D73 15 ISZERO 1D74 61 PUSH2 0x1d7b 1D77 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @1D65 stack[-8] = stack[-2] // @1D67 stack[-7] = stack[-1] // @1D6E stack[-4] = msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1d7b, if !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) label_1D78: // Incoming jump from 0x1D77, if not !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) // Inputs[2] // { // @1D78 stack[-4] // @1D7A memory[stack[-4]:stack[-4] + stack[-4]] // } 1D78 83 DUP4 1D79 84 DUP5 1D7A FD *REVERT // Stack delta = +0 // Outputs[1] { @1D7A revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1D7B: // Incoming jump from 0x1D77, if !(msg.data[stack[-9] + 0x20:stack[-9] + 0x20 + 0x20] > stack[-3]) // Inputs[3] // { // @1D80 stack[-8] // @1D81 stack[-2] // @1D82 stack[-7] // } 1D7B 5B JUMPDEST 1D7C 50 POP 1D7D 61 PUSH2 0x1d88 1D80 87 DUP8 1D81 82 DUP3 1D82 88 DUP9 1D83 01 ADD 1D84 61 PUSH2 0x1a3f 1D87 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1D7D stack[-1] = 0x1d88 // @1D80 stack[0] = stack[-8] // @1D83 stack[1] = stack[-7] + stack[-2] // } // Block ends with call to 0x1a3f, returns to 0x1D88 label_1D88: // Incoming return from call to 0x1A3F at 0x1D87 // Inputs[7] // { // @1D89 stack[-7] // @1D89 stack[-1] // @1D8A stack[-10] // @1D8B stack[-6] // @1D8C stack[-9] // @1D8E stack[-8] // @1D8E stack[-2] // } 1D88 5B JUMPDEST 1D89 95 SWAP6 1D8A 98 SWAP9 1D8B 94 SWAP5 1D8C 97 SWAP8 1D8D 50 POP 1D8E 95 SWAP6 1D8F 50 POP 1D90 50 POP 1D91 50 POP 1D92 50 POP 1D93 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @1D89 stack[-7] = stack[-1] // @1D8A stack[-10] = stack[-7] // @1D8C stack[-9] = stack[-6] // @1D8E stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_1D94: // Incoming call from 0x0236, returns to 0x0237 // Inputs[2] // { // @1D9A stack[-1] // @1D9B stack[-2] // } 1D94 5B JUMPDEST 1D95 60 PUSH1 0x00 1D97 80 DUP1 1D98 60 PUSH1 0x40 1D9A 83 DUP4 1D9B 85 DUP6 1D9C 03 SUB 1D9D 12 SLT 1D9E 15 ISZERO 1D9F 61 PUSH2 0x1da6 1DA2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D95 stack[0] = 0x00 // @1D97 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1da6, if !(stack[-2] - stack[-1] i< 0x40) label_1DA3: // Incoming jump from 0x1DA2, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DA3 stack[-2] // @1DA5 memory[stack[-2]:stack[-2] + stack[-2]] // } 1DA3 81 DUP2 1DA4 82 DUP3 1DA5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DA5 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1DA6: // Incoming jump from 0x1DA2, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1DA7 stack[-3] // @1DA8 msg.data[stack[-3]:stack[-3] + 0x20] // } 1DA6 5B JUMPDEST 1DA7 82 DUP3 1DA8 35 CALLDATALOAD 1DA9 67 PUSH8 0xffffffffffffffff 1DB2 80 DUP1 1DB3 82 DUP3 1DB4 11 GT 1DB5 15 ISZERO 1DB6 61 PUSH2 0x1dbd 1DB9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1DA8 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1DA9 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1dbd, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1DBA: // Incoming jump from 0x1DB9, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1DBA stack[-4] // @1DBC memory[stack[-4]:stack[-4] + stack[-4]] // } 1DBA 83 DUP4 1DBB 84 DUP5 1DBC FD *REVERT // Stack delta = +0 // Outputs[1] { @1DBC revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1DBD: // Incoming jump from 0x1DB9, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1DBE stack[-2] // @1DBF stack[-5] // @1DC3 stack[-6] // } 1DBD 5B JUMPDEST 1DBE 81 DUP2 1DBF 85 DUP6 1DC0 01 ADD 1DC1 91 SWAP2 1DC2 50 POP 1DC3 85 DUP6 1DC4 60 PUSH1 0x1f 1DC6 83 DUP4 1DC7 01 ADD 1DC8 12 SLT 1DC9 61 PUSH2 0x1dd0 1DCC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1DC1 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1dd0, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1DCD: // Incoming jump from 0x1DCC, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1DCD stack[-4] // @1DCF memory[stack[-4]:stack[-4] + stack[-4]] // } 1DCD 83 DUP4 1DCE 84 DUP5 1DCF FD *REVERT // Stack delta = +0 // Outputs[1] { @1DCF revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1DD0: // Incoming jump from 0x1DCC, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1DD1 stack[-2] // @1DD2 msg.data[stack[-2]:stack[-2] + 0x20] // } 1DD0 5B JUMPDEST 1DD1 81 DUP2 1DD2 35 CALLDATALOAD 1DD3 60 PUSH1 0x20 1DD5 61 PUSH2 0x1ddd 1DD8 82 DUP3 1DD9 61 PUSH2 0x20a6 1DDC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DD2 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1DD3 stack[1] = 0x20 // @1DD5 stack[2] = 0x1ddd // @1DD8 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x20a6, returns to 0x1DDD label_1DDD: // Incoming return from call to 0x20A6 at 0x1DDC // Inputs[2] // { // @1DE0 memory[0x40:0x60] // @1DE4 stack[-1] // } 1DDD 5B JUMPDEST 1DDE 60 PUSH1 0x40 1DE0 51 MLOAD 1DE1 61 PUSH2 0x1dea 1DE4 82 DUP3 1DE5 82 DUP3 1DE6 61 PUSH2 0x2178 1DE9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DE0 stack[0] = memory[0x40:0x60] // @1DE1 stack[1] = 0x1dea // @1DE4 stack[2] = stack[-1] // @1DE5 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2178, returns to 0x1DEA label_1DEA: // Incoming return from call to 0x2178 at 0x1DE9 // Inputs[6] // { // @1DEB stack[-4] // @1DEC stack[-1] // @1DEE stack[-3] // @1DF1 stack[-2] // @1DF3 stack[-6] // @1DFF stack[-10] // } 1DEA 5B JUMPDEST 1DEB 83 DUP4 1DEC 81 DUP2 1DED 52 MSTORE 1DEE 82 DUP3 1DEF 81 DUP2 1DF0 01 ADD 1DF1 91 SWAP2 1DF2 50 POP 1DF3 85 DUP6 1DF4 83 DUP4 1DF5 01 ADD 1DF6 60 PUSH1 0x05 1DF8 85 DUP6 1DF9 90 SWAP1 1DFA 1B SHL 1DFB 87 DUP8 1DFC 01 ADD 1DFD 84 DUP5 1DFE 01 ADD 1DFF 8B DUP12 1E00 10 LT 1E01 15 ISZERO 1E02 61 PUSH2 0x1e09 1E05 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1DED memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1DF1 stack[-2] = stack[-1] + stack[-3] // @1DF5 stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1e09, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_1E06: // Incoming jump from 0x1E05, if not !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1E06 stack[-9] // @1E08 memory[stack[-9]:stack[-9] + stack[-9]] // } 1E06 88 DUP9 1E07 89 DUP10 1E08 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E08 revert(memory[stack[-9]:stack[-9] + stack[-9]]); } // Block terminates label_1E09: // Incoming jump from 0x1E05, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[3] // { // @1E0A stack[-9] // @1E0B stack[-7] // @1E0E stack[-5] // } 1E09 5B JUMPDEST 1E0A 88 DUP9 1E0B 96 SWAP7 1E0C 50 POP 1E0D 5B JUMPDEST 1E0E 84 DUP5 1E0F 87 DUP8 1E10 10 LT 1E11 15 ISZERO 1E12 61 PUSH2 0x1e32 1E15 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E0B stack[-7] = stack[-9] } // Block ends with conditional jump to 0x1e32, if !(stack[-9] < stack[-5]) label_1E16: // Incoming jump from 0x1E15, if not !(stack[-9] < stack[-5]) // Incoming jump from 0x1E15, if not !(stack[-7] < stack[-5]) // Inputs[1] { @1E19 stack[-1] } 1E16 61 PUSH2 0x1e1e 1E19 81 DUP2 1E1A 61 PUSH2 0x1a23 1E1D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E16 stack[0] = 0x1e1e // @1E19 stack[1] = stack[-1] // } // Block ends with call to 0x1a23, returns to 0x1E1E label_1E1E: // Incoming return from call to 0x1A23 at 0x1E1D // Inputs[5] // { // @1E1F stack[-4] // @1E20 stack[-1] // @1E23 stack[-8] // @1E24 stack[-2] // @1E29 stack[-5] // } 1E1E 5B JUMPDEST 1E1F 83 DUP4 1E20 52 MSTORE 1E21 60 PUSH1 0x01 1E23 96 SWAP7 1E24 90 SWAP1 1E25 96 SWAP7 1E26 01 ADD 1E27 95 SWAP6 1E28 91 SWAP2 1E29 83 DUP4 1E2A 01 ADD 1E2B 91 SWAP2 1E2C 83 DUP4 1E2D 01 ADD 1E2E 61 PUSH2 0x1e0d 1E31 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1E20 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @1E27 stack[-8] = 0x01 + stack[-8] // @1E2B stack[-4] = stack[-5] + stack[-4] // @1E2D stack[-2] = stack[-5] + stack[-2] // } // Block ends with unconditional jump to 0x1e0d label_1E32: // Incoming jump from 0x1E15, if !(stack[-9] < stack[-5]) // Incoming jump from 0x1E15, if !(stack[-7] < stack[-5]) // Inputs[7] // { // @1E34 stack[-9] // @1E34 stack[-2] // @1E37 stack[-10] // @1E38 stack[-4] // @1E39 msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // @1E3A stack[-7] // @1E3D stack[-6] // } 1E32 5B JUMPDEST 1E33 50 POP 1E34 96 SWAP7 1E35 50 POP 1E36 50 POP 1E37 86 DUP7 1E38 01 ADD 1E39 35 CALLDATALOAD 1E3A 92 SWAP3 1E3B 50 POP 1E3C 50 POP 1E3D 80 DUP1 1E3E 82 DUP3 1E3F 11 GT 1E40 15 ISZERO 1E41 61 PUSH2 0x1e48 1E44 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1E34 stack[-9] = stack[-2] // @1E3A stack[-7] = msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // } // Block ends with conditional jump to 0x1e48, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) label_1E45: // Incoming jump from 0x1E44, if not !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[2] // { // @1E45 stack[-3] // @1E47 memory[stack[-3]:stack[-3] + stack[-3]] // } 1E45 82 DUP3 1E46 83 DUP4 1E47 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E47 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1E48: // Incoming jump from 0x1E44, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[3] // { // @1E4D stack[-6] // @1E4E stack[-2] // @1E4F stack[-5] // } 1E48 5B JUMPDEST 1E49 50 POP 1E4A 61 PUSH2 0x1e55 1E4D 85 DUP6 1E4E 82 DUP3 1E4F 86 DUP7 1E50 01 ADD 1E51 61 PUSH2 0x1a89 1E54 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1E4A stack[-1] = 0x1e55 // @1E4D stack[0] = stack[-6] // @1E50 stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x1a89, returns to 0x1E55 label_1E55: // Incoming return from call to 0x1A89 at 0x1E54 // Inputs[6] // { // @1E56 stack[-1] // @1E56 stack[-3] // @1E59 stack[-6] // @1E5B stack[-7] // @1E5B stack[-4] // @1E5C stack[-5] // } 1E55 5B JUMPDEST 1E56 91 SWAP2 1E57 50 POP 1E58 50 POP 1E59 92 SWAP3 1E5A 50 POP 1E5B 92 SWAP3 1E5C 90 SWAP1 1E5D 50 POP 1E5E 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1E59 stack[-6] = stack[-1] // @1E5B stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1E5F: // Incoming call from 0x01C4, returns to 0x01C5 // Inputs[2] // { // @1E64 stack[-1] // @1E65 stack[-2] // } 1E5F 5B JUMPDEST 1E60 60 PUSH1 0x00 1E62 60 PUSH1 0x20 1E64 82 DUP3 1E65 84 DUP5 1E66 03 SUB 1E67 12 SLT 1E68 15 ISZERO 1E69 61 PUSH2 0x1e70 1E6C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E60 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e70, if !(stack[-2] - stack[-1] i< 0x20) label_1E6D: // Incoming jump from 0x1E6C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E6D stack[-1] // @1E6F memory[stack[-1]:stack[-1] + stack[-1]] // } 1E6D 80 DUP1 1E6E 81 DUP2 1E6F FD *REVERT // Stack delta = +0 // Outputs[1] { @1E6F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1E70: // Incoming jump from 0x1E6C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E71 stack[-2] // @1E72 msg.data[stack[-2]:stack[-2] + 0x20] // } 1E70 5B JUMPDEST 1E71 81 DUP2 1E72 35 CALLDATALOAD 1E73 61 PUSH2 0x1b86 1E76 81 DUP2 1E77 61 PUSH2 0x22d8 1E7A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E72 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1E73 stack[1] = 0x1b86 // @1E76 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x22d8, returns to 0x1B86 1E7B 5B JUMPDEST 1E7C 60 PUSH1 0x00 1E7E 60 PUSH1 0x20 1E80 82 DUP3 1E81 84 DUP5 1E82 03 SUB 1E83 12 SLT 1E84 15 ISZERO 1E85 61 PUSH2 0x1e8c 1E88 57 *JUMPI 1E89 80 DUP1 1E8A 81 DUP2 1E8B FD *REVERT 1E8C 5B JUMPDEST 1E8D 81 DUP2 1E8E 51 MLOAD 1E8F 61 PUSH2 0x1b86 1E92 81 DUP2 1E93 61 PUSH2 0x22d8 1E96 56 *JUMP label_1E97: // Incoming call from 0x0269, returns to 0x026A // Inputs[2] // { // @1E9D stack[-1] // @1E9E stack[-2] // } 1E97 5B JUMPDEST 1E98 60 PUSH1 0x00 1E9A 80 DUP1 1E9B 60 PUSH1 0x20 1E9D 83 DUP4 1E9E 85 DUP6 1E9F 03 SUB 1EA0 12 SLT 1EA1 15 ISZERO 1EA2 61 PUSH2 0x1ea9 1EA5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E98 stack[0] = 0x00 // @1E9A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ea9, if !(stack[-2] - stack[-1] i< 0x20) label_1EA6: // Incoming jump from 0x1EA5, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1EA6 stack[-2] // @1EA8 memory[stack[-2]:stack[-2] + stack[-2]] // } 1EA6 81 DUP2 1EA7 82 DUP3 1EA8 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EA8 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1EA9: // Incoming jump from 0x1EA5, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1EAA stack[-3] // @1EAB msg.data[stack[-3]:stack[-3] + 0x20] // } 1EA9 5B JUMPDEST 1EAA 82 DUP3 1EAB 35 CALLDATALOAD 1EAC 67 PUSH8 0xffffffffffffffff 1EB5 80 DUP1 1EB6 82 DUP3 1EB7 11 GT 1EB8 15 ISZERO 1EB9 61 PUSH2 0x1ec0 1EBC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EAB stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1EAC stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1ec0, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1EBD: // Incoming jump from 0x1EBC, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1EBD stack[-4] // @1EBF memory[stack[-4]:stack[-4] + stack[-4]] // } 1EBD 83 DUP4 1EBE 84 DUP5 1EBF FD *REVERT // Stack delta = +0 // Outputs[1] { @1EBF revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1EC0: // Incoming jump from 0x1EBC, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1EC1 stack[-2] // @1EC2 stack[-5] // @1EC6 stack[-6] // } 1EC0 5B JUMPDEST 1EC1 81 DUP2 1EC2 85 DUP6 1EC3 01 ADD 1EC4 91 SWAP2 1EC5 50 POP 1EC6 85 DUP6 1EC7 60 PUSH1 0x1f 1EC9 83 DUP4 1ECA 01 ADD 1ECB 12 SLT 1ECC 61 PUSH2 0x1ed3 1ECF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1EC4 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1ed3, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1ED0: // Incoming jump from 0x1ECF, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1ED0 stack[-4] // @1ED2 memory[stack[-4]:stack[-4] + stack[-4]] // } 1ED0 83 DUP4 1ED1 84 DUP5 1ED2 FD *REVERT // Stack delta = +0 // Outputs[1] { @1ED2 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1ED3: // Incoming jump from 0x1ECF, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @1ED4 stack[-2] // @1ED5 msg.data[stack[-2]:stack[-2] + 0x20] // @1ED6 stack[-1] // } 1ED3 5B JUMPDEST 1ED4 81 DUP2 1ED5 35 CALLDATALOAD 1ED6 81 DUP2 1ED7 81 DUP2 1ED8 11 GT 1ED9 15 ISZERO 1EDA 61 PUSH2 0x1ee1 1EDD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1ED5 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1ee1, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_1EDE: // Incoming jump from 0x1EDD, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @1EDE stack[-5] // @1EE0 memory[stack[-5]:stack[-5] + stack[-5]] // } 1EDE 84 DUP5 1EDF 85 DUP6 1EE0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EE0 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_1EE1: // Incoming jump from 0x1EDD, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @1EE2 stack[-7] // @1EE5 stack[-1] // @1EE6 stack[-3] // } 1EE1 5B JUMPDEST 1EE2 86 DUP7 1EE3 60 PUSH1 0x20 1EE5 82 DUP3 1EE6 85 DUP6 1EE7 01 ADD 1EE8 01 ADD 1EE9 11 GT 1EEA 15 ISZERO 1EEB 61 PUSH2 0x1ef2 1EEE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ef2, if !(stack[-3] + stack[-1] + 0x20 > stack[-7]) label_1EEF: // Incoming jump from 0x1EEE, if not !(stack[-3] + stack[-1] + 0x20 > stack[-7]) // Inputs[2] // { // @1EEF stack[-5] // @1EF1 memory[stack[-5]:stack[-5] + stack[-5]] // } 1EEF 84 DUP5 1EF0 85 DUP6 1EF1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EF1 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_1EF2: // Incoming jump from 0x1EEE, if !(stack[-3] + stack[-1] + 0x20 > stack[-7]) // Inputs[6] // { // @1EF5 stack[-3] // @1EF6 stack[-1] // @1EF9 stack[-8] // @1EFB stack[-7] // @1EFD stack[-2] // @1EFE stack[-6] // } 1EF2 5B JUMPDEST 1EF3 60 PUSH1 0x20 1EF5 92 SWAP3 1EF6 90 SWAP1 1EF7 92 SWAP3 1EF8 01 ADD 1EF9 96 SWAP7 1EFA 91 SWAP2 1EFB 95 SWAP6 1EFC 50 POP 1EFD 90 SWAP1 1EFE 93 SWAP4 1EFF 50 POP 1F00 50 POP 1F01 50 POP 1F02 50 POP 1F03 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1EF9 stack[-8] = 0x20 + stack[-3] // @1EFB stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_1F04: // Incoming call from 0x02FE, returns to 0x02FF // Incoming call from 0x01FC, returns to 0x01FD // Inputs[2] // { // @1F09 stack[-1] // @1F0A stack[-2] // } 1F04 5B JUMPDEST 1F05 60 PUSH1 0x00 1F07 60 PUSH1 0x20 1F09 82 DUP3 1F0A 84 DUP5 1F0B 03 SUB 1F0C 12 SLT 1F0D 15 ISZERO 1F0E 61 PUSH2 0x1f15 1F11 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F05 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f15, if !(stack[-2] - stack[-1] i< 0x20) label_1F12: // Incoming jump from 0x1F11, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1F12 stack[-1] // @1F14 memory[stack[-1]:stack[-1] + stack[-1]] // } 1F12 80 DUP1 1F13 81 DUP2 1F14 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F14 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1F15: // Incoming jump from 0x1F11, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1F17 stack[-2] // @1F17 msg.data[stack[-2]:stack[-2] + 0x20] // @1F18 stack[-4] // @1F19 stack[-3] // } 1F15 5B JUMPDEST 1F16 50 POP 1F17 35 CALLDATALOAD 1F18 91 SWAP2 1F19 90 SWAP1 1F1A 50 POP 1F1B 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F18 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1F1C: // Incoming call from 0x2064, returns to 0x1B86 // Inputs[3] // { // @1F1F stack[-1] // @1F20 memory[stack[-1]:stack[-1] + 0x20] // @1F22 stack[-2] // } 1F1C 5B JUMPDEST 1F1D 60 PUSH1 0x00 1F1F 81 DUP2 1F20 51 MLOAD 1F21 80 DUP1 1F22 84 DUP5 1F23 52 MSTORE 1F24 60 PUSH1 0x20 1F26 80 DUP1 1F27 85 DUP6 1F28 01 ADD 1F29 94 SWAP5 1F2A 50 POP 1F2B 80 DUP1 1F2C 84 DUP5 1F2D 01 ADD 1F2E 83 DUP4 1F2F 5B JUMPDEST 1F30 83 DUP4 1F31 81 DUP2 1F32 10 LT 1F33 15 ISZERO 1F34 61 PUSH2 0x1f4b 1F37 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @1F1D stack[0] = 0x00 // @1F20 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1F23 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1F24 stack[2] = 0x20 // @1F29 stack[-2] = stack[-2] + 0x20 // @1F2D stack[3] = stack[-1] + 0x20 // @1F2E stack[4] = 0x00 // } // Block ends with conditional jump to 0x1f4b, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1F38: // Incoming jump from 0x1F37, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x1F37, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @1F38 stack[-2] // @1F39 memory[stack[-2]:stack[-2] + 0x20] // @1F3A stack[-7] // @1F3C stack[-1] // @1F3D stack[-3] // } 1F38 81 DUP2 1F39 51 MLOAD 1F3A 87 DUP8 1F3B 52 MSTORE 1F3C 95 SWAP6 1F3D 82 DUP3 1F3E 01 ADD 1F3F 95 SWAP6 1F40 90 SWAP1 1F41 82 DUP3 1F42 01 ADD 1F43 90 SWAP1 1F44 60 PUSH1 0x01 1F46 01 ADD 1F47 61 PUSH2 0x1f2f 1F4A 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1F3B memory[stack[-7]:stack[-7] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @1F3F stack[-7] = stack[-3] + stack[-7] // @1F43 stack[-2] = stack[-3] + stack[-2] // @1F46 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1f2f label_1F4B: // Incoming jump from 0x1F37, if !(stack[-1] < stack[-4]) // Incoming jump from 0x1F37, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1F4D stack[-7] // @1F4D stack[-2] // @1F4E stack[-8] // } 1F4B 5B JUMPDEST 1F4C 50 POP 1F4D 94 SWAP5 1F4E 95 SWAP6 1F4F 94 SWAP5 1F50 50 POP 1F51 50 POP 1F52 50 POP 1F53 50 POP 1F54 50 POP 1F55 56 *JUMP // Stack delta = -7 // Outputs[1] { @1F4E stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1F56: // Incoming call from 0x20A5, returns to 0x1B86 // Inputs[3] // { // @1F59 stack[-1] // @1F5A memory[stack[-1]:stack[-1] + 0x20] // @1F5C stack[-2] // } 1F56 5B JUMPDEST 1F57 60 PUSH1 0x00 1F59 81 DUP2 1F5A 51 MLOAD 1F5B 80 DUP1 1F5C 84 DUP5 1F5D 52 MSTORE 1F5E 61 PUSH2 0x1f6e 1F61 81 DUP2 1F62 60 PUSH1 0x20 1F64 86 DUP7 1F65 01 ADD 1F66 60 PUSH1 0x20 1F68 86 DUP7 1F69 01 ADD 1F6A 61 PUSH2 0x210d 1F6D 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1F57 stack[0] = 0x00 // @1F5A stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1F5D memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1F5E stack[2] = 0x1f6e // @1F61 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1F65 stack[4] = stack[-2] + 0x20 // @1F69 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x210d, returns to 0x1F6E label_1F6E: // Incoming return from call to 0x210D at 0x1F6D // Inputs[4] // { // @1F71 stack[-1] // @1F76 stack[-4] // @1F77 stack[-2] // @1F7D stack[-5] // } 1F6E 5B JUMPDEST 1F6F 60 PUSH1 0x1f 1F71 01 ADD 1F72 60 PUSH1 0x1f 1F74 19 NOT 1F75 16 AND 1F76 92 SWAP3 1F77 90 SWAP1 1F78 92 SWAP3 1F79 01 ADD 1F7A 60 PUSH1 0x20 1F7C 01 ADD 1F7D 92 SWAP3 1F7E 91 SWAP2 1F7F 50 POP 1F80 50 POP 1F81 56 *JUMP // Stack delta = -4 // Outputs[1] { @1F7D stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1F82: // Incoming call from 0x0DA1, returns to 0x0DA2 // Inputs[3] // { // @1F85 stack[-3] // @1F86 memory[stack[-3]:stack[-3] + 0x20] // @1F8B stack[-1] // } 1F82 5B JUMPDEST 1F83 60 PUSH1 0x00 1F85 83 DUP4 1F86 51 MLOAD 1F87 61 PUSH2 0x1f94 1F8A 81 DUP2 1F8B 84 DUP5 1F8C 60 PUSH1 0x20 1F8E 88 DUP9 1F8F 01 ADD 1F90 61 PUSH2 0x210d 1F93 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1F83 stack[0] = 0x00 // @1F86 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @1F87 stack[2] = 0x1f94 // @1F8A stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @1F8B stack[4] = stack[-1] // @1F8F stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x210d, returns to 0x1F94 label_1F94: // Incoming return from call to 0x210D at 0x1F93 // Inputs[4] // { // @1F95 stack[-4] // @1F96 memory[stack[-4]:stack[-4] + 0x20] // @1F97 stack[-1] // @1F98 stack[-3] // } 1F94 5B JUMPDEST 1F95 83 DUP4 1F96 51 MLOAD 1F97 90 SWAP1 1F98 83 DUP4 1F99 01 ADD 1F9A 90 SWAP1 1F9B 61 PUSH2 0x1fa8 1F9E 81 DUP2 1F9F 83 DUP4 1FA0 60 PUSH1 0x20 1FA2 88 DUP9 1FA3 01 ADD 1FA4 61 PUSH2 0x210d 1FA7 56 *JUMP // Stack delta = +5 // Outputs[6] // { // @1F9A stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @1F9A stack[-1] = stack[-3] + stack[-1] // @1F9B stack[1] = 0x1fa8 // @1F9E stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @1F9F stack[3] = stack[-3] + stack[-1] // @1FA3 stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x210d, returns to 0x1FA8 label_1FA8: // Incoming return from call to 0x210D at 0x1FA7 // Inputs[4] // { // @1FA9 stack[-2] // @1FA9 stack[-1] // @1FAA stack[-7] // @1FAB stack[-6] // } 1FA8 5B JUMPDEST 1FA9 01 ADD 1FAA 94 SWAP5 1FAB 93 SWAP4 1FAC 50 POP 1FAD 50 POP 1FAE 50 POP 1FAF 50 POP 1FB0 56 *JUMP // Stack delta = -6 // Outputs[1] { @1FAA stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] 1FB1 5B JUMPDEST 1FB2 60 PUSH1 0x00 1FB4 60 PUSH1 0x01 1FB6 60 PUSH1 0x01 1FB8 60 PUSH1 0xa0 1FBA 1B SHL 1FBB 03 SUB 1FBC 80 DUP1 1FBD 88 DUP9 1FBE 16 AND 1FBF 83 DUP4 1FC0 52 MSTORE 1FC1 80 DUP1 1FC2 87 DUP8 1FC3 16 AND 1FC4 60 PUSH1 0x20 1FC6 84 DUP5 1FC7 01 ADD 1FC8 52 MSTORE 1FC9 50 POP 1FCA 60 PUSH1 0xa0 1FCC 60 PUSH1 0x40 1FCE 83 DUP4 1FCF 01 ADD 1FD0 52 MSTORE 1FD1 61 PUSH2 0x1fdd 1FD4 60 PUSH1 0xa0 1FD6 83 DUP4 1FD7 01 ADD 1FD8 86 DUP7 1FD9 61 PUSH2 0x1f1c 1FDC 56 *JUMP 1FDD 5B JUMPDEST 1FDE 82 DUP3 1FDF 81 DUP2 1FE0 03 SUB 1FE1 60 PUSH1 0x60 1FE3 84 DUP5 1FE4 01 ADD 1FE5 52 MSTORE 1FE6 61 PUSH2 0x1fef 1FE9 81 DUP2 1FEA 86 DUP7 1FEB 61 PUSH2 0x1f1c 1FEE 56 *JUMP 1FEF 5B JUMPDEST 1FF0 90 SWAP1 1FF1 50 POP 1FF2 82 DUP3 1FF3 81 DUP2 1FF4 03 SUB 1FF5 60 PUSH1 0x80 1FF7 84 DUP5 1FF8 01 ADD 1FF9 52 MSTORE 1FFA 61 PUSH2 0x2003 1FFD 81 DUP2 1FFE 85 DUP6 1FFF 61 PUSH2 0x1f56 2002 56 *JUMP 2003 5B JUMPDEST 2004 98 SWAP9 2005 97 SWAP8 2006 50 POP 2007 50 POP 2008 50 POP 2009 50 POP 200A 50 POP 200B 50 POP 200C 50 POP 200D 50 POP 200E 56 *JUMP 200F 5B JUMPDEST 2010 60 PUSH1 0x00 2012 60 PUSH1 0x01 2014 60 PUSH1 0x01 2016 60 PUSH1 0xa0 2018 1B SHL 2019 03 SUB 201A 80 DUP1 201B 88 DUP9 201C 16 AND 201D 83 DUP4 201E 52 MSTORE 201F 80 DUP1 2020 87 DUP8 2021 16 AND 2022 60 PUSH1 0x20 2024 84 DUP5 2025 01 ADD 2026 52 MSTORE 2027 50 POP 2028 84 DUP5 2029 60 PUSH1 0x40 202B 83 DUP4 202C 01 ADD 202D 52 MSTORE 202E 83 DUP4 202F 60 PUSH1 0x60 2031 83 DUP4 2032 01 ADD 2033 52 MSTORE 2034 60 PUSH1 0xa0 2036 60 PUSH1 0x80 2038 83 DUP4 2039 01 ADD 203A 52 MSTORE 203B 61 PUSH2 0x2047 203E 60 PUSH1 0xa0 2040 83 DUP4 2041 01 ADD 2042 84 DUP5 2043 61 PUSH2 0x1f56 2046 56 *JUMP 2047 5B JUMPDEST 2048 97 SWAP8 2049 96 SWAP7 204A 50 POP 204B 50 POP 204C 50 POP 204D 50 POP 204E 50 POP 204F 50 POP 2050 50 POP 2051 56 *JUMP label_2052: // Incoming jump from 0x0248 // Inputs[2] // { // @2055 stack[-1] // @2060 stack[-2] // } 2052 5B JUMPDEST 2053 60 PUSH1 0x20 2055 81 DUP2 2056 52 MSTORE 2057 60 PUSH1 0x00 2059 61 PUSH2 0x1b86 205C 60 PUSH1 0x20 205E 83 DUP4 205F 01 ADD 2060 84 DUP5 2061 61 PUSH2 0x1f1c 2064 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2056 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2057 stack[0] = 0x00 // @2059 stack[1] = 0x1b86 // @205F stack[2] = stack[-1] + 0x20 // @2060 stack[3] = stack[-2] // } // Block ends with call to 0x1f1c, returns to 0x1B86 2065 5B JUMPDEST 2066 60 PUSH1 0x40 2068 81 DUP2 2069 52 MSTORE 206A 60 PUSH1 0x00 206C 61 PUSH2 0x2078 206F 60 PUSH1 0x40 2071 83 DUP4 2072 01 ADD 2073 85 DUP6 2074 61 PUSH2 0x1f1c 2077 56 *JUMP 2078 5B JUMPDEST 2079 82 DUP3 207A 81 DUP2 207B 03 SUB 207C 60 PUSH1 0x20 207E 84 DUP5 207F 01 ADD 2080 52 MSTORE 2081 61 PUSH2 0x208a 2084 81 DUP2 2085 85 DUP6 2086 61 PUSH2 0x1f1c 2089 56 *JUMP 208A 5B JUMPDEST 208B 95 SWAP6 208C 94 SWAP5 208D 50 POP 208E 50 POP 208F 50 POP 2090 50 POP 2091 50 POP 2092 56 *JUMP label_2093: // Incoming jump from 0x01EE // Inputs[2] // { // @2096 stack[-1] // @20A1 stack[-2] // } 2093 5B JUMPDEST 2094 60 PUSH1 0x20 2096 81 DUP2 2097 52 MSTORE 2098 60 PUSH1 0x00 209A 61 PUSH2 0x1b86 209D 60 PUSH1 0x20 209F 83 DUP4 20A0 01 ADD 20A1 84 DUP5 20A2 61 PUSH2 0x1f56 20A5 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2097 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2098 stack[0] = 0x00 // @209A stack[1] = 0x1b86 // @20A0 stack[2] = stack[-1] + 0x20 // @20A1 stack[3] = stack[-2] // } // Block ends with call to 0x1f56, returns to 0x1B86 label_20A6: // Incoming call from 0x1AA5, returns to 0x1AA6 // Incoming call from 0x1DDC, returns to 0x1DDD // Inputs[1] { @20B2 stack[-1] } 20A6 5B JUMPDEST 20A7 60 PUSH1 0x00 20A9 67 PUSH8 0xffffffffffffffff 20B2 82 DUP3 20B3 11 GT 20B4 15 ISZERO 20B5 61 PUSH2 0x20c0 20B8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20A7 stack[0] = 0x00 } // Block ends with conditional jump to 0x20c0, if !(stack[-1] > 0xffffffffffffffff) label_20B9: // Incoming jump from 0x20B8, if not !(stack[-1] > 0xffffffffffffffff) 20B9 61 PUSH2 0x20c0 20BC 61 PUSH2 0x2220 20BF 56 *JUMP // Stack delta = +1 // Outputs[1] { @20B9 stack[0] = 0x20c0 } // Block ends with unconditional jump to 0x2220 label_20C0: // Incoming jump from 0x20B8, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @20C4 stack[-2] // @20C8 stack[-3] // } 20C0 5B JUMPDEST 20C1 50 POP 20C2 60 PUSH1 0x05 20C4 1B SHL 20C5 60 PUSH1 0x20 20C7 01 ADD 20C8 90 SWAP1 20C9 56 *JUMP // Stack delta = -2 // Outputs[1] { @20C8 stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_20CA: // Incoming call from 0x143F, returns to 0x1440 // Inputs[2] // { // @20CD stack[-2] // @20CF stack[-1] // } 20CA 5B JUMPDEST 20CB 60 PUSH1 0x00 20CD 82 DUP3 20CE 19 NOT 20CF 82 DUP3 20D0 11 GT 20D1 15 ISZERO 20D2 61 PUSH2 0x20dd 20D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20CB stack[0] = 0x00 } // Block ends with conditional jump to 0x20dd, if !(stack[-1] > ~stack[-2]) label_20D6: // Incoming jump from 0x20D5, if not !(stack[-1] > ~stack[-2]) 20D6 61 PUSH2 0x20dd 20D9 61 PUSH2 0x21f4 20DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @20D6 stack[0] = 0x20dd } // Block ends with unconditional jump to 0x21f4 label_20DD: // Incoming jump from 0x20D5, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @20DF stack[-3] // @20DF stack[-2] // @20E0 stack[-4] // } 20DD 5B JUMPDEST 20DE 50 POP 20DF 01 ADD 20E0 90 SWAP1 20E1 56 *JUMP // Stack delta = -3 // Outputs[1] { @20E0 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_20E2: // Incoming call from 0x13B8, returns to 0x13B9 // Incoming call from 0x149C, returns to 0x149D // Inputs[1] { @20E5 stack[-2] } 20E2 5B JUMPDEST 20E3 60 PUSH1 0x00 20E5 82 DUP3 20E6 61 PUSH2 0x20f1 20E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20E3 stack[0] = 0x00 } // Block ends with conditional jump to 0x20f1, if stack[-2] label_20EA: // Incoming jump from 0x20E9, if not stack[-2] 20EA 61 PUSH2 0x20f1 20ED 61 PUSH2 0x220a 20F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @20EA stack[0] = 0x20f1 } // Block ends with unconditional jump to 0x220a label_20F1: // Incoming jump from 0x20E9, if stack[-2] // Inputs[3] // { // @20F3 stack[-2] // @20F3 stack[-3] // @20F4 stack[-4] // } 20F1 5B JUMPDEST 20F2 50 POP 20F3 04 DIV 20F4 90 SWAP1 20F5 56 *JUMP // Stack delta = -3 // Outputs[1] { @20F4 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_20F6: // Incoming call from 0x1427, returns to 0x1428 // Inputs[2] // { // @20F9 stack[-2] // @20FA stack[-1] // } 20F6 5B JUMPDEST 20F7 60 PUSH1 0x00 20F9 82 DUP3 20FA 82 DUP3 20FB 10 LT 20FC 15 ISZERO 20FD 61 PUSH2 0x2108 2100 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20F7 stack[0] = 0x00 } // Block ends with conditional jump to 0x2108, if !(stack[-1] < stack[-2]) label_2101: // Incoming jump from 0x2100, if not !(stack[-1] < stack[-2]) 2101 61 PUSH2 0x2108 2104 61 PUSH2 0x21f4 2107 56 *JUMP // Stack delta = +1 // Outputs[1] { @2101 stack[0] = 0x2108 } // Block ends with unconditional jump to 0x21f4 label_2108: // Incoming jump from 0x2100, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @210A stack[-2] // @210A stack[-3] // @210B stack[-4] // } 2108 5B JUMPDEST 2109 50 POP 210A 03 SUB 210B 90 SWAP1 210C 56 *JUMP // Stack delta = -3 // Outputs[1] { @210B stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_210D: // Incoming call from 0x1FA7, returns to 0x1FA8 // Incoming call from 0x1F93, returns to 0x1F94 // Incoming call from 0x1F6D, returns to 0x1F6E // Inputs[1] { @2111 stack[-3] } 210D 5B JUMPDEST 210E 60 PUSH1 0x00 2110 5B JUMPDEST 2111 83 DUP4 2112 81 DUP2 2113 10 LT 2114 15 ISZERO 2115 61 PUSH2 0x2128 2118 57 *JUMPI // Stack delta = +1 // Outputs[1] { @210E stack[0] = 0x00 } // Block ends with conditional jump to 0x2128, if !(0x00 < stack[-3]) label_2119: // Incoming jump from 0x2118, if not !(0x00 < stack[-3]) // Incoming jump from 0x2118, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2119 stack[-2] // @211A stack[-1] // @211C memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @211D stack[-3] // } 2119 81 DUP2 211A 81 DUP2 211B 01 ADD 211C 51 MLOAD 211D 83 DUP4 211E 82 DUP3 211F 01 ADD 2120 52 MSTORE 2121 60 PUSH1 0x20 2123 01 ADD 2124 61 PUSH2 0x2110 2127 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2120 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2123 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2110 label_2128: // Incoming jump from 0x2118, if !(0x00 < stack[-3]) // Incoming jump from 0x2118, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @2129 stack[-4] // @212A stack[-1] // } 2128 5B JUMPDEST 2129 83 DUP4 212A 81 DUP2 212B 11 GT 212C 15 ISZERO 212D 61 PUSH2 0x2137 2130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2137, if !(stack[-1] > stack[-4]) label_2131: // Incoming jump from 0x2130, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2133 stack[-4] // @2134 stack[-3] // @213C stack[-5] // } 2131 60 PUSH1 0x00 2133 84 DUP5 2134 84 DUP5 2135 01 ADD 2136 52 MSTORE 2137 5B JUMPDEST 2138 50 POP 2139 50 POP 213A 50 POP 213B 50 POP 213C 56 *JUMP // Stack delta = -5 // Outputs[1] { @2136 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_213D: // Incoming call from 0x04CB, returns to 0x04CC // Incoming call from 0x0CD8, returns to 0x0CD9 // Incoming call from 0x0A0F, returns to 0x04CC // Incoming call from 0x04F7, returns to 0x04F8 // Incoming call from 0x196E, returns to 0x196F // Incoming call from 0x0D04, returns to 0x0D05 // Incoming call from 0x0A02, returns to 0x04CC // Inputs[1] { @2140 stack[-1] } 213D 5B JUMPDEST 213E 60 PUSH1 0x01 2140 81 DUP2 2141 81 DUP2 2142 1C SHR 2143 90 SWAP1 2144 82 DUP3 2145 16 AND 2146 80 DUP1 2147 61 PUSH2 0x2151 214A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2143 stack[0] = stack[-1] >> 0x01 // @2145 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2151, if stack[-1] & 0x01 label_214B: // Incoming jump from 0x214A, if not stack[-1] & 0x01 // Inputs[2] // { // @214D stack[-2] // @2156 stack[-1] // } 214B 60 PUSH1 0x7f 214D 82 DUP3 214E 16 AND 214F 91 SWAP2 2150 50 POP 2151 5B JUMPDEST 2152 60 PUSH1 0x20 2154 82 DUP3 2155 10 LT 2156 81 DUP2 2157 14 EQ 2158 15 ISZERO 2159 61 PUSH2 0x2172 215C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @214F stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2172, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_215D: // Incoming jump from 0x215C, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x215C, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @2171 memory[0x00:0x24] } 215D 63 PUSH4 0x4e487b71 2162 60 PUSH1 0xe0 2164 1B SHL 2165 60 PUSH1 0x00 2167 52 MSTORE 2168 60 PUSH1 0x22 216A 60 PUSH1 0x04 216C 52 MSTORE 216D 60 PUSH1 0x24 216F 60 PUSH1 0x00 2171 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2167 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @216C memory[0x04:0x24] = 0x22 // @2171 revert(memory[0x00:0x24]); // } // Block terminates label_2172: // Incoming jump from 0x215C, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x215C, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @2174 stack[-4] // @2174 stack[-2] // @2175 stack[-3] // } 2172 5B JUMPDEST 2173 50 POP 2174 91 SWAP2 2175 90 SWAP1 2176 50 POP 2177 56 *JUMP // Stack delta = -3 // Outputs[1] { @2174 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2178: // Incoming call from 0x1DE9, returns to 0x1DEA // Incoming call from 0x1AB2, returns to 0x1AB3 // Incoming call from 0x1B3D, returns to 0x1B3E // Inputs[2] // { // @217B stack[-2] // @2181 stack[-1] // } 2178 5B JUMPDEST 2179 60 PUSH1 0x1f 217B 82 DUP3 217C 01 ADD 217D 60 PUSH1 0x1f 217F 19 NOT 2180 16 AND 2181 81 DUP2 2182 01 ADD 2183 67 PUSH8 0xffffffffffffffff 218C 81 DUP2 218D 11 GT 218E 82 DUP3 218F 82 DUP3 2190 10 LT 2191 17 OR 2192 15 ISZERO 2193 61 PUSH2 0x219e 2196 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2182 stack[0] = stack[-1] + (~0x1f & stack[-2] + 0x1f) } // Block ends with conditional jump to 0x219e, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) label_2197: // Incoming jump from 0x2196, if not !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) 2197 61 PUSH2 0x219e 219A 61 PUSH2 0x2220 219D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2197 stack[0] = 0x219e } // Block ends with unconditional jump to 0x2220 label_219E: // Incoming jump from 0x2196, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) // Inputs[2] // { // @21A1 stack[-1] // @21A4 stack[-4] // } 219E 5B JUMPDEST 219F 60 PUSH1 0x40 21A1 52 MSTORE 21A2 50 POP 21A3 50 POP 21A4 56 *JUMP // Stack delta = -4 // Outputs[1] { @21A1 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_21A5: // Incoming call from 0x08FA, returns to 0x08FB // Incoming call from 0x0C08, returns to 0x0C09 // Incoming call from 0x0760, returns to 0x0761 // Incoming call from 0x13A9, returns to 0x13AA // Inputs[1] { @21AB stack[-1] } 21A5 5B JUMPDEST 21A6 60 PUSH1 0x00 21A8 60 PUSH1 0x00 21AA 19 NOT 21AB 82 DUP3 21AC 14 EQ 21AD 15 ISZERO 21AE 61 PUSH2 0x21b9 21B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21A6 stack[0] = 0x00 } // Block ends with conditional jump to 0x21b9, if !(stack[-1] == ~0x00) label_21B2: // Incoming jump from 0x21B1, if not !(stack[-1] == ~0x00) 21B2 61 PUSH2 0x21b9 21B5 61 PUSH2 0x21f4 21B8 56 *JUMP // Stack delta = +1 // Outputs[1] { @21B2 stack[0] = 0x21b9 } // Block ends with unconditional jump to 0x21f4 label_21B9: // Incoming jump from 0x21B1, if !(stack[-1] == ~0x00) // Inputs[2] // { // @21BD stack[-2] // @21BE stack[-3] // } 21B9 5B JUMPDEST 21BA 50 POP 21BB 60 PUSH1 0x01 21BD 01 ADD 21BE 90 SWAP1 21BF 56 *JUMP // Stack delta = -2 // Outputs[1] { @21BE stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_21C0: // Incoming call from 0x0C20, returns to 0x0C21 // Inputs[1] { @21C5 stack[-1] } 21C0 5B JUMPDEST 21C1 60 PUSH1 0x00 21C3 60 PUSH1 0xff 21C5 82 DUP3 21C6 16 AND 21C7 60 PUSH1 0xff 21C9 81 DUP2 21CA 14 EQ 21CB 15 ISZERO 21CC 61 PUSH2 0x21d7 21CF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21C1 stack[0] = 0x00 // @21C6 stack[1] = stack[-1] & 0xff // } // Block ends with conditional jump to 0x21d7, if !(stack[-1] & 0xff == 0xff) label_21D0: // Incoming jump from 0x21CF, if not !(stack[-1] & 0xff == 0xff) 21D0 61 PUSH2 0x21d7 21D3 61 PUSH2 0x21f4 21D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @21D0 stack[0] = 0x21d7 } // Block ends with unconditional jump to 0x21f4 label_21D7: // Incoming jump from 0x21CF, if !(stack[-1] & 0xff == 0xff) // Inputs[3] // { // @21DA stack[-1] // @21DB stack[-4] // @21DC stack[-3] // } 21D7 5B JUMPDEST 21D8 60 PUSH1 0x01 21DA 01 ADD 21DB 92 SWAP3 21DC 91 SWAP2 21DD 50 POP 21DE 50 POP 21DF 56 *JUMP // Stack delta = -3 // Outputs[1] { @21DB stack[-4] = 0x01 + stack[-1] } // Block ends with unconditional jump to stack[-4] label_21E0: // Incoming call from 0x1434, returns to 0x1435 // Inputs[1] { @21E3 stack[-2] } 21E0 5B JUMPDEST 21E1 60 PUSH1 0x00 21E3 82 DUP3 21E4 61 PUSH2 0x21ef 21E7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21E1 stack[0] = 0x00 } // Block ends with conditional jump to 0x21ef, if stack[-2] label_21E8: // Incoming jump from 0x21E7, if not stack[-2] 21E8 61 PUSH2 0x21ef 21EB 61 PUSH2 0x220a 21EE 56 *JUMP // Stack delta = +1 // Outputs[1] { @21E8 stack[0] = 0x21ef } // Block ends with unconditional jump to 0x220a label_21EF: // Incoming jump from 0x21E7, if stack[-2] // Inputs[3] // { // @21F1 stack[-3] // @21F1 stack[-2] // @21F2 stack[-4] // } 21EF 5B JUMPDEST 21F0 50 POP 21F1 06 MOD 21F2 90 SWAP1 21F3 56 *JUMP // Stack delta = -3 // Outputs[1] { @21F2 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_21F4: // Incoming jump from 0x21D6 // Incoming jump from 0x20DC // Incoming jump from 0x21B8 // Incoming jump from 0x2107 // Inputs[1] { @2209 memory[0x00:0x24] } 21F4 5B JUMPDEST 21F5 63 PUSH4 0x4e487b71 21FA 60 PUSH1 0xe0 21FC 1B SHL 21FD 60 PUSH1 0x00 21FF 52 MSTORE 2200 60 PUSH1 0x11 2202 60 PUSH1 0x04 2204 52 MSTORE 2205 60 PUSH1 0x24 2207 60 PUSH1 0x00 2209 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @21FF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2204 memory[0x04:0x24] = 0x11 // @2209 revert(memory[0x00:0x24]); // } // Block terminates label_220A: // Incoming jump from 0x21EE // Incoming jump from 0x20F0 // Inputs[1] { @221F memory[0x00:0x24] } 220A 5B JUMPDEST 220B 63 PUSH4 0x4e487b71 2210 60 PUSH1 0xe0 2212 1B SHL 2213 60 PUSH1 0x00 2215 52 MSTORE 2216 60 PUSH1 0x12 2218 60 PUSH1 0x04 221A 52 MSTORE 221B 60 PUSH1 0x24 221D 60 PUSH1 0x00 221F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2215 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @221A memory[0x04:0x24] = 0x12 // @221F revert(memory[0x00:0x24]); // } // Block terminates label_2220: // Incoming jump from 0x1B26 // Incoming jump from 0x219D // Incoming jump from 0x20BF // Inputs[1] { @2235 memory[0x00:0x24] } 2220 5B JUMPDEST 2221 63 PUSH4 0x4e487b71 2226 60 PUSH1 0xe0 2228 1B SHL 2229 60 PUSH1 0x00 222B 52 MSTORE 222C 60 PUSH1 0x41 222E 60 PUSH1 0x04 2230 52 MSTORE 2231 60 PUSH1 0x24 2233 60 PUSH1 0x00 2235 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @222B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2230 memory[0x04:0x24] = 0x41 // @2235 revert(memory[0x00:0x24]); // } // Block terminates 2236 5B JUMPDEST 2237 60 PUSH1 0x00 2239 60 PUSH1 0x03 223B 3D RETURNDATASIZE 223C 11 GT 223D 15 ISZERO 223E 61 PUSH2 0x224b 2241 57 *JUMPI 2242 60 PUSH1 0x04 2244 81 DUP2 2245 82 DUP3 2246 3E RETURNDATACOPY 2247 51 MLOAD 2248 60 PUSH1 0xe0 224A 1C SHR 224B 5B JUMPDEST 224C 90 SWAP1 224D 56 *JUMP 224E 5B JUMPDEST 224F 60 PUSH1 0x00 2251 60 PUSH1 0x44 2253 3D RETURNDATASIZE 2254 10 LT 2255 15 ISZERO 2256 61 PUSH2 0x225c 2259 57 *JUMPI 225A 90 SWAP1 225B 56 *JUMP 225C 5B JUMPDEST 225D 60 PUSH1 0x40 225F 51 MLOAD 2260 60 PUSH1 0x03 2262 19 NOT 2263 3D RETURNDATASIZE 2264 81 DUP2 2265 01 ADD 2266 60 PUSH1 0x04 2268 83 DUP4 2269 3E RETURNDATACOPY 226A 81 DUP2 226B 51 MLOAD 226C 3D RETURNDATASIZE 226D 67 PUSH8 0xffffffffffffffff 2276 81 DUP2 2277 60 PUSH1 0x24 2279 84 DUP5 227A 01 ADD 227B 11 GT 227C 81 DUP2 227D 84 DUP5 227E 11 GT 227F 17 OR 2280 15 ISZERO 2281 61 PUSH2 0x228c 2284 57 *JUMPI 2285 50 POP 2286 50 POP 2287 50 POP 2288 50 POP 2289 50 POP 228A 90 SWAP1 228B 56 *JUMP 228C 5B JUMPDEST 228D 82 DUP3 228E 85 DUP6 228F 01 ADD 2290 91 SWAP2 2291 50 POP 2292 81 DUP2 2293 51 MLOAD 2294 81 DUP2 2295 81 DUP2 2296 11 GT 2297 15 ISZERO 2298 61 PUSH2 0x22a4 229B 57 *JUMPI 229C 50 POP 229D 50 POP 229E 50 POP 229F 50 POP 22A0 50 POP 22A1 50 POP 22A2 90 SWAP1 22A3 56 *JUMP 22A4 5B JUMPDEST 22A5 84 DUP5 22A6 3D RETURNDATASIZE 22A7 87 DUP8 22A8 01 ADD 22A9 01 ADD 22AA 60 PUSH1 0x20 22AC 82 DUP3 22AD 85 DUP6 22AE 01 ADD 22AF 01 ADD 22B0 11 GT 22B1 15 ISZERO 22B2 61 PUSH2 0x22be 22B5 57 *JUMPI 22B6 50 POP 22B7 50 POP 22B8 50 POP 22B9 50 POP 22BA 50 POP 22BB 50 POP 22BC 90 SWAP1 22BD 56 *JUMP 22BE 5B JUMPDEST 22BF 61 PUSH2 0x22cd 22C2 60 PUSH1 0x20 22C4 82 DUP3 22C5 86 DUP7 22C6 01 ADD 22C7 01 ADD 22C8 87 DUP8 22C9 61 PUSH2 0x2178 22CC 56 *JUMP 22CD 5B JUMPDEST 22CE 50 POP 22CF 90 SWAP1 22D0 95 SWAP6 22D1 94 SWAP5 22D2 50 POP 22D3 50 POP 22D4 50 POP 22D5 50 POP 22D6 50 POP 22D7 56 *JUMP label_22D8: // Incoming call from 0x1E7A, returns to 0x1B86 // Inputs[1] { @22E2 stack[-1] } 22D8 5B JUMPDEST 22D9 60 PUSH1 0x01 22DB 60 PUSH1 0x01 22DD 60 PUSH1 0xe0 22DF 1B SHL 22E0 03 SUB 22E1 19 NOT 22E2 81 DUP2 22E3 16 AND 22E4 81 DUP2 22E5 14 EQ 22E6 61 PUSH2 0x0f34 22E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f34, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_22EA: // Incoming jump from 0x22E9, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @22ED memory[0x00:0x00] } 22EA 60 PUSH1 0x00 22EC 80 DUP1 22ED FD *REVERT // Stack delta = +0 // Outputs[1] { @22ED revert(memory[0x00:0x00]); } // Block terminates 22EE FE *ASSERT 22EF A2 LOG2 22F0 64 PUSH5 0x6970667358 22F6 22 22 22F7 12 SLT 22F8 20 SHA3 22F9 07 SMOD 22FA 80 DUP1 22FB 81 DUP2 22FC A7 A7 22FD 96 SWAP7 22FE BC BC 22FF 8E DUP15 2300 45 GASLIMIT 2301 C7 C7 2302 5C 5C 2303 AF AF 2304 91 SWAP2 2305 A3 LOG3 2306 91 SWAP2 2307 A9 A9 2308 96 SWAP7 2309 28 28 230A CB CB 230B FC FC 230C 04 DIV 230D F7 F7 230E 82 DUP3 230F 87 DUP8 2310 76 PUSH23 0xb4b843ab76fa505d64736f6c63430008040033