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 0x018d 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x018d, 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 0x70a08231 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 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa22cb465 0031 11 GT 0032 61 PUSH2 0x008c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008c, if 0xa22cb465 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xd547cfb7 003C 11 GT 003D 61 PUSH2 0x0066 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0066, if 0xd547cfb7 > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xd547cfb7 > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xd547cfb7 0047 14 EQ 0048 61 PUSH2 0x0310 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0310, if 0xd547cfb7 == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xd547cfb7 == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe985e9c5 0052 14 EQ 0053 61 PUSH2 0x0318 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0318, if 0xe985e9c5 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x0354 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0354, 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 0xd547cfb7 > stack[-1] // Inputs[1] { @0067 stack[-1] } 0066 5B JUMPDEST 0067 80 DUP1 0068 63 PUSH4 0xa22cb465 006D 14 EQ 006E 61 PUSH2 0x02d7 0071 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02d7, if 0xa22cb465 == stack[-1] label_0072: // Incoming jump from 0x0071, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0072 stack[-1] } 0072 80 DUP1 0073 63 PUSH4 0xb88d4fde 0078 14 EQ 0079 61 PUSH2 0x02ea 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ea, if 0xb88d4fde == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xb88d4fde == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xc87b56dd 0083 14 EQ 0084 61 PUSH2 0x02fd 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fd, if 0xc87b56dd == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xc87b56dd == 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 0xa22cb465 > stack[-1] // Inputs[1] { @008D stack[-1] } 008C 5B JUMPDEST 008D 80 DUP1 008E 63 PUSH4 0x85a96af8 0093 11 GT 0094 61 PUSH2 0x00bd 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bd, if 0x85a96af8 > stack[-1] label_0098: // Incoming jump from 0x0097, if not 0x85a96af8 > stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0x85a96af8 009E 14 EQ 009F 61 PUSH2 0x02ab 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ab, if 0x85a96af8 == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x85a96af8 == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x8da5cb5b 00A9 14 EQ 00AA 61 PUSH2 0x02be 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02be, if 0x8da5cb5b == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x95d89b41 00B4 14 EQ 00B5 61 PUSH2 0x02cf 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cf, if 0x95d89b41 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x95d89b41 == 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 0x85a96af8 > stack[-1] // Inputs[1] { @00BE stack[-1] } 00BD 5B JUMPDEST 00BE 80 DUP1 00BF 63 PUSH4 0x70a08231 00C4 14 EQ 00C5 61 PUSH2 0x027d 00C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027d, if 0x70a08231 == stack[-1] label_00C9: // Incoming jump from 0x00C8, if not 0x70a08231 == stack[-1] // Inputs[1] { @00C9 stack[-1] } 00C9 80 DUP1 00CA 63 PUSH4 0x715018a6 00CF 14 EQ 00D0 61 PUSH2 0x0290 00D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0290, if 0x715018a6 == stack[-1] label_00D4: // Incoming jump from 0x00D3, if not 0x715018a6 == stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D4 80 DUP1 00D5 63 PUSH4 0x82d95df5 00DA 14 EQ 00DB 61 PUSH2 0x0298 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0298, if 0x82d95df5 == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x82d95df5 == 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 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00E4 stack[-1] } 00E3 5B JUMPDEST 00E4 80 DUP1 00E5 63 PUSH4 0x18160ddd 00EA 11 GT 00EB 61 PUSH2 0x0145 00EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0145, if 0x18160ddd > stack[-1] label_00EF: // Incoming jump from 0x00EE, if not 0x18160ddd > stack[-1] // Inputs[1] { @00EF stack[-1] } 00EF 80 DUP1 00F0 63 PUSH4 0x42842e0e 00F5 11 GT 00F6 61 PUSH2 0x011f 00F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011f, if 0x42842e0e > stack[-1] label_00FA: // Incoming jump from 0x00F9, if not 0x42842e0e > stack[-1] // Inputs[1] { @00FA stack[-1] } 00FA 80 DUP1 00FB 63 PUSH4 0x42842e0e 0100 14 EQ 0101 61 PUSH2 0x024f 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024f, if 0x42842e0e == stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x42842e0e == stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x6352211e 010B 14 EQ 010C 61 PUSH2 0x0262 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0262, if 0x6352211e == stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x6352211e == stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x64f65cc0 0116 14 EQ 0117 61 PUSH2 0x0275 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0275, if 0x64f65cc0 == stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x64f65cc0 == 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 0x42842e0e > stack[-1] // Inputs[1] { @0120 stack[-1] } 011F 5B JUMPDEST 0120 80 DUP1 0121 63 PUSH4 0x18160ddd 0126 14 EQ 0127 61 PUSH2 0x0217 012A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0217, if 0x18160ddd == stack[-1] label_012B: // Incoming jump from 0x012A, if not 0x18160ddd == stack[-1] // Inputs[1] { @012B stack[-1] } 012B 80 DUP1 012C 63 PUSH4 0x23b872dd 0131 14 EQ 0132 61 PUSH2 0x0229 0135 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0229, if 0x23b872dd == stack[-1] label_0136: // Incoming jump from 0x0135, if not 0x23b872dd == stack[-1] // Inputs[1] { @0136 stack[-1] } 0136 80 DUP1 0137 63 PUSH4 0x30176e13 013C 14 EQ 013D 61 PUSH2 0x023c 0140 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023c, if 0x30176e13 == stack[-1] label_0141: // Incoming jump from 0x0140, if not 0x30176e13 == 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 0x18160ddd > stack[-1] // Inputs[1] { @0146 stack[-1] } 0145 5B JUMPDEST 0146 80 DUP1 0147 63 PUSH4 0x081812fc 014C 11 GT 014D 61 PUSH2 0x0176 0150 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0176, if 0x081812fc > stack[-1] label_0151: // Incoming jump from 0x0150, if not 0x081812fc > stack[-1] // Inputs[1] { @0151 stack[-1] } 0151 80 DUP1 0152 63 PUSH4 0x081812fc 0157 14 EQ 0158 61 PUSH2 0x01cf 015B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cf, if 0x081812fc == stack[-1] label_015C: // Incoming jump from 0x015B, if not 0x081812fc == stack[-1] // Inputs[1] { @015C stack[-1] } 015C 80 DUP1 015D 63 PUSH4 0x095ea7b3 0162 14 EQ 0163 61 PUSH2 0x01fa 0166 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fa, if 0x095ea7b3 == stack[-1] label_0167: // Incoming jump from 0x0166, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0167 stack[-1] } 0167 80 DUP1 0168 63 PUSH4 0x1249c58b 016D 14 EQ 016E 61 PUSH2 0x020f 0171 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020f, if 0x1249c58b == stack[-1] label_0172: // Incoming jump from 0x0171, if not 0x1249c58b == 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 0x081812fc > stack[-1] // Inputs[1] { @0177 stack[-1] } 0176 5B JUMPDEST 0177 80 DUP1 0178 63 PUSH4 0x01ffc9a7 017D 14 EQ 017E 61 PUSH2 0x0192 0181 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0192, if 0x01ffc9a7 == stack[-1] label_0182: // Incoming jump from 0x0181, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0182 stack[-1] } 0182 80 DUP1 0183 63 PUSH4 0x06fdde03 0188 14 EQ 0189 61 PUSH2 0x01ba 018C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ba, if 0x06fdde03 == stack[-1] label_018D: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x018C, if not 0x06fdde03 == stack[-1] // Inputs[1] { @0191 memory[0x00:0x00] } 018D 5B JUMPDEST 018E 60 PUSH1 0x00 0190 80 DUP1 0191 FD *REVERT // Stack delta = +0 // Outputs[1] { @0191 revert(memory[0x00:0x00]); } // Block terminates label_0192: // Incoming jump from 0x0181, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0199 msg.data.length } 0192 5B JUMPDEST 0193 61 PUSH2 0x01a5 0196 61 PUSH2 0x01a0 0199 36 CALLDATASIZE 019A 60 PUSH1 0x04 019C 61 PUSH2 0x1a5a 019F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0193 stack[0] = 0x01a5 // @0196 stack[1] = 0x01a0 // @0199 stack[2] = msg.data.length // @019A stack[3] = 0x04 // } // Block ends with call to 0x1a5a, returns to 0x01A0 label_01A0: // Incoming return from call to 0x1A5A at 0x019F 01A0 5B JUMPDEST 01A1 61 PUSH2 0x0367 01A4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0367 label_01A5: // Incoming return from call to 0x01A0 at 0x019F // Incoming return from call to 0x0326 at 0x0325 // Inputs[2] // { // @01A8 memory[0x40:0x60] // @01A9 stack[-1] // } 01A5 5B JUMPDEST 01A6 60 PUSH1 0x40 01A8 51 MLOAD 01A9 90 SWAP1 01AA 15 ISZERO 01AB 15 ISZERO 01AC 81 DUP2 01AD 52 MSTORE 01AE 60 PUSH1 0x20 01B0 01 ADD // Stack delta = +0 // Outputs[2] // { // @01AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01B0 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_01B1: // Incoming jump from 0x0228 // Incoming jump from 0x0228 // Incoming jump from 0x01F9 // Incoming jump from 0x01B0 // Inputs[3] // { // @01B4 memory[0x40:0x60] // @01B6 stack[-1] // @01B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01B1 5B JUMPDEST 01B2 60 PUSH1 0x40 01B4 51 MLOAD 01B5 80 DUP1 01B6 91 SWAP2 01B7 03 SUB 01B8 90 SWAP1 01B9 F3 *RETURN // Stack delta = -1 // Outputs[1] { @01B9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_01BA: // Incoming jump from 0x018C, if 0x06fdde03 == stack[-1] 01BA 5B JUMPDEST 01BB 61 PUSH2 0x01c2 01BE 61 PUSH2 0x044c 01C1 56 *JUMP // Stack delta = +1 // Outputs[1] { @01BB stack[0] = 0x01c2 } // Block ends with call to 0x044c, returns to 0x01C2 label_01C2: // Incoming return from call to 0x030B at 0x030A // Incoming return from call to 0x0C8A at 0x02D6 // Incoming return from call to 0x044C at 0x01C1 // Incoming return from call to 0x0F0B at 0x0317 // Inputs[2] // { // @01C5 memory[0x40:0x60] // @01C9 stack[-1] // } 01C2 5B JUMPDEST 01C3 60 PUSH1 0x40 01C5 51 MLOAD 01C6 61 PUSH2 0x01b1 01C9 91 SWAP2 01CA 90 SWAP1 01CB 61 PUSH2 0x1b7f 01CE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01C9 stack[-1] = 0x01b1 // @01CA stack[1] = memory[0x40:0x60] // @01CA stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1b7f label_01CF: // Incoming jump from 0x015B, if 0x081812fc == stack[-1] // Inputs[1] { @01D6 msg.data.length } 01CF 5B JUMPDEST 01D0 61 PUSH2 0x01e2 01D3 61 PUSH2 0x01dd 01D6 36 CALLDATASIZE 01D7 60 PUSH1 0x04 01D9 61 PUSH2 0x1add 01DC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D0 stack[0] = 0x01e2 // @01D3 stack[1] = 0x01dd // @01D6 stack[2] = msg.data.length // @01D7 stack[3] = 0x04 // } // Block ends with call to 0x1add, returns to 0x01DD label_01DD: // Incoming return from call to 0x1ADD at 0x01DC 01DD 5B JUMPDEST 01DE 61 PUSH2 0x04de 01E1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04de label_01E2: // Incoming return from call to 0x0270 at 0x026F // Incoming jump from 0x02CE // Incoming return from call to 0x01DD at 0x01DC // Inputs[2] // { // @01E5 memory[0x40:0x60] // @01EF stack[-1] // } 01E2 5B JUMPDEST 01E3 60 PUSH1 0x40 01E5 51 MLOAD 01E6 60 PUSH1 0x01 01E8 60 PUSH1 0x01 01EA 60 PUSH1 0xa0 01EC 1B SHL 01ED 03 SUB 01EE 90 SWAP1 01EF 91 SWAP2 01F0 16 AND 01F1 81 DUP2 01F2 52 MSTORE 01F3 60 PUSH1 0x20 01F5 01 ADD 01F6 61 PUSH2 0x01b1 01F9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @01F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @01F5 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01b1 label_01FA: // Incoming jump from 0x0166, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0201 msg.data.length } 01FA 5B JUMPDEST 01FB 61 PUSH2 0x020d 01FE 61 PUSH2 0x0208 0201 36 CALLDATASIZE 0202 60 PUSH1 0x04 0204 61 PUSH2 0x1a15 0207 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01FB stack[0] = 0x020d // @01FE stack[1] = 0x0208 // @0201 stack[2] = msg.data.length // @0202 stack[3] = 0x04 // } // Block ends with call to 0x1a15, returns to 0x0208 label_0208: // Incoming return from call to 0x1A15 at 0x0207 0208 5B JUMPDEST 0209 61 PUSH2 0x0589 020C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0589 label_020D: // Incoming return from call to 0x09E6 at 0x027C // Incoming return from call to 0x02A6 at 0x02A5 // Incoming return from call to 0x06BB at 0x0216 // Incoming return from call to 0x0362 at 0x0361 // Incoming return from call to 0x0208 at 0x0207 // Incoming return from call to 0x02E5 at 0x02E4 // Incoming return from call to 0x0AE9 at 0x0297 // Incoming return from call to 0x02B9 at 0x02B8 020D 5B JUMPDEST 020E 00 *STOP // Stack delta = +0 // Outputs[1] { @020E stop(); } // Block terminates label_020F: // Incoming jump from 0x0171, if 0x1249c58b == stack[-1] 020F 5B JUMPDEST 0210 61 PUSH2 0x020d 0213 61 PUSH2 0x06bb 0216 56 *JUMP // Stack delta = +1 // Outputs[1] { @0210 stack[0] = 0x020d } // Block ends with call to 0x06bb, returns to 0x020D label_0217: // Incoming jump from 0x012A, if 0x18160ddd == stack[-1] // Inputs[2] // { // @021A storage[0x07] // @021E memory[0x40:0x60] // } 0217 5B JUMPDEST 0218 60 PUSH1 0x07 021A 54 SLOAD 021B 5B JUMPDEST 021C 60 PUSH1 0x40 021E 51 MLOAD 021F 90 SWAP1 0220 81 DUP2 0221 52 MSTORE 0222 60 PUSH1 0x20 0224 01 ADD 0225 61 PUSH2 0x01b1 0228 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0221 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x07] // @0224 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01b1 label_0229: // Incoming jump from 0x0135, if 0x23b872dd == stack[-1] // Inputs[1] { @0230 msg.data.length } 0229 5B JUMPDEST 022A 61 PUSH2 0x020d 022D 61 PUSH2 0x0237 0230 36 CALLDATASIZE 0231 60 PUSH1 0x04 0233 61 PUSH2 0x1933 0236 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @022A stack[0] = 0x020d // @022D stack[1] = 0x0237 // @0230 stack[2] = msg.data.length // @0231 stack[3] = 0x04 // } // Block ends with call to 0x1933, returns to 0x0237 label_0237: // Incoming return from call to 0x1933 at 0x0236 0237 5B JUMPDEST 0238 61 PUSH2 0x0848 023B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0848 label_023C: // Incoming jump from 0x0140, if 0x30176e13 == stack[-1] // Inputs[1] { @0243 msg.data.length } 023C 5B JUMPDEST 023D 61 PUSH2 0x020d 0240 61 PUSH2 0x024a 0243 36 CALLDATASIZE 0244 60 PUSH1 0x04 0246 61 PUSH2 0x1a94 0249 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023D stack[0] = 0x020d // @0240 stack[1] = 0x024a // @0243 stack[2] = msg.data.length // @0244 stack[3] = 0x04 // } // Block ends with call to 0x1a94, returns to 0x024A label_024A: // Incoming return from call to 0x1A94 at 0x0249 024A 5B JUMPDEST 024B 61 PUSH2 0x08cf 024E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08cf label_024F: // Incoming jump from 0x0104, if 0x42842e0e == stack[-1] // Inputs[1] { @0256 msg.data.length } 024F 5B JUMPDEST 0250 61 PUSH2 0x020d 0253 61 PUSH2 0x025d 0256 36 CALLDATASIZE 0257 60 PUSH1 0x04 0259 61 PUSH2 0x1933 025C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0250 stack[0] = 0x020d // @0253 stack[1] = 0x025d // @0256 stack[2] = msg.data.length // @0257 stack[3] = 0x04 // } // Block ends with call to 0x1933, returns to 0x025D label_025D: // Incoming return from call to 0x1933 at 0x025C 025D 5B JUMPDEST 025E 61 PUSH2 0x0940 0261 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0940 label_0262: // Incoming jump from 0x010F, if 0x6352211e == stack[-1] // Inputs[1] { @0269 msg.data.length } 0262 5B JUMPDEST 0263 61 PUSH2 0x01e2 0266 61 PUSH2 0x0270 0269 36 CALLDATASIZE 026A 60 PUSH1 0x04 026C 61 PUSH2 0x1add 026F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0263 stack[0] = 0x01e2 // @0266 stack[1] = 0x0270 // @0269 stack[2] = msg.data.length // @026A stack[3] = 0x04 // } // Block ends with call to 0x1add, returns to 0x0270 label_0270: // Incoming return from call to 0x1ADD at 0x026F 0270 5B JUMPDEST 0271 61 PUSH2 0x095b 0274 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x095b label_0275: // Incoming jump from 0x011A, if 0x64f65cc0 == stack[-1] 0275 5B JUMPDEST 0276 61 PUSH2 0x020d 0279 61 PUSH2 0x09e6 027C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0276 stack[0] = 0x020d } // Block ends with call to 0x09e6, returns to 0x020D label_027D: // Incoming jump from 0x00C8, if 0x70a08231 == stack[-1] // Inputs[1] { @0284 msg.data.length } 027D 5B JUMPDEST 027E 61 PUSH2 0x021b 0281 61 PUSH2 0x028b 0284 36 CALLDATASIZE 0285 60 PUSH1 0x04 0287 61 PUSH2 0x18de 028A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @027E stack[0] = 0x021b // @0281 stack[1] = 0x028b // @0284 stack[2] = msg.data.length // @0285 stack[3] = 0x04 // } // Block ends with call to 0x18de, returns to 0x028B label_028B: // Incoming return from call to 0x18DE at 0x028A 028B 5B JUMPDEST 028C 61 PUSH2 0x0a4f 028F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a4f label_0290: // Incoming jump from 0x00D3, if 0x715018a6 == stack[-1] 0290 5B JUMPDEST 0291 61 PUSH2 0x020d 0294 61 PUSH2 0x0ae9 0297 56 *JUMP // Stack delta = +1 // Outputs[1] { @0291 stack[0] = 0x020d } // Block ends with call to 0x0ae9, returns to 0x020D label_0298: // Incoming jump from 0x00DE, if 0x82d95df5 == stack[-1] // Inputs[1] { @029F msg.data.length } 0298 5B JUMPDEST 0299 61 PUSH2 0x020d 029C 61 PUSH2 0x02a6 029F 36 CALLDATASIZE 02A0 60 PUSH1 0x04 02A2 61 PUSH2 0x1add 02A5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0299 stack[0] = 0x020d // @029C stack[1] = 0x02a6 // @029F stack[2] = msg.data.length // @02A0 stack[3] = 0x04 // } // Block ends with call to 0x1add, returns to 0x02A6 label_02A6: // Incoming return from call to 0x1ADD at 0x02A5 02A6 5B JUMPDEST 02A7 61 PUSH2 0x0b9a 02AA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b9a label_02AB: // Incoming jump from 0x00A2, if 0x85a96af8 == stack[-1] // Inputs[1] { @02B2 msg.data.length } 02AB 5B JUMPDEST 02AC 61 PUSH2 0x020d 02AF 61 PUSH2 0x02b9 02B2 36 CALLDATASIZE 02B3 60 PUSH1 0x04 02B5 61 PUSH2 0x1a3f 02B8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02AC stack[0] = 0x020d // @02AF stack[1] = 0x02b9 // @02B2 stack[2] = msg.data.length // @02B3 stack[3] = 0x04 // } // Block ends with call to 0x1a3f, returns to 0x02B9 label_02B9: // Incoming return from call to 0x1A3F at 0x02B8 02B9 5B JUMPDEST 02BA 61 PUSH2 0x0bf9 02BD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bf9 label_02BE: // Incoming jump from 0x00AD, if 0x8da5cb5b == stack[-1] // Inputs[1] { @02C1 storage[0x06] } 02BE 5B JUMPDEST 02BF 60 PUSH1 0x06 02C1 54 SLOAD 02C2 60 PUSH1 0x01 02C4 60 PUSH1 0x01 02C6 60 PUSH1 0xa0 02C8 1B SHL 02C9 03 SUB 02CA 16 AND 02CB 61 PUSH2 0x01e2 02CE 56 *JUMP // Stack delta = +1 // Outputs[1] { @02CA stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x06] } // Block ends with unconditional jump to 0x01e2 label_02CF: // Incoming jump from 0x00B8, if 0x95d89b41 == stack[-1] 02CF 5B JUMPDEST 02D0 61 PUSH2 0x01c2 02D3 61 PUSH2 0x0c8a 02D6 56 *JUMP // Stack delta = +1 // Outputs[1] { @02D0 stack[0] = 0x01c2 } // Block ends with call to 0x0c8a, returns to 0x01C2 label_02D7: // Incoming jump from 0x0071, if 0xa22cb465 == stack[-1] // Inputs[1] { @02DE msg.data.length } 02D7 5B JUMPDEST 02D8 61 PUSH2 0x020d 02DB 61 PUSH2 0x02e5 02DE 36 CALLDATASIZE 02DF 60 PUSH1 0x04 02E1 61 PUSH2 0x19eb 02E4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02D8 stack[0] = 0x020d // @02DB stack[1] = 0x02e5 // @02DE stack[2] = msg.data.length // @02DF stack[3] = 0x04 // } // Block ends with call to 0x19eb, returns to 0x02E5 label_02E5: // Incoming return from call to 0x19EB at 0x02E4 02E5 5B JUMPDEST 02E6 61 PUSH2 0x0c99 02E9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c99 label_02EA: // Incoming jump from 0x007C, if 0xb88d4fde == stack[-1] // Inputs[1] { @02F1 msg.data.length } 02EA 5B JUMPDEST 02EB 61 PUSH2 0x020d 02EE 61 PUSH2 0x02f8 02F1 36 CALLDATASIZE 02F2 60 PUSH1 0x04 02F4 61 PUSH2 0x196f 02F7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02EB stack[0] = 0x020d // @02EE stack[1] = 0x02f8 // @02F1 stack[2] = msg.data.length // @02F2 stack[3] = 0x04 // } // Block ends with call to 0x196f, returns to 0x02F8 label_02F8: // Incoming return from call to 0x196F at 0x02F7 02F8 5B JUMPDEST 02F9 61 PUSH2 0x0d5e 02FC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d5e label_02FD: // Incoming jump from 0x0087, if 0xc87b56dd == stack[-1] // Inputs[1] { @0304 msg.data.length } 02FD 5B JUMPDEST 02FE 61 PUSH2 0x01c2 0301 61 PUSH2 0x030b 0304 36 CALLDATASIZE 0305 60 PUSH1 0x04 0307 61 PUSH2 0x1add 030A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02FE stack[0] = 0x01c2 // @0301 stack[1] = 0x030b // @0304 stack[2] = msg.data.length // @0305 stack[3] = 0x04 // } // Block ends with call to 0x1add, returns to 0x030B label_030B: // Incoming return from call to 0x1ADD at 0x030A 030B 5B JUMPDEST 030C 61 PUSH2 0x0dec 030F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dec label_0310: // Incoming jump from 0x004B, if 0xd547cfb7 == stack[-1] 0310 5B JUMPDEST 0311 61 PUSH2 0x01c2 0314 61 PUSH2 0x0f0b 0317 56 *JUMP // Stack delta = +1 // Outputs[1] { @0311 stack[0] = 0x01c2 } // Block ends with call to 0x0f0b, returns to 0x01C2 label_0318: // Incoming jump from 0x0056, if 0xe985e9c5 == stack[-1] // Inputs[1] { @031F msg.data.length } 0318 5B JUMPDEST 0319 61 PUSH2 0x01a5 031C 61 PUSH2 0x0326 031F 36 CALLDATASIZE 0320 60 PUSH1 0x04 0322 61 PUSH2 0x1900 0325 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0319 stack[0] = 0x01a5 // @031C stack[1] = 0x0326 // @031F stack[2] = msg.data.length // @0320 stack[3] = 0x04 // } // Block ends with call to 0x1900, returns to 0x0326 label_0326: // Incoming call from 0x0639, returns to 0x063A // Incoming return from call to 0x1900 at 0x0325 // Inputs[6] // { // @032F stack[-2] // @0342 memory[0x00:0x40] // @0343 stack[-1] // @034D memory[0x00:0x40] // @034E storage[keccak256(memory[0x00:0x40])] // @0352 stack[-3] // } 0326 5B JUMPDEST 0327 60 PUSH1 0x01 0329 60 PUSH1 0x01 032B 60 PUSH1 0xa0 032D 1B SHL 032E 03 SUB 032F 91 SWAP2 0330 82 DUP3 0331 16 AND 0332 60 PUSH1 0x00 0334 90 SWAP1 0335 81 DUP2 0336 52 MSTORE 0337 60 PUSH1 0x05 0339 60 PUSH1 0x20 033B 90 SWAP1 033C 81 DUP2 033D 52 MSTORE 033E 60 PUSH1 0x40 0340 80 DUP1 0341 83 DUP4 0342 20 SHA3 0343 93 SWAP4 0344 90 SWAP1 0345 94 SWAP5 0346 16 AND 0347 82 DUP3 0348 52 MSTORE 0349 91 SWAP2 034A 90 SWAP1 034B 91 SWAP2 034C 52 MSTORE 034D 20 SHA3 034E 54 SLOAD 034F 60 PUSH1 0xff 0351 16 AND 0352 90 SWAP1 0353 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0336 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @033D memory[0x20:0x40] = 0x05 // @0348 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @034C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0352 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0354: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @035B msg.data.length } 0354 5B JUMPDEST 0355 61 PUSH2 0x020d 0358 61 PUSH2 0x0362 035B 36 CALLDATASIZE 035C 60 PUSH1 0x04 035E 61 PUSH2 0x18de 0361 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0355 stack[0] = 0x020d // @0358 stack[1] = 0x0362 // @035B stack[2] = msg.data.length // @035C stack[3] = 0x04 // } // Block ends with call to 0x18de, returns to 0x0362 label_0362: // Incoming return from call to 0x18DE at 0x0361 0362 5B JUMPDEST 0363 61 PUSH2 0x0f1a 0366 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f1a label_0367: // Incoming jump from 0x01A4 // Inputs[1] { @038B stack[-1] } 0367 5B JUMPDEST 0368 60 PUSH1 0x00 036A 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 038B 82 DUP3 038C 16 AND 038D 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 03AE 14 EQ 03AF 80 DUP1 03B0 61 PUSH2 0x03fa 03B3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0368 stack[0] = 0x00 // @03AE stack[1] = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x03fa, if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_03B4: // Incoming jump from 0x03B3, if not 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @03D6 stack[-3] } 03B4 50 POP 03B5 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 03D6 82 DUP3 03D7 16 AND 03D8 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 03F9 14 EQ 03FA 5B JUMPDEST 03FB 80 DUP1 03FC 61 PUSH2 0x0446 03FF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03F9 stack[-1] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 } // Block ends with conditional jump to 0x0446, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_0400: // Incoming jump from 0x03FF, if not 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x03FF, if not stack[-1] // Inputs[1] { @0443 stack[-3] } 0400 50 POP 0401 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 0422 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 0443 83 DUP4 0444 16 AND 0445 14 EQ // Stack delta = +0 // Outputs[1] { @0445 stack[-1] = stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block continues label_0446: // Incoming jump from 0x03FF, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x0445 // Incoming jump from 0x0978, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x03FF, if stack[-1] // Inputs[3] // { // @0447 stack[-1] // @0447 stack[-4] // @0448 stack[-3] // } 0446 5B JUMPDEST 0447 92 SWAP3 0448 91 SWAP2 0449 50 POP 044A 50 POP 044B 56 *JUMP // Stack delta = -3 // Outputs[1] { @0447 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_044C: // Incoming call from 0x01C1, returns to 0x01C2 // Inputs[1] { @0452 storage[0x00] } 044C 5B JUMPDEST 044D 60 PUSH1 0x60 044F 60 PUSH1 0x00 0451 80 DUP1 0452 54 SLOAD 0453 61 PUSH2 0x045b 0456 90 SWAP1 0457 61 PUSH2 0x1bc1 045A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @044D stack[0] = 0x60 // @044F stack[1] = 0x00 // @0456 stack[2] = 0x045b // @0456 stack[3] = storage[0x00] // } // Block ends with call to 0x1bc1, returns to 0x045B label_045B: // Incoming return from call to 0x1BC1 at 0x045A // Incoming return from call to 0x1BC1 at 0x0F19 // Incoming return from call to 0x1BC1 at 0x0C98 // Inputs[4] // { // @045C stack[-1] // @046B memory[0x40:0x60] // @0473 stack[-2] // @047E storage[stack[-2]] // } 045B 5B JUMPDEST 045C 80 DUP1 045D 60 PUSH1 0x1f 045F 01 ADD 0460 60 PUSH1 0x20 0462 80 DUP1 0463 91 SWAP2 0464 04 DIV 0465 02 MUL 0466 60 PUSH1 0x20 0468 01 ADD 0469 60 PUSH1 0x40 046B 51 MLOAD 046C 90 SWAP1 046D 81 DUP2 046E 01 ADD 046F 60 PUSH1 0x40 0471 52 MSTORE 0472 80 DUP1 0473 92 SWAP3 0474 91 SWAP2 0475 90 SWAP1 0476 81 DUP2 0477 81 DUP2 0478 52 MSTORE 0479 60 PUSH1 0x20 047B 01 ADD 047C 82 DUP3 047D 80 DUP1 047E 54 SLOAD 047F 61 PUSH2 0x0487 0482 90 SWAP1 0483 61 PUSH2 0x1bc1 0486 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0471 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0473 stack[-2] = memory[0x40:0x60] // @0474 stack[-1] = stack[-2] // @0475 stack[0] = stack[-1] // @0478 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @047B stack[1] = 0x20 + memory[0x40:0x60] // @047C stack[2] = stack[-2] // @0482 stack[4] = storage[stack[-2]] // @0482 stack[3] = 0x0487 // } // Block ends with call to 0x1bc1, returns to 0x0487 label_0487: // Incoming return from call to 0x1BC1 at 0x0486 // Inputs[1] { @0488 stack[-1] } 0487 5B JUMPDEST 0488 80 DUP1 0489 15 ISZERO 048A 61 PUSH2 0x04d4 048D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d4, if !stack[-1] label_048E: // Incoming jump from 0x048D, if not !stack[-1] // Inputs[1] { @048E stack[-1] } 048E 80 DUP1 048F 60 PUSH1 0x1f 0491 10 LT 0492 61 PUSH2 0x04a9 0495 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a9, if 0x1f < stack[-1] label_0496: // Incoming jump from 0x0495, if not 0x1f < stack[-1] // Inputs[4] // { // @049A stack[-2] // @049B storage[stack[-2]] // @049E stack[-3] // @04A0 stack[-1] // } 0496 61 PUSH2 0x0100 0499 80 DUP1 049A 83 DUP4 049B 54 SLOAD 049C 04 DIV 049D 02 MUL 049E 83 DUP4 049F 52 MSTORE 04A0 91 SWAP2 04A1 60 PUSH1 0x20 04A3 01 ADD 04A4 91 SWAP2 04A5 61 PUSH2 0x04d4 04A8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @049F memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @04A4 stack[-1] = stack[-1] // @04A4 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04d4 label_04A9: // Incoming jump from 0x0495, if 0x1f < stack[-1] // Inputs[5] // { // @04AA stack[-3] // @04AB stack[-1] // @04AD stack[-2] // @04B5 memory[0x00:0x20] // @04B9 storage[keccak256(memory[0x00:0x20])] // } 04A9 5B JUMPDEST 04AA 82 DUP3 04AB 01 ADD 04AC 91 SWAP2 04AD 90 SWAP1 04AE 60 PUSH1 0x00 04B0 52 MSTORE 04B1 60 PUSH1 0x20 04B3 60 PUSH1 0x00 04B5 20 SHA3 04B6 90 SWAP1 04B7 5B JUMPDEST 04B8 81 DUP2 04B9 54 SLOAD 04BA 81 DUP2 04BB 52 MSTORE 04BC 90 SWAP1 04BD 60 PUSH1 0x01 04BF 01 ADD 04C0 90 SWAP1 04C1 60 PUSH1 0x20 04C3 01 ADD 04C4 80 DUP1 04C5 83 DUP4 04C6 11 GT 04C7 61 PUSH2 0x04b7 04CA 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @04AC stack[-3] = stack[-3] + stack[-1] // @04B0 memory[0x00:0x20] = stack[-2] // @04BB memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04C0 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04C3 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04b7, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04CB: // Incoming jump from 0x04CA, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x04CA, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @04CB stack[-3] // @04CC stack[-1] // } 04CB 82 DUP3 04CC 90 SWAP1 04CD 03 SUB 04CE 60 PUSH1 0x1f 04D0 16 AND 04D1 82 DUP3 04D2 01 ADD 04D3 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04D3 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04D3 stack[-1] = stack[-3] // } // Block continues label_04D4: // Incoming jump from 0x048D, if !stack[-1] // Incoming jump from 0x04A8 // Incoming jump from 0x04D3 // Inputs[3] // { // @04DA stack[-7] // @04DA stack[-6] // @04DC stack[-8] // } 04D4 5B JUMPDEST 04D5 50 POP 04D6 50 POP 04D7 50 POP 04D8 50 POP 04D9 50 POP 04DA 90 SWAP1 04DB 50 POP 04DC 90 SWAP1 04DD 56 *JUMP // Stack delta = -7 // Outputs[1] { @04DC stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_04DE: // Incoming jump from 0x01E1 // Incoming call from 0x12E7, returns to 0x12E8 // Inputs[3] // { // @04E1 stack[-1] // @04EC memory[0x00:0x40] // @04ED storage[keccak256(memory[0x00:0x40])] // } 04DE 5B JUMPDEST 04DF 60 PUSH1 0x00 04E1 81 DUP2 04E2 81 DUP2 04E3 52 MSTORE 04E4 60 PUSH1 0x02 04E6 60 PUSH1 0x20 04E8 52 MSTORE 04E9 60 PUSH1 0x40 04EB 81 DUP2 04EC 20 SHA3 04ED 54 SLOAD 04EE 60 PUSH1 0x01 04F0 60 PUSH1 0x01 04F2 60 PUSH1 0xa0 04F4 1B SHL 04F5 03 SUB 04F6 16 AND 04F7 61 PUSH2 0x056d 04FA 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @04DF stack[0] = 0x00 // @04E3 memory[0x00:0x20] = stack[-1] // @04E8 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x056d, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_04FB: // Incoming jump from 0x04FA, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @04FD memory[0x40:0x60] } 04FB 60 PUSH1 0x40 04FD 51 MLOAD 04FE 62 PUSH3 0x461bcd 0502 60 PUSH1 0xe5 0504 1B SHL 0505 81 DUP2 0506 52 MSTORE 0507 60 PUSH1 0x20 0509 60 PUSH1 0x04 050B 82 DUP3 050C 01 ADD 050D 52 MSTORE 050E 60 PUSH1 0x2c 0510 60 PUSH1 0x24 0512 82 DUP3 0513 01 ADD 0514 52 MSTORE 0515 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 0536 60 PUSH1 0x44 0538 82 DUP3 0539 01 ADD 053A 52 MSTORE 053B 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 055C 60 PUSH1 0x64 055E 82 DUP3 055F 01 ADD 0560 52 MSTORE 0561 60 PUSH1 0x84 0563 01 ADD // Stack delta = +1 // Outputs[6] // { // @0506 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @050D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0514 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @053A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @0560 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @0563 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0564: // Incoming jump from 0x14AA // Incoming jump from 0x07A9 // Incoming jump from 0x09E5 // Incoming jump from 0x0928 // Incoming jump from 0x1525 // Incoming jump from 0x0BF3 // Incoming jump from 0x0C52 // Incoming jump from 0x0563 // Incoming jump from 0x08C3 // Incoming jump from 0x0824 // Incoming jump from 0x118E // Incoming jump from 0x0ACC // Incoming jump from 0x0B42 // Incoming jump from 0x1387 // Incoming jump from 0x12AC // Incoming jump from 0x061D // Incoming jump from 0x0CF1 // Incoming jump from 0x0FEF // Incoming jump from 0x06AB // Incoming jump from 0x0DD9 // Incoming jump from 0x0F73 // Incoming jump from 0x0731 // Incoming jump from 0x0E78 // Incoming jump from 0x0A3F // Incoming jump from 0x1129 // Inputs[3] // { // @0567 memory[0x40:0x60] // @0569 stack[-1] // @056C memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0564 5B JUMPDEST 0565 60 PUSH1 0x40 0567 51 MLOAD 0568 80 DUP1 0569 91 SWAP2 056A 03 SUB 056B 90 SWAP1 056C FD *REVERT // Stack delta = -1 // Outputs[1] { @056C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_056D: // Incoming jump from 0x04FA, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @0571 stack[-2] // @057C memory[0x00:0x40] // @057D storage[keccak256(memory[0x00:0x40])] // @0587 stack[-3] // } 056D 5B JUMPDEST 056E 50 POP 056F 60 PUSH1 0x00 0571 90 SWAP1 0572 81 DUP2 0573 52 MSTORE 0574 60 PUSH1 0x04 0576 60 PUSH1 0x20 0578 52 MSTORE 0579 60 PUSH1 0x40 057B 90 SWAP1 057C 20 SHA3 057D 54 SLOAD 057E 60 PUSH1 0x01 0580 60 PUSH1 0x01 0582 60 PUSH1 0xa0 0584 1B SHL 0585 03 SUB 0586 16 AND 0587 90 SWAP1 0588 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0573 memory[0x00:0x20] = stack[-2] // @0578 memory[0x20:0x40] = 0x04 // @0587 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0589: // Incoming jump from 0x020C // Inputs[1] { @058F stack[-1] } 0589 5B JUMPDEST 058A 60 PUSH1 0x00 058C 61 PUSH2 0x0594 058F 82 DUP3 0590 61 PUSH2 0x095b 0593 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @058A stack[0] = 0x00 // @058C stack[1] = 0x0594 // @058F stack[2] = stack[-1] // } // Block ends with call to 0x095b, returns to 0x0594 label_0594: // Incoming return from call to 0x095B at 0x0593 // Inputs[3] // { // @0595 stack[-2] // @0595 stack[-1] // @05A1 stack[-4] // } 0594 5B JUMPDEST 0595 90 SWAP1 0596 50 POP 0597 80 DUP1 0598 60 PUSH1 0x01 059A 60 PUSH1 0x01 059C 60 PUSH1 0xa0 059E 1B SHL 059F 03 SUB 05A0 16 AND 05A1 83 DUP4 05A2 60 PUSH1 0x01 05A4 60 PUSH1 0x01 05A6 60 PUSH1 0xa0 05A8 1B SHL 05A9 03 SUB 05AA 16 AND 05AB 14 EQ 05AC 15 ISZERO 05AD 61 PUSH2 0x061e 05B0 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0595 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x061e, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_05B1: // Incoming jump from 0x05B0, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @05B3 memory[0x40:0x60] } 05B1 60 PUSH1 0x40 05B3 51 MLOAD 05B4 62 PUSH3 0x461bcd 05B8 60 PUSH1 0xe5 05BA 1B SHL 05BB 81 DUP2 05BC 52 MSTORE 05BD 60 PUSH1 0x20 05BF 60 PUSH1 0x04 05C1 82 DUP3 05C2 01 ADD 05C3 52 MSTORE 05C4 60 PUSH1 0x21 05C6 60 PUSH1 0x24 05C8 82 DUP3 05C9 01 ADD 05CA 52 MSTORE 05CB 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 05EC 60 PUSH1 0x44 05EE 82 DUP3 05EF 01 ADD 05F0 52 MSTORE 05F1 7F PUSH32 0x7200000000000000000000000000000000000000000000000000000000000000 0612 60 PUSH1 0x64 0614 82 DUP3 0615 01 ADD 0616 52 MSTORE 0617 60 PUSH1 0x84 0619 01 ADD 061A 61 PUSH2 0x0564 061D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @05BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05C3 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05CA memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @05F0 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @0616 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7200000000000000000000000000000000000000000000000000000000000000 // @0619 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_061E: // Incoming jump from 0x05B0, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @061F msg.sender // @0628 stack[-1] // } 061E 5B JUMPDEST 061F 33 CALLER 0620 60 PUSH1 0x01 0622 60 PUSH1 0x01 0624 60 PUSH1 0xa0 0626 1B SHL 0627 03 SUB 0628 82 DUP3 0629 16 AND 062A 14 EQ 062B 80 DUP1 062C 61 PUSH2 0x063a 062F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @062A stack[0] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender } // Block ends with conditional jump to 0x063a, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_0630: // Incoming jump from 0x062F, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0634 stack[-2] // @0635 msg.sender // } 0630 50 POP 0631 61 PUSH2 0x063a 0634 81 DUP2 0635 33 CALLER 0636 61 PUSH2 0x0326 0639 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0631 stack[-1] = 0x063a // @0634 stack[0] = stack[-2] // @0635 stack[1] = msg.sender // } // Block ends with call to 0x0326, returns to 0x063A label_063A: // Incoming jump from 0x062F, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x0326 at 0x0639 // Inputs[1] { @063E stack[-1] } 063A 5B JUMPDEST 063B 61 PUSH2 0x06ac 063E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06ac, if stack[-1] label_063F: // Incoming jump from 0x063E, if not stack[-1] // Inputs[1] { @0641 memory[0x40:0x60] } 063F 60 PUSH1 0x40 0641 51 MLOAD 0642 62 PUSH3 0x461bcd 0646 60 PUSH1 0xe5 0648 1B SHL 0649 81 DUP2 064A 52 MSTORE 064B 60 PUSH1 0x20 064D 60 PUSH1 0x04 064F 82 DUP3 0650 01 ADD 0651 52 MSTORE 0652 60 PUSH1 0x38 0654 60 PUSH1 0x24 0656 82 DUP3 0657 01 ADD 0658 52 MSTORE 0659 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 067A 60 PUSH1 0x44 067C 82 DUP3 067D 01 ADD 067E 52 MSTORE 067F 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 06A0 60 PUSH1 0x64 06A2 82 DUP3 06A3 01 ADD 06A4 52 MSTORE 06A5 60 PUSH1 0x84 06A7 01 ADD 06A8 61 PUSH2 0x0564 06AB 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @064A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0651 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0658 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x38 // @067E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @06A4 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 // @06A7 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_06AC: // Incoming jump from 0x063E, if stack[-1] // Inputs[2] // { // @06B0 stack[-3] // @06B1 stack[-2] // } 06AC 5B JUMPDEST 06AD 61 PUSH2 0x06b6 06B0 83 DUP4 06B1 83 DUP4 06B2 61 PUSH2 0x1059 06B5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06AD stack[0] = 0x06b6 // @06B0 stack[1] = stack[-3] // @06B1 stack[2] = stack[-2] // } // Block ends with call to 0x1059, returns to 0x06B6 label_06B6: // Incoming return from call to 0x1059 at 0x06B5 // Incoming return from call to 0x141C at 0x1392 // Inputs[1] { @06BA stack[-4] } 06B6 5B JUMPDEST 06B7 50 POP 06B8 50 POP 06B9 50 POP 06BA 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_06BB: // Incoming call from 0x0216, returns to 0x020D // Inputs[2] // { // @06BC block.timestamp // @06BF storage[0x08] // } 06BB 5B JUMPDEST 06BC 42 TIMESTAMP 06BD 60 PUSH1 0x08 06BF 54 SLOAD 06C0 10 LT 06C1 61 PUSH2 0x0732 06C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0732, if storage[0x08] < block.timestamp label_06C5: // Incoming jump from 0x06C4, if not storage[0x08] < block.timestamp // Inputs[1] { @06C7 memory[0x40:0x60] } 06C5 60 PUSH1 0x40 06C7 51 MLOAD 06C8 62 PUSH3 0x461bcd 06CC 60 PUSH1 0xe5 06CE 1B SHL 06CF 81 DUP2 06D0 52 MSTORE 06D1 60 PUSH1 0x20 06D3 60 PUSH1 0x04 06D5 82 DUP3 06D6 01 ADD 06D7 52 MSTORE 06D8 60 PUSH1 0x25 06DA 60 PUSH1 0x24 06DC 82 DUP3 06DD 01 ADD 06DE 52 MSTORE 06DF 7F PUSH32 0x596f752061726520746f6f206561726c7920746f20636c61696d207468697320 0700 60 PUSH1 0x44 0702 82 DUP3 0703 01 ADD 0704 52 MSTORE 0705 7F PUSH32 0x746f6b656e000000000000000000000000000000000000000000000000000000 0726 60 PUSH1 0x64 0728 82 DUP3 0729 01 ADD 072A 52 MSTORE 072B 60 PUSH1 0x84 072D 01 ADD 072E 61 PUSH2 0x0564 0731 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @06D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06D7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06DE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @0704 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f752061726520746f6f206561726c7920746f20636c61696d207468697320 // @072A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x746f6b656e000000000000000000000000000000000000000000000000000000 // @072D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0732: // Incoming jump from 0x06C4, if storage[0x08] < block.timestamp // Inputs[1] { @0735 storage[0x09] } 0732 5B JUMPDEST 0733 60 PUSH1 0x09 0735 54 SLOAD 0736 60 PUSH1 0xff 0738 16 AND 0739 15 ISZERO 073A 61 PUSH2 0x07aa 073D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07aa, if !(0xff & storage[0x09]) label_073E: // Incoming jump from 0x073D, if not !(0xff & storage[0x09]) // Inputs[1] { @0740 memory[0x40:0x60] } 073E 60 PUSH1 0x40 0740 51 MLOAD 0741 62 PUSH3 0x461bcd 0745 60 PUSH1 0xe5 0747 1B SHL 0748 81 DUP2 0749 52 MSTORE 074A 60 PUSH1 0x20 074C 60 PUSH1 0x04 074E 82 DUP3 074F 01 ADD 0750 52 MSTORE 0751 60 PUSH1 0x24 0753 80 DUP1 0754 82 DUP3 0755 01 ADD 0756 52 MSTORE 0757 7F PUSH32 0x596f752063616e206e6f7420636c61696d207468697320746f6b656e20616e79 0778 60 PUSH1 0x44 077A 82 DUP3 077B 01 ADD 077C 52 MSTORE 077D 7F PUSH32 0x6d6f726500000000000000000000000000000000000000000000000000000000 079E 60 PUSH1 0x64 07A0 82 DUP3 07A1 01 ADD 07A2 52 MSTORE 07A3 60 PUSH1 0x84 07A5 01 ADD 07A6 61 PUSH2 0x0564 07A9 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0749 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0750 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0756 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @077C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f752063616e206e6f7420636c61696d207468697320746f6b656e20616e79 // @07A2 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6d6f726500000000000000000000000000000000000000000000000000000000 // @07A5 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_07AA: // Incoming jump from 0x073D, if !(0xff & storage[0x09]) // Inputs[1] { @07AE msg.sender } 07AA 5B JUMPDEST 07AB 61 PUSH2 0x07b3 07AE 33 CALLER 07AF 61 PUSH2 0x0a4f 07B2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07AB stack[0] = 0x07b3 // @07AE stack[1] = msg.sender // } // Block ends with call to 0x0a4f, returns to 0x07B3 label_07B3: // Incoming return from call to 0x0A4F at 0x07B2 // Inputs[1] { @07B4 stack[-1] } 07B3 5B JUMPDEST 07B4 15 ISZERO 07B5 61 PUSH2 0x0825 07B8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0825, if !stack[-1] label_07B9: // Incoming jump from 0x07B8, if not !stack[-1] // Inputs[1] { @07BB memory[0x40:0x60] } 07B9 60 PUSH1 0x40 07BB 51 MLOAD 07BC 62 PUSH3 0x461bcd 07C0 60 PUSH1 0xe5 07C2 1B SHL 07C3 81 DUP2 07C4 52 MSTORE 07C5 60 PUSH1 0x20 07C7 60 PUSH1 0x04 07C9 82 DUP3 07CA 01 ADD 07CB 52 MSTORE 07CC 60 PUSH1 0x24 07CE 80 DUP1 07CF 82 DUP3 07D0 01 ADD 07D1 52 MSTORE 07D2 7F PUSH32 0x4f6e6c79206f6e6520546f6b656e207065722077616c6c657420697320616c6c 07F3 60 PUSH1 0x44 07F5 82 DUP3 07F6 01 ADD 07F7 52 MSTORE 07F8 7F PUSH32 0x6f77656400000000000000000000000000000000000000000000000000000000 0819 60 PUSH1 0x64 081B 82 DUP3 081C 01 ADD 081D 52 MSTORE 081E 60 PUSH1 0x84 0820 01 ADD 0821 61 PUSH2 0x0564 0824 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @07C4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07CB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @07F7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f6e6c79206f6e6520546f6b656e207065722077616c6c657420697320616c6c // @081D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6f77656400000000000000000000000000000000000000000000000000000000 // @0820 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0825: // Incoming jump from 0x07B8, if !stack[-1] // Inputs[2] // { // @0829 msg.sender // @082C storage[0x07] // } 0825 5B JUMPDEST 0826 61 PUSH2 0x0831 0829 33 CALLER 082A 60 PUSH1 0x07 082C 54 SLOAD 082D 61 PUSH2 0x10d4 0830 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0826 stack[0] = 0x0831 // @0829 stack[1] = msg.sender // @082C stack[2] = storage[0x07] // } // Block ends with call to 0x10d4, returns to 0x0831 label_0831: // Incoming return from call to 0x10D4 at 0x0830 // Inputs[1] { @0835 storage[0x07] } 0831 5B JUMPDEST 0832 60 PUSH1 0x07 0834 80 DUP1 0835 54 SLOAD 0836 90 SWAP1 0837 60 PUSH1 0x00 0839 61 PUSH2 0x0841 083C 83 DUP4 083D 61 PUSH2 0x1bfc 0840 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0836 stack[0] = storage[0x07] // @0836 stack[1] = 0x07 // @0837 stack[2] = 0x00 // @0839 stack[3] = 0x0841 // @083C stack[4] = storage[0x07] // } // Block ends with call to 0x1bfc, returns to 0x0841 label_0841: // Incoming return from call to 0x1BFC at 0x0840 // Inputs[4] // { // @0842 stack[-1] // @0842 stack[-3] // @0843 stack[-2] // @0847 stack[-5] // } 0841 5B JUMPDEST 0842 91 SWAP2 0843 90 SWAP1 0844 50 POP 0845 55 SSTORE 0846 50 POP 0847 56 *JUMP // Stack delta = -5 // Outputs[1] { @0845 storage[stack[-3]] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0848: // Incoming jump from 0x023B // Inputs[2] // { // @084C msg.sender // @084D stack[-1] // } 0848 5B JUMPDEST 0849 61 PUSH2 0x0852 084C 33 CALLER 084D 82 DUP3 084E 61 PUSH2 0x1223 0851 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0849 stack[0] = 0x0852 // @084C stack[1] = msg.sender // @084D stack[2] = stack[-1] // } // Block ends with call to 0x1223, returns to 0x0852 label_0852: // Incoming return from call to 0x1223 at 0x0851 // Inputs[1] { @0856 stack[-1] } 0852 5B JUMPDEST 0853 61 PUSH2 0x08c4 0856 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08c4, if stack[-1] label_0857: // Incoming jump from 0x0856, if not stack[-1] // Inputs[1] { @0859 memory[0x40:0x60] } 0857 60 PUSH1 0x40 0859 51 MLOAD 085A 62 PUSH3 0x461bcd 085E 60 PUSH1 0xe5 0860 1B SHL 0861 81 DUP2 0862 52 MSTORE 0863 60 PUSH1 0x20 0865 60 PUSH1 0x04 0867 82 DUP3 0868 01 ADD 0869 52 MSTORE 086A 60 PUSH1 0x31 086C 60 PUSH1 0x24 086E 82 DUP3 086F 01 ADD 0870 52 MSTORE 0871 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 0892 60 PUSH1 0x44 0894 82 DUP3 0895 01 ADD 0896 52 MSTORE 0897 7F PUSH32 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 08B8 60 PUSH1 0x64 08BA 82 DUP3 08BB 01 ADD 08BC 52 MSTORE 08BD 60 PUSH1 0x84 08BF 01 ADD 08C0 61 PUSH2 0x0564 08C3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0862 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0869 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0870 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x31 // @0896 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @08BC memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 // @08BF stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_08C4: // Incoming jump from 0x0856, if stack[-1] // Inputs[3] // { // @08C8 stack[-3] // @08C9 stack[-2] // @08CA stack[-1] // } 08C4 5B JUMPDEST 08C5 61 PUSH2 0x06b6 08C8 83 DUP4 08C9 83 DUP4 08CA 83 DUP4 08CB 61 PUSH2 0x132b 08CE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08C5 stack[0] = 0x06b6 // @08C8 stack[1] = stack[-3] // @08C9 stack[2] = stack[-2] // @08CA stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x132b label_08CF: // Incoming jump from 0x024E // Inputs[2] // { // @08D2 storage[0x06] // @08DC msg.sender // } 08CF 5B JUMPDEST 08D0 60 PUSH1 0x06 08D2 54 SLOAD 08D3 60 PUSH1 0x01 08D5 60 PUSH1 0x01 08D7 60 PUSH1 0xa0 08D9 1B SHL 08DA 03 SUB 08DB 16 AND 08DC 33 CALLER 08DD 14 EQ 08DE 61 PUSH2 0x0929 08E1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0929, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_08E2: // Incoming jump from 0x08E1, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @08E4 memory[0x40:0x60] } 08E2 60 PUSH1 0x40 08E4 51 MLOAD 08E5 62 PUSH3 0x461bcd 08E9 60 PUSH1 0xe5 08EB 1B SHL 08EC 81 DUP2 08ED 52 MSTORE 08EE 60 PUSH1 0x20 08F0 60 PUSH1 0x04 08F2 82 DUP3 08F3 01 ADD 08F4 81 DUP2 08F5 90 SWAP1 08F6 52 MSTORE 08F7 60 PUSH1 0x24 08F9 82 DUP3 08FA 01 ADD 08FB 52 MSTORE 08FC 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 091D 60 PUSH1 0x44 091F 82 DUP3 0920 01 ADD 0921 52 MSTORE 0922 60 PUSH1 0x64 0924 01 ADD 0925 61 PUSH2 0x0564 0928 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @08ED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08F6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08FB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0921 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0924 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0929: // Incoming jump from 0x08E1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @092A stack[-1] // @092B memory[stack[-1]:stack[-1] + 0x20] // } 0929 5B JUMPDEST 092A 80 DUP1 092B 51 MLOAD 092C 61 PUSH2 0x093c 092F 90 SWAP1 0930 60 PUSH1 0x0a 0932 90 SWAP1 0933 60 PUSH1 0x20 0935 84 DUP5 0936 01 ADD 0937 90 SWAP1 0938 61 PUSH2 0x17a3 093B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @092F stack[0] = 0x093c // @0932 stack[1] = 0x0a // @0937 stack[2] = stack[-1] + 0x20 // @0937 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x17a3 093C 5B JUMPDEST 093D 50 POP 093E 50 POP 093F 56 *JUMP label_0940: // Incoming jump from 0x0261 // Inputs[4] // { // @0944 stack[-3] // @0945 stack[-2] // @0946 stack[-1] // @0949 memory[0x40:0x60] // } 0940 5B JUMPDEST 0941 61 PUSH2 0x06b6 0944 83 DUP4 0945 83 DUP4 0946 83 DUP4 0947 60 PUSH1 0x40 0949 51 MLOAD 094A 80 DUP1 094B 60 PUSH1 0x20 094D 01 ADD 094E 60 PUSH1 0x40 0950 52 MSTORE 0951 80 DUP1 0952 60 PUSH1 0x00 0954 81 DUP2 0955 52 MSTORE 0956 50 POP 0957 61 PUSH2 0x0d5e 095A 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0941 stack[0] = 0x06b6 // @0944 stack[1] = stack[-3] // @0945 stack[2] = stack[-2] // @0946 stack[3] = stack[-1] // @0949 stack[4] = memory[0x40:0x60] // @0950 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0955 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0d5e label_095B: // Incoming jump from 0x0274 // Incoming call from 0x12B7, returns to 0x12B8 // Incoming call from 0x109A, returns to 0x109B // Incoming call from 0x0593, returns to 0x0594 // Incoming call from 0x142E, returns to 0x142F // Inputs[3] // { // @095E stack[-1] // @0969 memory[0x00:0x40] // @096A storage[keccak256(memory[0x00:0x40])] // } 095B 5B JUMPDEST 095C 60 PUSH1 0x00 095E 81 DUP2 095F 81 DUP2 0960 52 MSTORE 0961 60 PUSH1 0x02 0963 60 PUSH1 0x20 0965 52 MSTORE 0966 60 PUSH1 0x40 0968 81 DUP2 0969 20 SHA3 096A 54 SLOAD 096B 60 PUSH1 0x01 096D 60 PUSH1 0x01 096F 60 PUSH1 0xa0 0971 1B SHL 0972 03 SUB 0973 16 AND 0974 80 DUP1 0975 61 PUSH2 0x0446 0978 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @095C stack[0] = 0x00 // @0960 memory[0x00:0x20] = stack[-1] // @0965 memory[0x20:0x40] = 0x02 // @0973 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0446, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0979: // Incoming jump from 0x0978, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @097B memory[0x40:0x60] } 0979 60 PUSH1 0x40 097B 51 MLOAD 097C 62 PUSH3 0x461bcd 0980 60 PUSH1 0xe5 0982 1B SHL 0983 81 DUP2 0984 52 MSTORE 0985 60 PUSH1 0x20 0987 60 PUSH1 0x04 0989 82 DUP3 098A 01 ADD 098B 52 MSTORE 098C 60 PUSH1 0x29 098E 60 PUSH1 0x24 0990 82 DUP3 0991 01 ADD 0992 52 MSTORE 0993 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 09B4 60 PUSH1 0x44 09B6 82 DUP3 09B7 01 ADD 09B8 52 MSTORE 09B9 7F PUSH32 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 09DA 60 PUSH1 0x64 09DC 82 DUP3 09DD 01 ADD 09DE 52 MSTORE 09DF 60 PUSH1 0x84 09E1 01 ADD 09E2 61 PUSH2 0x0564 09E5 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0984 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @098B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0992 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @09B8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @09DE memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x656e7420746f6b656e0000000000000000000000000000000000000000000000 // @09E1 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_09E6: // Incoming call from 0x027C, returns to 0x020D // Inputs[2] // { // @09E9 storage[0x06] // @09F3 msg.sender // } 09E6 5B JUMPDEST 09E7 60 PUSH1 0x06 09E9 54 SLOAD 09EA 60 PUSH1 0x01 09EC 60 PUSH1 0x01 09EE 60 PUSH1 0xa0 09F0 1B SHL 09F1 03 SUB 09F2 16 AND 09F3 33 CALLER 09F4 14 EQ 09F5 61 PUSH2 0x0a40 09F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a40, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_09F9: // Incoming jump from 0x09F8, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @09FB memory[0x40:0x60] } 09F9 60 PUSH1 0x40 09FB 51 MLOAD 09FC 62 PUSH3 0x461bcd 0A00 60 PUSH1 0xe5 0A02 1B SHL 0A03 81 DUP2 0A04 52 MSTORE 0A05 60 PUSH1 0x20 0A07 60 PUSH1 0x04 0A09 82 DUP3 0A0A 01 ADD 0A0B 81 DUP2 0A0C 90 SWAP1 0A0D 52 MSTORE 0A0E 60 PUSH1 0x24 0A10 82 DUP3 0A11 01 ADD 0A12 52 MSTORE 0A13 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0A34 60 PUSH1 0x44 0A36 82 DUP3 0A37 01 ADD 0A38 52 MSTORE 0A39 60 PUSH1 0x64 0A3B 01 ADD 0A3C 61 PUSH2 0x0564 0A3F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A0D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A12 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0A38 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0A3B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0A40: // Incoming jump from 0x09F8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @0A44 storage[0x09] // @0A4E stack[-1] // } 0A40 5B JUMPDEST 0A41 60 PUSH1 0x09 0A43 80 DUP1 0A44 54 SLOAD 0A45 60 PUSH1 0xff 0A47 19 NOT 0A48 16 AND 0A49 60 PUSH1 0x01 0A4B 17 OR 0A4C 90 SWAP1 0A4D 55 SSTORE 0A4E 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A4D storage[0x09] = 0x01 | (~0xff & storage[0x09]) } // Block ends with unconditional jump to stack[-1] label_0A4F: // Incoming call from 0x07B2, returns to 0x07B3 // Incoming jump from 0x028F // Inputs[1] { @0A5A stack[-1] } 0A4F 5B JUMPDEST 0A50 60 PUSH1 0x00 0A52 60 PUSH1 0x01 0A54 60 PUSH1 0x01 0A56 60 PUSH1 0xa0 0A58 1B SHL 0A59 03 SUB 0A5A 82 DUP3 0A5B 16 AND 0A5C 61 PUSH2 0x0acd 0A5F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A50 stack[0] = 0x00 } // Block ends with conditional jump to 0x0acd, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0A60: // Incoming jump from 0x0A5F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A62 memory[0x40:0x60] } 0A60 60 PUSH1 0x40 0A62 51 MLOAD 0A63 62 PUSH3 0x461bcd 0A67 60 PUSH1 0xe5 0A69 1B SHL 0A6A 81 DUP2 0A6B 52 MSTORE 0A6C 60 PUSH1 0x20 0A6E 60 PUSH1 0x04 0A70 82 DUP3 0A71 01 ADD 0A72 52 MSTORE 0A73 60 PUSH1 0x2a 0A75 60 PUSH1 0x24 0A77 82 DUP3 0A78 01 ADD 0A79 52 MSTORE 0A7A 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 0A9B 60 PUSH1 0x44 0A9D 82 DUP3 0A9E 01 ADD 0A9F 52 MSTORE 0AA0 7F PUSH32 0x726f206164647265737300000000000000000000000000000000000000000000 0AC1 60 PUSH1 0x64 0AC3 82 DUP3 0AC4 01 ADD 0AC5 52 MSTORE 0AC6 60 PUSH1 0x84 0AC8 01 ADD 0AC9 61 PUSH2 0x0564 0ACC 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0A6B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A72 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A79 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @0A9F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @0AC5 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x726f206164647265737300000000000000000000000000000000000000000000 // @0AC8 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0ACD: // Incoming jump from 0x0A5F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0AD7 stack[-2] // @0AE5 memory[0x00:0x40] // @0AE6 storage[keccak256(memory[0x00:0x40])] // @0AE7 stack[-3] // } 0ACD 5B JUMPDEST 0ACE 50 POP 0ACF 60 PUSH1 0x01 0AD1 60 PUSH1 0x01 0AD3 60 PUSH1 0xa0 0AD5 1B SHL 0AD6 03 SUB 0AD7 16 AND 0AD8 60 PUSH1 0x00 0ADA 90 SWAP1 0ADB 81 DUP2 0ADC 52 MSTORE 0ADD 60 PUSH1 0x03 0ADF 60 PUSH1 0x20 0AE1 52 MSTORE 0AE2 60 PUSH1 0x40 0AE4 90 SWAP1 0AE5 20 SHA3 0AE6 54 SLOAD 0AE7 90 SWAP1 0AE8 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0ADC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0AE1 memory[0x20:0x40] = 0x03 // @0AE7 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0AE9: // Incoming call from 0x0297, returns to 0x020D // Inputs[2] // { // @0AEC storage[0x06] // @0AF6 msg.sender // } 0AE9 5B JUMPDEST 0AEA 60 PUSH1 0x06 0AEC 54 SLOAD 0AED 60 PUSH1 0x01 0AEF 60 PUSH1 0x01 0AF1 60 PUSH1 0xa0 0AF3 1B SHL 0AF4 03 SUB 0AF5 16 AND 0AF6 33 CALLER 0AF7 14 EQ 0AF8 61 PUSH2 0x0b43 0AFB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b43, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0AFC: // Incoming jump from 0x0AFB, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0AFE memory[0x40:0x60] } 0AFC 60 PUSH1 0x40 0AFE 51 MLOAD 0AFF 62 PUSH3 0x461bcd 0B03 60 PUSH1 0xe5 0B05 1B SHL 0B06 81 DUP2 0B07 52 MSTORE 0B08 60 PUSH1 0x20 0B0A 60 PUSH1 0x04 0B0C 82 DUP3 0B0D 01 ADD 0B0E 81 DUP2 0B0F 90 SWAP1 0B10 52 MSTORE 0B11 60 PUSH1 0x24 0B13 82 DUP3 0B14 01 ADD 0B15 52 MSTORE 0B16 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0B37 60 PUSH1 0x44 0B39 82 DUP3 0B3A 01 ADD 0B3B 52 MSTORE 0B3C 60 PUSH1 0x64 0B3E 01 ADD 0B3F 61 PUSH2 0x0564 0B42 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B10 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B15 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0B3B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0B3E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0B43: // Incoming jump from 0x0AFB, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[5] // { // @0B46 storage[0x06] // @0B49 memory[0x40:0x60] // @0B7B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0B7F storage[0x06] // @0B99 stack[-1] // } 0B43 5B JUMPDEST 0B44 60 PUSH1 0x06 0B46 54 SLOAD 0B47 60 PUSH1 0x40 0B49 51 MLOAD 0B4A 60 PUSH1 0x00 0B4C 91 SWAP2 0B4D 60 PUSH1 0x01 0B4F 60 PUSH1 0x01 0B51 60 PUSH1 0xa0 0B53 1B SHL 0B54 03 SUB 0B55 16 AND 0B56 90 SWAP1 0B57 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0B78 90 SWAP1 0B79 83 DUP4 0B7A 90 SWAP1 0B7B A3 LOG3 0B7C 60 PUSH1 0x06 0B7E 80 DUP1 0B7F 54 SLOAD 0B80 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B95 19 NOT 0B96 16 AND 0B97 90 SWAP1 0B98 55 SSTORE 0B99 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @0B7B log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x06] & (0x01 << 0xa0) - 0x01, 0x00]); // @0B98 storage[0x06] = ~0xffffffffffffffffffffffffffffffffffffffff & storage[0x06] // } // Block ends with unconditional jump to stack[-1] label_0B9A: // Incoming jump from 0x02AA // Inputs[2] // { // @0B9D storage[0x06] // @0BA7 msg.sender // } 0B9A 5B JUMPDEST 0B9B 60 PUSH1 0x06 0B9D 54 SLOAD 0B9E 60 PUSH1 0x01 0BA0 60 PUSH1 0x01 0BA2 60 PUSH1 0xa0 0BA4 1B SHL 0BA5 03 SUB 0BA6 16 AND 0BA7 33 CALLER 0BA8 14 EQ 0BA9 61 PUSH2 0x0bf4 0BAC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bf4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0BAD: // Incoming jump from 0x0BAC, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0BAF memory[0x40:0x60] } 0BAD 60 PUSH1 0x40 0BAF 51 MLOAD 0BB0 62 PUSH3 0x461bcd 0BB4 60 PUSH1 0xe5 0BB6 1B SHL 0BB7 81 DUP2 0BB8 52 MSTORE 0BB9 60 PUSH1 0x20 0BBB 60 PUSH1 0x04 0BBD 82 DUP3 0BBE 01 ADD 0BBF 81 DUP2 0BC0 90 SWAP1 0BC1 52 MSTORE 0BC2 60 PUSH1 0x24 0BC4 82 DUP3 0BC5 01 ADD 0BC6 52 MSTORE 0BC7 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0BE8 60 PUSH1 0x44 0BEA 82 DUP3 0BEB 01 ADD 0BEC 52 MSTORE 0BED 60 PUSH1 0x64 0BEF 01 ADD 0BF0 61 PUSH2 0x0564 0BF3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0BB8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BC1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BC6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0BEC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0BEF stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0BF4: // Incoming jump from 0x0BAC, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[2] // { // @0BF7 stack[-1] // @0BF8 stack[-2] // } 0BF4 5B JUMPDEST 0BF5 60 PUSH1 0x08 0BF7 55 SSTORE 0BF8 56 *JUMP // Stack delta = -2 // Outputs[1] { @0BF7 storage[0x08] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0BF9: // Incoming jump from 0x02BD // Inputs[2] // { // @0BFC storage[0x06] // @0C06 msg.sender // } 0BF9 5B JUMPDEST 0BFA 60 PUSH1 0x06 0BFC 54 SLOAD 0BFD 60 PUSH1 0x01 0BFF 60 PUSH1 0x01 0C01 60 PUSH1 0xa0 0C03 1B SHL 0C04 03 SUB 0C05 16 AND 0C06 33 CALLER 0C07 14 EQ 0C08 61 PUSH2 0x0c53 0C0B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c53, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0C0C: // Incoming jump from 0x0C0B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0C0E memory[0x40:0x60] } 0C0C 60 PUSH1 0x40 0C0E 51 MLOAD 0C0F 62 PUSH3 0x461bcd 0C13 60 PUSH1 0xe5 0C15 1B SHL 0C16 81 DUP2 0C17 52 MSTORE 0C18 60 PUSH1 0x20 0C1A 60 PUSH1 0x04 0C1C 82 DUP3 0C1D 01 ADD 0C1E 81 DUP2 0C1F 90 SWAP1 0C20 52 MSTORE 0C21 60 PUSH1 0x24 0C23 82 DUP3 0C24 01 ADD 0C25 52 MSTORE 0C26 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0C47 60 PUSH1 0x44 0C49 82 DUP3 0C4A 01 ADD 0C4B 52 MSTORE 0C4C 60 PUSH1 0x64 0C4E 01 ADD 0C4F 61 PUSH2 0x0564 0C52 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0C17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C20 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C25 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0C4B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0C4E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0C53: // Incoming jump from 0x0C0B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[3] // { // @0C57 storage[0x09] // @0C58 stack[-1] // @0C89 stack[-2] // } 0C53 5B JUMPDEST 0C54 60 PUSH1 0x09 0C56 80 DUP1 0C57 54 SLOAD 0C58 91 SWAP2 0C59 15 ISZERO 0C5A 15 ISZERO 0C5B 61 PUSH2 0x0100 0C5E 02 MUL 0C5F 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff 0C80 90 SWAP1 0C81 92 SWAP3 0C82 16 AND 0C83 91 SWAP2 0C84 90 SWAP1 0C85 91 SWAP2 0C86 17 OR 0C87 90 SWAP1 0C88 55 SSTORE 0C89 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C88 storage[0x09] = (storage[0x09] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff) | 0x0100 * !!stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C8A: // Incoming call from 0x02D6, returns to 0x01C2 // Inputs[1] { @0C90 storage[0x01] } 0C8A 5B JUMPDEST 0C8B 60 PUSH1 0x60 0C8D 60 PUSH1 0x01 0C8F 80 DUP1 0C90 54 SLOAD 0C91 61 PUSH2 0x045b 0C94 90 SWAP1 0C95 61 PUSH2 0x1bc1 0C98 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0C8B stack[0] = 0x60 // @0C8D stack[1] = 0x01 // @0C94 stack[2] = 0x045b // @0C94 stack[3] = storage[0x01] // } // Block ends with call to 0x1bc1, returns to 0x045B label_0C99: // Incoming jump from 0x02E9 // Inputs[2] // { // @0CA2 stack[-2] // @0CA4 msg.sender // } 0C99 5B JUMPDEST 0C9A 60 PUSH1 0x01 0C9C 60 PUSH1 0x01 0C9E 60 PUSH1 0xa0 0CA0 1B SHL 0CA1 03 SUB 0CA2 82 DUP3 0CA3 16 AND 0CA4 33 CALLER 0CA5 14 EQ 0CA6 15 ISZERO 0CA7 61 PUSH2 0x0cf2 0CAA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cf2, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) label_0CAB: // Incoming jump from 0x0CAA, if not !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @0CAD memory[0x40:0x60] } 0CAB 60 PUSH1 0x40 0CAD 51 MLOAD 0CAE 62 PUSH3 0x461bcd 0CB2 60 PUSH1 0xe5 0CB4 1B SHL 0CB5 81 DUP2 0CB6 52 MSTORE 0CB7 60 PUSH1 0x20 0CB9 60 PUSH1 0x04 0CBB 82 DUP3 0CBC 01 ADD 0CBD 52 MSTORE 0CBE 60 PUSH1 0x19 0CC0 60 PUSH1 0x24 0CC2 82 DUP3 0CC3 01 ADD 0CC4 52 MSTORE 0CC5 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 0CE6 60 PUSH1 0x44 0CE8 82 DUP3 0CE9 01 ADD 0CEA 52 MSTORE 0CEB 60 PUSH1 0x64 0CED 01 ADD 0CEE 61 PUSH2 0x0564 0CF1 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0CB6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CBD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CC4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @0CEA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @0CED stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0CF2: // Incoming jump from 0x0CAA, if !(msg.sender == stack[-2] & (0x01 << 0xa0) - 0x01) // Inputs[10] // { // @0CF3 msg.sender // @0D04 memory[0x00:0x40] // @0D0D stack[-2] // @0D18 memory[0x00:0x40] // @0D1A storage[keccak256(memory[0x00:0x40])] // @0D1F stack[-1] // @0D29 memory[0x40:0x60] // @0D55 memory[0x40:0x60] // @0D5A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0D5D stack[-3] // } 0CF2 5B JUMPDEST 0CF3 33 CALLER 0CF4 60 PUSH1 0x00 0CF6 81 DUP2 0CF7 81 DUP2 0CF8 52 MSTORE 0CF9 60 PUSH1 0x05 0CFB 60 PUSH1 0x20 0CFD 90 SWAP1 0CFE 81 DUP2 0CFF 52 MSTORE 0D00 60 PUSH1 0x40 0D02 80 DUP1 0D03 83 DUP4 0D04 20 SHA3 0D05 60 PUSH1 0x01 0D07 60 PUSH1 0x01 0D09 60 PUSH1 0xa0 0D0B 1B SHL 0D0C 03 SUB 0D0D 87 DUP8 0D0E 16 AND 0D0F 80 DUP1 0D10 85 DUP6 0D11 52 MSTORE 0D12 90 SWAP1 0D13 83 DUP4 0D14 52 MSTORE 0D15 92 SWAP3 0D16 81 DUP2 0D17 90 SWAP1 0D18 20 SHA3 0D19 80 DUP1 0D1A 54 SLOAD 0D1B 60 PUSH1 0xff 0D1D 19 NOT 0D1E 16 AND 0D1F 86 DUP7 0D20 15 ISZERO 0D21 15 ISZERO 0D22 90 SWAP1 0D23 81 DUP2 0D24 17 OR 0D25 90 SWAP1 0D26 91 SWAP2 0D27 55 SSTORE 0D28 90 SWAP1 0D29 51 MLOAD 0D2A 90 SWAP1 0D2B 81 DUP2 0D2C 52 MSTORE 0D2D 91 SWAP2 0D2E 92 SWAP3 0D2F 91 SWAP2 0D30 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0D51 91 SWAP2 0D52 01 ADD 0D53 60 PUSH1 0x40 0D55 51 MLOAD 0D56 80 DUP1 0D57 91 SWAP2 0D58 03 SUB 0D59 90 SWAP1 0D5A A3 LOG3 0D5B 50 POP 0D5C 50 POP 0D5D 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @0CF8 memory[0x00:0x20] = msg.sender // @0CFF memory[0x20:0x40] = 0x05 // @0D11 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0D14 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0D27 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0D2C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0D5A 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_0D5E: // Incoming jump from 0x02FC // Incoming jump from 0x095A // Inputs[2] // { // @0D62 msg.sender // @0D63 stack[-2] // } 0D5E 5B JUMPDEST 0D5F 61 PUSH2 0x0d68 0D62 33 CALLER 0D63 83 DUP4 0D64 61 PUSH2 0x1223 0D67 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D5F stack[0] = 0x0d68 // @0D62 stack[1] = msg.sender // @0D63 stack[2] = stack[-2] // } // Block ends with call to 0x1223, returns to 0x0D68 label_0D68: // Incoming return from call to 0x1223 at 0x0D67 // Inputs[1] { @0D6C stack[-1] } 0D68 5B JUMPDEST 0D69 61 PUSH2 0x0dda 0D6C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dda, if stack[-1] label_0D6D: // Incoming jump from 0x0D6C, if not stack[-1] // Inputs[1] { @0D6F memory[0x40:0x60] } 0D6D 60 PUSH1 0x40 0D6F 51 MLOAD 0D70 62 PUSH3 0x461bcd 0D74 60 PUSH1 0xe5 0D76 1B SHL 0D77 81 DUP2 0D78 52 MSTORE 0D79 60 PUSH1 0x20 0D7B 60 PUSH1 0x04 0D7D 82 DUP3 0D7E 01 ADD 0D7F 52 MSTORE 0D80 60 PUSH1 0x31 0D82 60 PUSH1 0x24 0D84 82 DUP3 0D85 01 ADD 0D86 52 MSTORE 0D87 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 0DA8 60 PUSH1 0x44 0DAA 82 DUP3 0DAB 01 ADD 0DAC 52 MSTORE 0DAD 7F PUSH32 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 0DCE 60 PUSH1 0x64 0DD0 82 DUP3 0DD1 01 ADD 0DD2 52 MSTORE 0DD3 60 PUSH1 0x84 0DD5 01 ADD 0DD6 61 PUSH2 0x0564 0DD9 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0D78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D7F memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D86 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x31 // @0DAC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @0DD2 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x776e6572206e6f7220617070726f766564000000000000000000000000000000 // @0DD5 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0DDA: // Incoming jump from 0x0D6C, if stack[-1] // Inputs[4] // { // @0DDE stack[-4] // @0DDF stack[-3] // @0DE0 stack[-2] // @0DE1 stack[-1] // } 0DDA 5B JUMPDEST 0DDB 61 PUSH2 0x0de6 0DDE 84 DUP5 0DDF 84 DUP5 0DE0 84 DUP5 0DE1 84 DUP5 0DE2 61 PUSH2 0x1393 0DE5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0DDB stack[0] = 0x0de6 // @0DDE stack[1] = stack[-4] // @0DDF stack[2] = stack[-3] // @0DE0 stack[3] = stack[-2] // @0DE1 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1393 0DE6 5B JUMPDEST 0DE7 50 POP 0DE8 50 POP 0DE9 50 POP 0DEA 50 POP 0DEB 56 *JUMP label_0DEC: // Incoming jump from 0x030F // Inputs[3] // { // @0DEF stack[-1] // @0DFA memory[0x00:0x40] // @0DFB storage[keccak256(memory[0x00:0x40])] // } 0DEC 5B JUMPDEST 0DED 60 PUSH1 0x00 0DEF 81 DUP2 0DF0 81 DUP2 0DF1 52 MSTORE 0DF2 60 PUSH1 0x02 0DF4 60 PUSH1 0x20 0DF6 52 MSTORE 0DF7 60 PUSH1 0x40 0DF9 90 SWAP1 0DFA 20 SHA3 0DFB 54 SLOAD 0DFC 60 PUSH1 0x60 0DFE 90 SWAP1 0DFF 60 PUSH1 0x01 0E01 60 PUSH1 0x01 0E03 60 PUSH1 0xa0 0E05 1B SHL 0E06 03 SUB 0E07 16 AND 0E08 61 PUSH2 0x0e79 0E0B 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0DF1 memory[0x00:0x20] = stack[-1] // @0DF6 memory[0x20:0x40] = 0x02 // @0DFE stack[0] = 0x60 // } // Block ends with conditional jump to 0x0e79, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0E0C: // Incoming jump from 0x0E0B, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0E0E memory[0x40:0x60] } 0E0C 60 PUSH1 0x40 0E0E 51 MLOAD 0E0F 62 PUSH3 0x461bcd 0E13 60 PUSH1 0xe5 0E15 1B SHL 0E16 81 DUP2 0E17 52 MSTORE 0E18 60 PUSH1 0x20 0E1A 60 PUSH1 0x04 0E1C 82 DUP3 0E1D 01 ADD 0E1E 52 MSTORE 0E1F 60 PUSH1 0x2f 0E21 60 PUSH1 0x24 0E23 82 DUP3 0E24 01 ADD 0E25 52 MSTORE 0E26 7F PUSH32 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f 0E47 60 PUSH1 0x44 0E49 82 DUP3 0E4A 01 ADD 0E4B 52 MSTORE 0E4C 7F PUSH32 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 0E6D 60 PUSH1 0x64 0E6F 82 DUP3 0E70 01 ADD 0E71 52 MSTORE 0E72 60 PUSH1 0x84 0E74 01 ADD 0E75 61 PUSH2 0x0564 0E78 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0E17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E1E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E25 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @0E4B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732314d657461646174613a2055524920717565727920666f72206e6f // @0E71 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 // @0E74 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0E79: // Incoming jump from 0x0E0B, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0E7D storage[0x0a] } 0E79 5B JUMPDEST 0E7A 60 PUSH1 0x0a 0E7C 80 DUP1 0E7D 54 SLOAD 0E7E 61 PUSH2 0x0e86 0E81 90 SWAP1 0E82 61 PUSH2 0x1bc1 0E85 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E7A stack[0] = 0x0a // @0E81 stack[1] = 0x0e86 // @0E81 stack[2] = storage[0x0a] // } // Block ends with call to 0x1bc1, returns to 0x0E86 label_0E86: // Incoming return from call to 0x1BC1 at 0x0E85 // Inputs[4] // { // @0E87 stack[-1] // @0E96 memory[0x40:0x60] // @0E9E stack[-2] // @0EA9 storage[stack[-2]] // } 0E86 5B JUMPDEST 0E87 80 DUP1 0E88 60 PUSH1 0x1f 0E8A 01 ADD 0E8B 60 PUSH1 0x20 0E8D 80 DUP1 0E8E 91 SWAP2 0E8F 04 DIV 0E90 02 MUL 0E91 60 PUSH1 0x20 0E93 01 ADD 0E94 60 PUSH1 0x40 0E96 51 MLOAD 0E97 90 SWAP1 0E98 81 DUP2 0E99 01 ADD 0E9A 60 PUSH1 0x40 0E9C 52 MSTORE 0E9D 80 DUP1 0E9E 92 SWAP3 0E9F 91 SWAP2 0EA0 90 SWAP1 0EA1 81 DUP2 0EA2 81 DUP2 0EA3 52 MSTORE 0EA4 60 PUSH1 0x20 0EA6 01 ADD 0EA7 82 DUP3 0EA8 80 DUP1 0EA9 54 SLOAD 0EAA 61 PUSH2 0x0eb2 0EAD 90 SWAP1 0EAE 61 PUSH2 0x1bc1 0EB1 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0E9C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0E9E stack[-2] = memory[0x40:0x60] // @0E9F stack[-1] = stack[-2] // @0EA0 stack[0] = stack[-1] // @0EA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0EA6 stack[1] = 0x20 + memory[0x40:0x60] // @0EA7 stack[2] = stack[-2] // @0EAD stack[4] = storage[stack[-2]] // @0EAD stack[3] = 0x0eb2 // } // Block ends with call to 0x1bc1, returns to 0x0EB2 label_0EB2: // Incoming return from call to 0x1BC1 at 0x0EB1 // Inputs[1] { @0EB3 stack[-1] } 0EB2 5B JUMPDEST 0EB3 80 DUP1 0EB4 15 ISZERO 0EB5 61 PUSH2 0x0eff 0EB8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eff, if !stack[-1] label_0EB9: // Incoming jump from 0x0EB8, if not !stack[-1] // Inputs[1] { @0EB9 stack[-1] } 0EB9 80 DUP1 0EBA 60 PUSH1 0x1f 0EBC 10 LT 0EBD 61 PUSH2 0x0ed4 0EC0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ed4, if 0x1f < stack[-1] label_0EC1: // Incoming jump from 0x0EC0, if not 0x1f < stack[-1] // Inputs[4] // { // @0EC5 stack[-2] // @0EC6 storage[stack[-2]] // @0EC9 stack[-3] // @0ECB stack[-1] // } 0EC1 61 PUSH2 0x0100 0EC4 80 DUP1 0EC5 83 DUP4 0EC6 54 SLOAD 0EC7 04 DIV 0EC8 02 MUL 0EC9 83 DUP4 0ECA 52 MSTORE 0ECB 91 SWAP2 0ECC 60 PUSH1 0x20 0ECE 01 ADD 0ECF 91 SWAP2 0ED0 61 PUSH2 0x0eff 0ED3 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0ECA memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0ECF stack[-1] = stack[-1] // @0ECF stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0eff label_0ED4: // Incoming jump from 0x0EC0, if 0x1f < stack[-1] // Inputs[5] // { // @0ED5 stack[-3] // @0ED6 stack[-1] // @0ED8 stack[-2] // @0EE0 memory[0x00:0x20] // @0EE4 storage[keccak256(memory[0x00:0x20])] // } 0ED4 5B JUMPDEST 0ED5 82 DUP3 0ED6 01 ADD 0ED7 91 SWAP2 0ED8 90 SWAP1 0ED9 60 PUSH1 0x00 0EDB 52 MSTORE 0EDC 60 PUSH1 0x20 0EDE 60 PUSH1 0x00 0EE0 20 SHA3 0EE1 90 SWAP1 0EE2 5B JUMPDEST 0EE3 81 DUP2 0EE4 54 SLOAD 0EE5 81 DUP2 0EE6 52 MSTORE 0EE7 90 SWAP1 0EE8 60 PUSH1 0x01 0EEA 01 ADD 0EEB 90 SWAP1 0EEC 60 PUSH1 0x20 0EEE 01 ADD 0EEF 80 DUP1 0EF0 83 DUP4 0EF1 11 GT 0EF2 61 PUSH2 0x0ee2 0EF5 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0ED7 stack[-3] = stack[-3] + stack[-1] // @0EDB memory[0x00:0x20] = stack[-2] // @0EE6 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0EEB stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0EEE stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0ee2, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0EF6: // Incoming jump from 0x0EF5, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0EF5, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0EF6 stack[-3] // @0EF7 stack[-1] // } 0EF6 82 DUP3 0EF7 90 SWAP1 0EF8 03 SUB 0EF9 60 PUSH1 0x1f 0EFB 16 AND 0EFC 82 DUP3 0EFD 01 ADD 0EFE 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0EFE stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0EFE stack[-1] = stack[-3] // } // Block continues label_0EFF: // Incoming jump from 0x0EFE // Incoming jump from 0x0EB8, if !stack[-1] // Incoming jump from 0x0ED3 // Inputs[4] // { // @0F05 stack[-6] // @0F05 stack[-7] // @0F07 stack[-9] // @0F08 stack[-8] // } 0EFF 5B JUMPDEST 0F00 50 POP 0F01 50 POP 0F02 50 POP 0F03 50 POP 0F04 50 POP 0F05 90 SWAP1 0F06 50 POP 0F07 91 SWAP2 0F08 90 SWAP1 0F09 50 POP 0F0A 56 *JUMP // Stack delta = -8 // Outputs[1] { @0F07 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_0F0B: // Incoming call from 0x0317, returns to 0x01C2 // Inputs[1] { @0F11 storage[0x0a] } 0F0B 5B JUMPDEST 0F0C 60 PUSH1 0x60 0F0E 60 PUSH1 0x0a 0F10 80 DUP1 0F11 54 SLOAD 0F12 61 PUSH2 0x045b 0F15 90 SWAP1 0F16 61 PUSH2 0x1bc1 0F19 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F0C stack[0] = 0x60 // @0F0E stack[1] = 0x0a // @0F15 stack[2] = 0x045b // @0F15 stack[3] = storage[0x0a] // } // Block ends with call to 0x1bc1, returns to 0x045B label_0F1A: // Incoming jump from 0x0366 // Inputs[2] // { // @0F1D storage[0x06] // @0F27 msg.sender // } 0F1A 5B JUMPDEST 0F1B 60 PUSH1 0x06 0F1D 54 SLOAD 0F1E 60 PUSH1 0x01 0F20 60 PUSH1 0x01 0F22 60 PUSH1 0xa0 0F24 1B SHL 0F25 03 SUB 0F26 16 AND 0F27 33 CALLER 0F28 14 EQ 0F29 61 PUSH2 0x0f74 0F2C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f74, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] label_0F2D: // Incoming jump from 0x0F2C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0F2F memory[0x40:0x60] } 0F2D 60 PUSH1 0x40 0F2F 51 MLOAD 0F30 62 PUSH3 0x461bcd 0F34 60 PUSH1 0xe5 0F36 1B SHL 0F37 81 DUP2 0F38 52 MSTORE 0F39 60 PUSH1 0x20 0F3B 60 PUSH1 0x04 0F3D 82 DUP3 0F3E 01 ADD 0F3F 81 DUP2 0F40 90 SWAP1 0F41 52 MSTORE 0F42 60 PUSH1 0x24 0F44 82 DUP3 0F45 01 ADD 0F46 52 MSTORE 0F47 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0F68 60 PUSH1 0x44 0F6A 82 DUP3 0F6B 01 ADD 0F6C 52 MSTORE 0F6D 60 PUSH1 0x64 0F6F 01 ADD 0F70 61 PUSH2 0x0564 0F73 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F41 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F46 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0F6C memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0F6F stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0F74: // Incoming jump from 0x0F2C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x06] // Inputs[1] { @0F7D stack[-1] } 0F74 5B JUMPDEST 0F75 60 PUSH1 0x01 0F77 60 PUSH1 0x01 0F79 60 PUSH1 0xa0 0F7B 1B SHL 0F7C 03 SUB 0F7D 81 DUP2 0F7E 16 AND 0F7F 61 PUSH2 0x0ff0 0F82 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ff0, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0F83: // Incoming jump from 0x0F82, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0F85 memory[0x40:0x60] } 0F83 60 PUSH1 0x40 0F85 51 MLOAD 0F86 62 PUSH3 0x461bcd 0F8A 60 PUSH1 0xe5 0F8C 1B SHL 0F8D 81 DUP2 0F8E 52 MSTORE 0F8F 60 PUSH1 0x20 0F91 60 PUSH1 0x04 0F93 82 DUP3 0F94 01 ADD 0F95 52 MSTORE 0F96 60 PUSH1 0x26 0F98 60 PUSH1 0x24 0F9A 82 DUP3 0F9B 01 ADD 0F9C 52 MSTORE 0F9D 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0FBE 60 PUSH1 0x44 0FC0 82 DUP3 0FC1 01 ADD 0FC2 52 MSTORE 0FC3 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 0FE4 60 PUSH1 0x64 0FE6 82 DUP3 0FE7 01 ADD 0FE8 52 MSTORE 0FE9 60 PUSH1 0x84 0FEB 01 ADD 0FEC 61 PUSH2 0x0564 0FEF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0F8E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F95 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F9C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0FC2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0FE8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @0FEB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_0FF0: // Incoming jump from 0x0F82, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0FF3 storage[0x06] // @0FF6 memory[0x40:0x60] // @1000 stack[-1] // @102A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @102E storage[0x06] // @1058 stack[-2] // } 0FF0 5B JUMPDEST 0FF1 60 PUSH1 0x06 0FF3 54 SLOAD 0FF4 60 PUSH1 0x40 0FF6 51 MLOAD 0FF7 60 PUSH1 0x01 0FF9 60 PUSH1 0x01 0FFB 60 PUSH1 0xa0 0FFD 1B SHL 0FFE 03 SUB 0FFF 80 DUP1 1000 84 DUP5 1001 16 AND 1002 92 SWAP3 1003 16 AND 1004 90 SWAP1 1005 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1026 90 SWAP1 1027 60 PUSH1 0x00 1029 90 SWAP1 102A A3 LOG3 102B 60 PUSH1 0x06 102D 80 DUP1 102E 54 SLOAD 102F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1044 19 NOT 1045 16 AND 1046 60 PUSH1 0x01 1048 60 PUSH1 0x01 104A 60 PUSH1 0xa0 104C 1B SHL 104D 03 SUB 104E 92 SWAP3 104F 90 SWAP1 1050 92 SWAP3 1051 16 AND 1052 91 SWAP2 1053 90 SWAP1 1054 91 SWAP2 1055 17 OR 1056 90 SWAP1 1057 55 SSTORE 1058 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @102A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x06] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // @1057 storage[0x06] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[0x06]) // } // Block ends with unconditional jump to stack[-2] label_1059: // Incoming call from 0x06B5, returns to 0x06B6 // Incoming call from 0x1530, returns to 0x1531 // Inputs[4] // { // @105C stack[-1] // @1067 memory[0x00:0x40] // @1069 storage[keccak256(memory[0x00:0x40])] // @1089 stack[-2] // } 1059 5B JUMPDEST 105A 60 PUSH1 0x00 105C 81 DUP2 105D 81 DUP2 105E 52 MSTORE 105F 60 PUSH1 0x04 1061 60 PUSH1 0x20 1063 52 MSTORE 1064 60 PUSH1 0x40 1066 90 SWAP1 1067 20 SHA3 1068 80 DUP1 1069 54 SLOAD 106A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 107F 19 NOT 1080 16 AND 1081 60 PUSH1 0x01 1083 60 PUSH1 0x01 1085 60 PUSH1 0xa0 1087 1B SHL 1088 03 SUB 1089 84 DUP5 108A 16 AND 108B 90 SWAP1 108C 81 DUP2 108D 17 OR 108E 90 SWAP1 108F 91 SWAP2 1090 55 SSTORE 1091 81 DUP2 1092 90 SWAP1 1093 61 PUSH2 0x109b 1096 82 DUP3 1097 61 PUSH2 0x095b 109A 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @105E memory[0x00:0x20] = stack[-1] // @1063 memory[0x20:0x40] = 0x04 // @1090 storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @1092 stack[0] = stack[-1] // @1092 stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1093 stack[2] = 0x109b // @1096 stack[3] = stack[-1] // } // Block ends with call to 0x095b, returns to 0x109B label_109B: // Incoming return from call to 0x095B at 0x109A // Inputs[7] // { // @10A4 stack[-1] // @10C8 memory[0x40:0x60] // @10CB memory[0x40:0x60] // @10D0 stack[-2] // @10D0 stack[-3] // @10D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @10D3 stack[-6] // } 109B 5B JUMPDEST 109C 60 PUSH1 0x01 109E 60 PUSH1 0x01 10A0 60 PUSH1 0xa0 10A2 1B SHL 10A3 03 SUB 10A4 16 AND 10A5 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 10C6 60 PUSH1 0x40 10C8 51 MLOAD 10C9 60 PUSH1 0x40 10CB 51 MLOAD 10CC 80 DUP1 10CD 91 SWAP2 10CE 03 SUB 10CF 90 SWAP1 10D0 A4 LOG4 10D1 50 POP 10D2 50 POP 10D3 56 *JUMP // Stack delta = -6 // Outputs[1] { @10D0 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_10D4: // Incoming call from 0x0830, returns to 0x0831 // Inputs[1] { @10DD stack[-2] } 10D4 5B JUMPDEST 10D5 60 PUSH1 0x01 10D7 60 PUSH1 0x01 10D9 60 PUSH1 0xa0 10DB 1B SHL 10DC 03 SUB 10DD 82 DUP3 10DE 16 AND 10DF 61 PUSH2 0x112a 10E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x112a, if stack[-2] & (0x01 << 0xa0) - 0x01 label_10E3: // Incoming jump from 0x10E2, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @10E5 memory[0x40:0x60] } 10E3 60 PUSH1 0x40 10E5 51 MLOAD 10E6 62 PUSH3 0x461bcd 10EA 60 PUSH1 0xe5 10EC 1B SHL 10ED 81 DUP2 10EE 52 MSTORE 10EF 60 PUSH1 0x20 10F1 60 PUSH1 0x04 10F3 82 DUP3 10F4 01 ADD 10F5 81 DUP2 10F6 90 SWAP1 10F7 52 MSTORE 10F8 60 PUSH1 0x24 10FA 82 DUP3 10FB 01 ADD 10FC 52 MSTORE 10FD 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 111E 60 PUSH1 0x44 1120 82 DUP3 1121 01 ADD 1122 52 MSTORE 1123 60 PUSH1 0x64 1125 01 ADD 1126 61 PUSH2 0x0564 1129 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @10EE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10F7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10FC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1122 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @1125 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_112A: // Incoming jump from 0x10E2, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @112D stack[-1] // @1138 memory[0x00:0x40] // @1139 storage[keccak256(memory[0x00:0x40])] // } 112A 5B JUMPDEST 112B 60 PUSH1 0x00 112D 81 DUP2 112E 81 DUP2 112F 52 MSTORE 1130 60 PUSH1 0x02 1132 60 PUSH1 0x20 1134 52 MSTORE 1135 60 PUSH1 0x40 1137 90 SWAP1 1138 20 SHA3 1139 54 SLOAD 113A 60 PUSH1 0x01 113C 60 PUSH1 0x01 113E 60 PUSH1 0xa0 1140 1B SHL 1141 03 SUB 1142 16 AND 1143 15 ISZERO 1144 61 PUSH2 0x118f 1147 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @112F memory[0x00:0x20] = stack[-1] // @1134 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x118f, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) label_1148: // Incoming jump from 0x1147, if not !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @114A memory[0x40:0x60] } 1148 60 PUSH1 0x40 114A 51 MLOAD 114B 62 PUSH3 0x461bcd 114F 60 PUSH1 0xe5 1151 1B SHL 1152 81 DUP2 1153 52 MSTORE 1154 60 PUSH1 0x20 1156 60 PUSH1 0x04 1158 82 DUP3 1159 01 ADD 115A 52 MSTORE 115B 60 PUSH1 0x1c 115D 60 PUSH1 0x24 115F 82 DUP3 1160 01 ADD 1161 52 MSTORE 1162 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 1183 60 PUSH1 0x44 1185 82 DUP3 1186 01 ADD 1187 52 MSTORE 1188 60 PUSH1 0x64 118A 01 ADD 118B 61 PUSH2 0x0564 118E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1153 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @115A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1161 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @1187 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @118A stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_118F: // Incoming jump from 0x1147, if !((0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @1198 stack[-2] // @11A7 memory[0x00:0x40] // @11A9 storage[keccak256(memory[0x00:0x40])] // } 118F 5B JUMPDEST 1190 60 PUSH1 0x01 1192 60 PUSH1 0x01 1194 60 PUSH1 0xa0 1196 1B SHL 1197 03 SUB 1198 82 DUP3 1199 16 AND 119A 60 PUSH1 0x00 119C 90 SWAP1 119D 81 DUP2 119E 52 MSTORE 119F 60 PUSH1 0x03 11A1 60 PUSH1 0x20 11A3 52 MSTORE 11A4 60 PUSH1 0x40 11A6 81 DUP2 11A7 20 SHA3 11A8 80 DUP1 11A9 54 SLOAD 11AA 60 PUSH1 0x01 11AC 92 SWAP3 11AD 90 SWAP1 11AE 61 PUSH2 0x11b8 11B1 90 SWAP1 11B2 84 DUP5 11B3 90 SWAP1 11B4 61 PUSH2 0x1b92 11B7 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @119E memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @11A3 memory[0x20:0x40] = 0x03 // @11A7 stack[1] = keccak256(memory[0x00:0x40]) // @11AC stack[0] = 0x01 // @11AD stack[2] = 0x00 // @11B1 stack[3] = 0x11b8 // @11B3 stack[4] = 0x01 // @11B3 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1b92, returns to 0x11B8 label_11B8: // Incoming return from call to 0x1B92 at 0x11B7 // Inputs[10] // { // @11B9 stack[-2] // @11B9 stack[-1] // @11BA stack[-3] // @11C0 stack[-5] // @11CC memory[0x00:0x40] // @11CE storage[keccak256(memory[0x00:0x40])] // @11EE stack[-6] // @11F7 memory[0x40:0x60] // @121F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1222 stack[-7] // } 11B8 5B JUMPDEST 11B9 90 SWAP1 11BA 91 SWAP2 11BB 55 SSTORE 11BC 50 POP 11BD 50 POP 11BE 60 PUSH1 0x00 11C0 81 DUP2 11C1 81 DUP2 11C2 52 MSTORE 11C3 60 PUSH1 0x02 11C5 60 PUSH1 0x20 11C7 52 MSTORE 11C8 60 PUSH1 0x40 11CA 80 DUP1 11CB 82 DUP3 11CC 20 SHA3 11CD 80 DUP1 11CE 54 SLOAD 11CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11E4 19 NOT 11E5 16 AND 11E6 60 PUSH1 0x01 11E8 60 PUSH1 0x01 11EA 60 PUSH1 0xa0 11EC 1B SHL 11ED 03 SUB 11EE 86 DUP7 11EF 16 AND 11F0 90 SWAP1 11F1 81 DUP2 11F2 17 OR 11F3 90 SWAP1 11F4 91 SWAP2 11F5 55 SSTORE 11F6 90 SWAP1 11F7 51 MLOAD 11F8 83 DUP4 11F9 92 SWAP3 11FA 90 SWAP1 11FB 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 121C 90 SWAP1 121D 82 DUP3 121E 90 SWAP1 121F A4 LOG4 1220 50 POP 1221 50 POP 1222 56 *JUMP // Stack delta = -7 // Outputs[5] // { // @11BB storage[stack[-3]] = stack[-1] // @11C2 memory[0x00:0x20] = stack[-5] // @11C7 memory[0x20:0x40] = 0x02 // @11F5 storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @121F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-7] label_1223: // Incoming call from 0x0851, returns to 0x0852 // Incoming call from 0x0D67, returns to 0x0D68 // Inputs[3] // { // @1226 stack[-1] // @1231 memory[0x00:0x40] // @1232 storage[keccak256(memory[0x00:0x40])] // } 1223 5B JUMPDEST 1224 60 PUSH1 0x00 1226 81 DUP2 1227 81 DUP2 1228 52 MSTORE 1229 60 PUSH1 0x02 122B 60 PUSH1 0x20 122D 52 MSTORE 122E 60 PUSH1 0x40 1230 81 DUP2 1231 20 SHA3 1232 54 SLOAD 1233 60 PUSH1 0x01 1235 60 PUSH1 0x01 1237 60 PUSH1 0xa0 1239 1B SHL 123A 03 SUB 123B 16 AND 123C 61 PUSH2 0x12ad 123F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1224 stack[0] = 0x00 // @1228 memory[0x00:0x20] = stack[-1] // @122D memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x12ad, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1240: // Incoming jump from 0x123F, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1242 memory[0x40:0x60] } 1240 60 PUSH1 0x40 1242 51 MLOAD 1243 62 PUSH3 0x461bcd 1247 60 PUSH1 0xe5 1249 1B SHL 124A 81 DUP2 124B 52 MSTORE 124C 60 PUSH1 0x20 124E 60 PUSH1 0x04 1250 82 DUP3 1251 01 ADD 1252 52 MSTORE 1253 60 PUSH1 0x2c 1255 60 PUSH1 0x24 1257 82 DUP3 1258 01 ADD 1259 52 MSTORE 125A 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 127B 60 PUSH1 0x44 127D 82 DUP3 127E 01 ADD 127F 52 MSTORE 1280 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 12A1 60 PUSH1 0x64 12A3 82 DUP3 12A4 01 ADD 12A5 52 MSTORE 12A6 60 PUSH1 0x84 12A8 01 ADD 12A9 61 PUSH2 0x0564 12AC 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @124B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1252 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1259 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @127F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @12A5 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @12A8 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_12AD: // Incoming jump from 0x123F, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @12B3 stack[-2] } 12AD 5B JUMPDEST 12AE 60 PUSH1 0x00 12B0 61 PUSH2 0x12b8 12B3 83 DUP4 12B4 61 PUSH2 0x095b 12B7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12AE stack[0] = 0x00 // @12B0 stack[1] = 0x12b8 // @12B3 stack[2] = stack[-2] // } // Block ends with call to 0x095b, returns to 0x12B8 label_12B8: // Incoming return from call to 0x095B at 0x12B7 // Inputs[3] // { // @12B9 stack[-1] // @12B9 stack[-2] // @12C5 stack[-5] // } 12B8 5B JUMPDEST 12B9 90 SWAP1 12BA 50 POP 12BB 80 DUP1 12BC 60 PUSH1 0x01 12BE 60 PUSH1 0x01 12C0 60 PUSH1 0xa0 12C2 1B SHL 12C3 03 SUB 12C4 16 AND 12C5 84 DUP5 12C6 60 PUSH1 0x01 12C8 60 PUSH1 0x01 12CA 60 PUSH1 0xa0 12CC 1B SHL 12CD 03 SUB 12CE 16 AND 12CF 14 EQ 12D0 80 DUP1 12D1 61 PUSH2 0x12f3 12D4 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @12B9 stack[-2] = stack[-1] // @12CF stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x12f3, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_12D5: // Incoming jump from 0x12D4, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @12D6 stack[-5] // @12E3 stack[-4] // } 12D5 50 POP 12D6 83 DUP4 12D7 60 PUSH1 0x01 12D9 60 PUSH1 0x01 12DB 60 PUSH1 0xa0 12DD 1B SHL 12DE 03 SUB 12DF 16 AND 12E0 61 PUSH2 0x12e8 12E3 84 DUP5 12E4 61 PUSH2 0x04de 12E7 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12DF stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @12E0 stack[0] = 0x12e8 // @12E3 stack[1] = stack[-4] // } // Block ends with call to 0x04de, returns to 0x12E8 label_12E8: // Incoming return from call to 0x04DE at 0x12E7 // Inputs[2] // { // @12F1 stack[-1] // @12F2 stack[-2] // } 12E8 5B JUMPDEST 12E9 60 PUSH1 0x01 12EB 60 PUSH1 0x01 12ED 60 PUSH1 0xa0 12EF 1B SHL 12F0 03 SUB 12F1 16 AND 12F2 14 EQ // Stack delta = -1 // Outputs[1] { @12F2 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_12F3: // Incoming jump from 0x12F2 // Incoming jump from 0x12D4, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[1] { @12F4 stack[-1] } 12F3 5B JUMPDEST 12F4 80 DUP1 12F5 61 PUSH2 0x1323 12F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1323, if stack[-1] label_12F9: // Incoming jump from 0x12F8, if not stack[-1] // Inputs[5] // { // @1303 stack[-2] // @1315 memory[0x00:0x40] // @1317 stack[-5] // @131E memory[0x00:0x40] // @131F storage[keccak256(memory[0x00:0x40])] // } 12F9 50 POP 12FA 60 PUSH1 0x01 12FC 60 PUSH1 0x01 12FE 60 PUSH1 0xa0 1300 1B SHL 1301 03 SUB 1302 80 DUP1 1303 82 DUP3 1304 16 AND 1305 60 PUSH1 0x00 1307 90 SWAP1 1308 81 DUP2 1309 52 MSTORE 130A 60 PUSH1 0x05 130C 60 PUSH1 0x20 130E 90 SWAP1 130F 81 DUP2 1310 52 MSTORE 1311 60 PUSH1 0x40 1313 80 DUP1 1314 83 DUP4 1315 20 SHA3 1316 93 SWAP4 1317 88 DUP9 1318 16 AND 1319 83 DUP4 131A 52 MSTORE 131B 92 SWAP3 131C 90 SWAP1 131D 52 MSTORE 131E 20 SHA3 131F 54 SLOAD 1320 60 PUSH1 0xff 1322 16 AND // Stack delta = +0 // Outputs[5] // { // @1309 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1310 memory[0x20:0x40] = 0x05 // @131A memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @131D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1322 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_1323: // Incoming return from call to 0x183C at 0x1ADC // Incoming jump from 0x1322 // Incoming jump from 0x12F8, if stack[-1] // Inputs[3] // { // @1324 stack[-6] // @1324 stack[-1] // @1325 stack[-5] // } 1323 5B JUMPDEST 1324 94 SWAP5 1325 93 SWAP4 1326 50 POP 1327 50 POP 1328 50 POP 1329 50 POP 132A 56 *JUMP // Stack delta = -5 // Outputs[1] { @1324 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_132B: // Incoming jump from 0x139D // Incoming jump from 0x08CE // Inputs[1] { @132E storage[0x09] } 132B 5B JUMPDEST 132C 60 PUSH1 0x09 132E 54 SLOAD 132F 60 PUSH1 0xff 1331 61 PUSH2 0x0100 1334 90 SWAP1 1335 91 SWAP2 1336 04 DIV 1337 16 AND 1338 15 ISZERO 1339 15 ISZERO 133A 60 PUSH1 0x01 133C 14 EQ 133D 61 PUSH2 0x1388 1340 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1388, if 0x01 == !!(storage[0x09] / 0x0100 & 0xff) label_1341: // Incoming jump from 0x1340, if not 0x01 == !!(storage[0x09] / 0x0100 & 0xff) // Inputs[1] { @1343 memory[0x40:0x60] } 1341 60 PUSH1 0x40 1343 51 MLOAD 1344 62 PUSH3 0x461bcd 1348 60 PUSH1 0xe5 134A 1B SHL 134B 81 DUP2 134C 52 MSTORE 134D 60 PUSH1 0x20 134F 60 PUSH1 0x04 1351 82 DUP3 1352 01 ADD 1353 52 MSTORE 1354 60 PUSH1 0x1e 1356 60 PUSH1 0x24 1358 82 DUP3 1359 01 ADD 135A 52 MSTORE 135B 7F PUSH32 0x5468697320746f6b656e206973206e6f6e2d7472616e7366657261626c650000 137C 60 PUSH1 0x44 137E 82 DUP3 137F 01 ADD 1380 52 MSTORE 1381 60 PUSH1 0x64 1383 01 ADD 1384 61 PUSH2 0x0564 1387 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @134C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1353 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @135A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @1380 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468697320746f6b656e206973206e6f6e2d7472616e7366657261626c650000 // @1383 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_1388: // Incoming jump from 0x1340, if 0x01 == !!(storage[0x09] / 0x0100 & 0xff) // Inputs[3] // { // @138C stack[-3] // @138D stack[-2] // @138E stack[-1] // } 1388 5B JUMPDEST 1389 61 PUSH2 0x06b6 138C 83 DUP4 138D 83 DUP4 138E 83 DUP4 138F 61 PUSH2 0x141c 1392 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1389 stack[0] = 0x06b6 // @138C stack[1] = stack[-3] // @138D stack[2] = stack[-2] // @138E stack[3] = stack[-1] // } // Block ends with call to 0x141c, returns to 0x06B6 label_1393: // Incoming jump from 0x0DE5 // Inputs[3] // { // @1397 stack[-4] // @1398 stack[-3] // @1399 stack[-2] // } 1393 5B JUMPDEST 1394 61 PUSH2 0x139e 1397 84 DUP5 1398 84 DUP5 1399 84 DUP5 139A 61 PUSH2 0x132b 139D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1394 stack[0] = 0x139e // @1397 stack[1] = stack[-4] // @1398 stack[2] = stack[-3] // @1399 stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x132b 139E 5B JUMPDEST 139F 61 PUSH2 0x13aa 13A2 84 DUP5 13A3 84 DUP5 13A4 84 DUP5 13A5 84 DUP5 13A6 61 PUSH2 0x15f6 13A9 56 *JUMP 13AA 5B JUMPDEST 13AB 61 PUSH2 0x0de6 13AE 57 *JUMPI 13AF 60 PUSH1 0x40 13B1 51 MLOAD 13B2 62 PUSH3 0x461bcd 13B6 60 PUSH1 0xe5 13B8 1B SHL 13B9 81 DUP2 13BA 52 MSTORE 13BB 60 PUSH1 0x20 13BD 60 PUSH1 0x04 13BF 82 DUP3 13C0 01 ADD 13C1 52 MSTORE 13C2 60 PUSH1 0x32 13C4 60 PUSH1 0x24 13C6 82 DUP3 13C7 01 ADD 13C8 52 MSTORE 13C9 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 13EA 60 PUSH1 0x44 13EC 82 DUP3 13ED 01 ADD 13EE 52 MSTORE 13EF 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 1410 60 PUSH1 0x64 1412 82 DUP3 1413 01 ADD 1414 52 MSTORE 1415 60 PUSH1 0x84 1417 01 ADD 1418 61 PUSH2 0x0564 141B 56 *JUMP label_141C: // Incoming call from 0x1392, returns to 0x06B6 // Inputs[2] // { // @141D stack[-3] // @142A stack[-1] // } 141C 5B JUMPDEST 141D 82 DUP3 141E 60 PUSH1 0x01 1420 60 PUSH1 0x01 1422 60 PUSH1 0xa0 1424 1B SHL 1425 03 SUB 1426 16 AND 1427 61 PUSH2 0x142f 142A 82 DUP3 142B 61 PUSH2 0x095b 142E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1426 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1427 stack[1] = 0x142f // @142A stack[2] = stack[-1] // } // Block ends with call to 0x095b, returns to 0x142F label_142F: // Incoming return from call to 0x095B at 0x142E // Inputs[2] // { // @1438 stack[-1] // @1439 stack[-2] // } 142F 5B JUMPDEST 1430 60 PUSH1 0x01 1432 60 PUSH1 0x01 1434 60 PUSH1 0xa0 1436 1B SHL 1437 03 SUB 1438 16 AND 1439 14 EQ 143A 61 PUSH2 0x14ab 143D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x14ab, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_143E: // Incoming jump from 0x143D, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1440 memory[0x40:0x60] } 143E 60 PUSH1 0x40 1440 51 MLOAD 1441 62 PUSH3 0x461bcd 1445 60 PUSH1 0xe5 1447 1B SHL 1448 81 DUP2 1449 52 MSTORE 144A 60 PUSH1 0x20 144C 60 PUSH1 0x04 144E 82 DUP3 144F 01 ADD 1450 52 MSTORE 1451 60 PUSH1 0x29 1453 60 PUSH1 0x24 1455 82 DUP3 1456 01 ADD 1457 52 MSTORE 1458 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 1479 60 PUSH1 0x44 147B 82 DUP3 147C 01 ADD 147D 52 MSTORE 147E 7F PUSH32 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 149F 60 PUSH1 0x64 14A1 82 DUP3 14A2 01 ADD 14A3 52 MSTORE 14A4 60 PUSH1 0x84 14A6 01 ADD 14A7 61 PUSH2 0x0564 14AA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1449 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1450 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1457 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @147D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 // @14A3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73206e6f74206f776e0000000000000000000000000000000000000000000000 // @14A6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_14AB: // Incoming jump from 0x143D, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @14B4 stack[-2] } 14AB 5B JUMPDEST 14AC 60 PUSH1 0x01 14AE 60 PUSH1 0x01 14B0 60 PUSH1 0xa0 14B2 1B SHL 14B3 03 SUB 14B4 82 DUP3 14B5 16 AND 14B6 61 PUSH2 0x1526 14B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1526, if stack[-2] & (0x01 << 0xa0) - 0x01 label_14BA: // Incoming jump from 0x14B9, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @14BC memory[0x40:0x60] } 14BA 60 PUSH1 0x40 14BC 51 MLOAD 14BD 62 PUSH3 0x461bcd 14C1 60 PUSH1 0xe5 14C3 1B SHL 14C4 81 DUP2 14C5 52 MSTORE 14C6 60 PUSH1 0x20 14C8 60 PUSH1 0x04 14CA 82 DUP3 14CB 01 ADD 14CC 52 MSTORE 14CD 60 PUSH1 0x24 14CF 80 DUP1 14D0 82 DUP3 14D1 01 ADD 14D2 52 MSTORE 14D3 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 14F4 60 PUSH1 0x44 14F6 82 DUP3 14F7 01 ADD 14F8 52 MSTORE 14F9 7F PUSH32 0x7265737300000000000000000000000000000000000000000000000000000000 151A 60 PUSH1 0x64 151C 82 DUP3 151D 01 ADD 151E 52 MSTORE 151F 60 PUSH1 0x84 1521 01 ADD 1522 61 PUSH2 0x0564 1525 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @14C5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @14CC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @14D2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @14F8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @151E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7265737300000000000000000000000000000000000000000000000000000000 // @1521 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0564 label_1526: // Incoming jump from 0x14B9, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @152C stack[-1] } 1526 5B JUMPDEST 1527 61 PUSH2 0x1531 152A 60 PUSH1 0x00 152C 82 DUP3 152D 61 PUSH2 0x1059 1530 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1527 stack[0] = 0x1531 // @152A stack[1] = 0x00 // @152C stack[2] = stack[-1] // } // Block ends with call to 0x1059, returns to 0x1531 label_1531: // Incoming return from call to 0x1059 at 0x1530 // Inputs[3] // { // @153A stack[-3] // @1549 memory[0x00:0x40] // @154B storage[keccak256(memory[0x00:0x40])] // } 1531 5B JUMPDEST 1532 60 PUSH1 0x01 1534 60 PUSH1 0x01 1536 60 PUSH1 0xa0 1538 1B SHL 1539 03 SUB 153A 83 DUP4 153B 16 AND 153C 60 PUSH1 0x00 153E 90 SWAP1 153F 81 DUP2 1540 52 MSTORE 1541 60 PUSH1 0x03 1543 60 PUSH1 0x20 1545 52 MSTORE 1546 60 PUSH1 0x40 1548 81 DUP2 1549 20 SHA3 154A 80 DUP1 154B 54 SLOAD 154C 60 PUSH1 0x01 154E 92 SWAP3 154F 90 SWAP1 1550 61 PUSH2 0x155a 1553 90 SWAP1 1554 84 DUP5 1555 90 SWAP1 1556 61 PUSH2 0x1baa 1559 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @1540 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1545 memory[0x20:0x40] = 0x03 // @1549 stack[1] = keccak256(memory[0x00:0x40]) // @154E stack[0] = 0x01 // @154F stack[2] = 0x00 // @1553 stack[3] = 0x155a // @1555 stack[4] = 0x01 // @1555 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1baa, returns to 0x155A label_155A: // Incoming return from call to 0x1BAA at 0x1559 // Inputs[6] // { // @155B stack[-2] // @155B stack[-1] // @155C stack[-3] // @1568 stack[-6] // @1577 memory[0x00:0x40] // @1579 storage[keccak256(memory[0x00:0x40])] // } 155A 5B JUMPDEST 155B 90 SWAP1 155C 91 SWAP2 155D 55 SSTORE 155E 50 POP 155F 50 POP 1560 60 PUSH1 0x01 1562 60 PUSH1 0x01 1564 60 PUSH1 0xa0 1566 1B SHL 1567 03 SUB 1568 82 DUP3 1569 16 AND 156A 60 PUSH1 0x00 156C 90 SWAP1 156D 81 DUP2 156E 52 MSTORE 156F 60 PUSH1 0x03 1571 60 PUSH1 0x20 1573 52 MSTORE 1574 60 PUSH1 0x40 1576 81 DUP2 1577 20 SHA3 1578 80 DUP1 1579 54 SLOAD 157A 60 PUSH1 0x01 157C 92 SWAP3 157D 90 SWAP1 157E 61 PUSH2 0x1588 1581 90 SWAP1 1582 84 DUP5 1583 90 SWAP1 1584 61 PUSH2 0x1b92 1587 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @155D storage[stack[-3]] = stack[-1] // @156E memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1573 memory[0x20:0x40] = 0x03 // @1577 stack[-3] = keccak256(memory[0x00:0x40]) // @157C stack[-4] = 0x01 // @157D stack[-2] = 0x00 // @1581 stack[-1] = 0x1588 // @1583 stack[0] = 0x01 // @1583 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1b92, returns to 0x1588 label_1588: // Incoming return from call to 0x1B92 at 0x1587 // Inputs[11] // { // @1589 stack[-2] // @1589 stack[-1] // @158A stack[-3] // @1590 stack[-5] // @159C memory[0x00:0x40] // @159E storage[keccak256(memory[0x00:0x40])] // @15BE stack[-6] // @15C8 memory[0x40:0x60] // @15CC stack[-7] // @15F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @15F5 stack[-8] // } 1588 5B JUMPDEST 1589 90 SWAP1 158A 91 SWAP2 158B 55 SSTORE 158C 50 POP 158D 50 POP 158E 60 PUSH1 0x00 1590 81 DUP2 1591 81 DUP2 1592 52 MSTORE 1593 60 PUSH1 0x02 1595 60 PUSH1 0x20 1597 52 MSTORE 1598 60 PUSH1 0x40 159A 80 DUP1 159B 82 DUP3 159C 20 SHA3 159D 80 DUP1 159E 54 SLOAD 159F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 15B4 19 NOT 15B5 16 AND 15B6 60 PUSH1 0x01 15B8 60 PUSH1 0x01 15BA 60 PUSH1 0xa0 15BC 1B SHL 15BD 03 SUB 15BE 86 DUP7 15BF 81 DUP2 15C0 16 AND 15C1 91 SWAP2 15C2 82 DUP3 15C3 17 OR 15C4 90 SWAP1 15C5 92 SWAP3 15C6 55 SSTORE 15C7 91 SWAP2 15C8 51 MLOAD 15C9 84 DUP5 15CA 93 SWAP4 15CB 91 SWAP2 15CC 87 DUP8 15CD 16 AND 15CE 91 SWAP2 15CF 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 15F0 91 SWAP2 15F1 A4 LOG4 15F2 50 POP 15F3 50 POP 15F4 50 POP 15F5 56 *JUMP // Stack delta = -8 // Outputs[5] // { // @158B storage[stack[-3]] = stack[-1] // @1592 memory[0x00:0x20] = stack[-5] // @1597 memory[0x20:0x40] = 0x02 // @15C6 storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @15F1 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-8] 15F6 5B JUMPDEST 15F7 60 PUSH1 0x00 15F9 60 PUSH1 0x01 15FB 60 PUSH1 0x01 15FD 60 PUSH1 0xa0 15FF 1B SHL 1600 03 SUB 1601 84 DUP5 1602 16 AND 1603 3B EXTCODESIZE 1604 15 ISZERO 1605 61 PUSH2 0x1798 1608 57 *JUMPI 1609 60 PUSH1 0x40 160B 51 MLOAD 160C 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 162D 81 DUP2 162E 52 MSTORE 162F 60 PUSH1 0x01 1631 60 PUSH1 0x01 1633 60 PUSH1 0xa0 1635 1B SHL 1636 03 SUB 1637 85 DUP6 1638 16 AND 1639 90 SWAP1 163A 63 PUSH4 0x150b7a02 163F 90 SWAP1 1640 61 PUSH2 0x1653 1643 90 SWAP1 1644 33 CALLER 1645 90 SWAP1 1646 89 DUP10 1647 90 SWAP1 1648 88 DUP9 1649 90 SWAP1 164A 88 DUP9 164B 90 SWAP1 164C 60 PUSH1 0x04 164E 01 ADD 164F 61 PUSH2 0x1b43 1652 56 *JUMP 1653 5B JUMPDEST 1654 60 PUSH1 0x20 1656 60 PUSH1 0x40 1658 51 MLOAD 1659 80 DUP1 165A 83 DUP4 165B 03 SUB 165C 81 DUP2 165D 60 PUSH1 0x00 165F 87 DUP8 1660 80 DUP1 1661 3B EXTCODESIZE 1662 15 ISZERO 1663 80 DUP1 1664 15 ISZERO 1665 61 PUSH2 0x166d 1668 57 *JUMPI 1669 60 PUSH1 0x00 166B 80 DUP1 166C FD *REVERT 166D 5B JUMPDEST 166E 50 POP 166F 5A GAS 1670 F1 CALL 1671 92 SWAP3 1672 50 POP 1673 50 POP 1674 50 POP 1675 80 DUP1 1676 15 ISZERO 1677 61 PUSH2 0x169d 167A 57 *JUMPI 167B 50 POP 167C 60 PUSH1 0x40 167E 80 DUP1 167F 51 MLOAD 1680 60 PUSH1 0x1f 1682 3D RETURNDATASIZE 1683 90 SWAP1 1684 81 DUP2 1685 01 ADD 1686 60 PUSH1 0x1f 1688 19 NOT 1689 16 AND 168A 82 DUP3 168B 01 ADD 168C 90 SWAP1 168D 92 SWAP3 168E 52 MSTORE 168F 61 PUSH2 0x169a 1692 91 SWAP2 1693 81 DUP2 1694 01 ADD 1695 90 SWAP1 1696 61 PUSH2 0x1a77 1699 56 *JUMP 169A 5B JUMPDEST 169B 60 PUSH1 0x01 169D 5B JUMPDEST 169E 61 PUSH2 0x174d 16A1 57 *JUMPI 16A2 3D RETURNDATASIZE 16A3 80 DUP1 16A4 80 DUP1 16A5 15 ISZERO 16A6 61 PUSH2 0x16cb 16A9 57 *JUMPI 16AA 60 PUSH1 0x40 16AC 51 MLOAD 16AD 91 SWAP2 16AE 50 POP 16AF 60 PUSH1 0x1f 16B1 19 NOT 16B2 60 PUSH1 0x3f 16B4 3D RETURNDATASIZE 16B5 01 ADD 16B6 16 AND 16B7 82 DUP3 16B8 01 ADD 16B9 60 PUSH1 0x40 16BB 52 MSTORE 16BC 3D RETURNDATASIZE 16BD 82 DUP3 16BE 52 MSTORE 16BF 3D RETURNDATASIZE 16C0 60 PUSH1 0x00 16C2 60 PUSH1 0x20 16C4 84 DUP5 16C5 01 ADD 16C6 3E RETURNDATACOPY 16C7 61 PUSH2 0x16d0 16CA 56 *JUMP 16CB 5B JUMPDEST 16CC 60 PUSH1 0x60 16CE 91 SWAP2 16CF 50 POP 16D0 5B JUMPDEST 16D1 50 POP 16D2 80 DUP1 16D3 51 MLOAD 16D4 61 PUSH2 0x1745 16D7 57 *JUMPI 16D8 60 PUSH1 0x40 16DA 51 MLOAD 16DB 62 PUSH3 0x461bcd 16DF 60 PUSH1 0xe5 16E1 1B SHL 16E2 81 DUP2 16E3 52 MSTORE 16E4 60 PUSH1 0x20 16E6 60 PUSH1 0x04 16E8 82 DUP3 16E9 01 ADD 16EA 52 MSTORE 16EB 60 PUSH1 0x32 16ED 60 PUSH1 0x24 16EF 82 DUP3 16F0 01 ADD 16F1 52 MSTORE 16F2 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 1713 60 PUSH1 0x44 1715 82 DUP3 1716 01 ADD 1717 52 MSTORE 1718 7F PUSH32 0x63656976657220696d706c656d656e7465720000000000000000000000000000 1739 60 PUSH1 0x64 173B 82 DUP3 173C 01 ADD 173D 52 MSTORE 173E 60 PUSH1 0x84 1740 01 ADD 1741 61 PUSH2 0x0564 1744 56 *JUMP 1745 5B JUMPDEST 1746 80 DUP1 1747 51 MLOAD 1748 81 DUP2 1749 60 PUSH1 0x20 174B 01 ADD 174C FD *REVERT 174D 5B JUMPDEST 174E 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 176F 16 AND 1770 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 1791 14 EQ 1792 90 SWAP1 1793 50 POP 1794 61 PUSH2 0x1323 1797 56 *JUMP 1798 5B JUMPDEST 1799 50 POP 179A 60 PUSH1 0x01 179C 94 SWAP5 179D 93 SWAP4 179E 50 POP 179F 50 POP 17A0 50 POP 17A1 50 POP 17A2 56 *JUMP label_17A3: // Incoming jump from 0x093B // Inputs[2] // { // @17A4 stack[-3] // @17A6 storage[stack[-3]] // } 17A3 5B JUMPDEST 17A4 82 DUP3 17A5 80 DUP1 17A6 54 SLOAD 17A7 61 PUSH2 0x17af 17AA 90 SWAP1 17AB 61 PUSH2 0x1bc1 17AE 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @17A4 stack[0] = stack[-3] // @17AA stack[1] = 0x17af // @17AA stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1bc1, returns to 0x17AF label_17AF: // Incoming return from call to 0x1BC1 at 0x17AE // Inputs[5] // { // @17B0 stack[-1] // @17B0 stack[-2] // @17B8 memory[0x00:0x20] // @17C3 stack[-4] // @17C4 stack[-3] // } 17AF 5B JUMPDEST 17B0 90 SWAP1 17B1 60 PUSH1 0x00 17B3 52 MSTORE 17B4 60 PUSH1 0x20 17B6 60 PUSH1 0x00 17B8 20 SHA3 17B9 90 SWAP1 17BA 60 PUSH1 0x1f 17BC 01 ADD 17BD 60 PUSH1 0x20 17BF 90 SWAP1 17C0 04 DIV 17C1 81 DUP2 17C2 01 ADD 17C3 92 SWAP3 17C4 82 DUP3 17C5 61 PUSH2 0x17d1 17C8 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @17B3 memory[0x00:0x20] = stack[-2] // @17B9 stack[-2] = keccak256(memory[0x00:0x20]) // @17C3 stack[-1] = stack[-4] // @17C3 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x17d1, if stack[-3] label_17C9: // Incoming jump from 0x17C8, if not stack[-3] // Inputs[1] { @17CB stack[-5] } 17C9 60 PUSH1 0x00 17CB 85 DUP6 17CC 55 SSTORE 17CD 61 PUSH2 0x1817 17D0 56 *JUMP // Stack delta = +0 // Outputs[1] { @17CC storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1817 label_17D1: // Incoming jump from 0x17C8, if stack[-3] // Inputs[1] { @17D2 stack[-3] } 17D1 5B JUMPDEST 17D2 82 DUP3 17D3 60 PUSH1 0x1f 17D5 10 LT 17D6 61 PUSH2 0x17ea 17D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17ea, if 0x1f < stack[-3] label_17DA: // Incoming jump from 0x17D9, if not 0x1f < stack[-3] // Inputs[4] // { // @17DA stack[-1] // @17DB memory[stack[-1]:stack[-1] + 0x20] // @17E0 stack[-3] // @17E4 stack[-5] // } 17DA 80 DUP1 17DB 51 MLOAD 17DC 60 PUSH1 0xff 17DE 19 NOT 17DF 16 AND 17E0 83 DUP4 17E1 80 DUP1 17E2 01 ADD 17E3 17 OR 17E4 85 DUP6 17E5 55 SSTORE 17E6 61 PUSH2 0x1817 17E9 56 *JUMP // Stack delta = +0 // Outputs[1] { @17E5 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x1817 label_17EA: // Incoming jump from 0x17D9, if 0x1f < stack[-3] // Inputs[2] // { // @17EB stack[-3] // @17F1 stack[-5] // } 17EA 5B JUMPDEST 17EB 82 DUP3 17EC 80 DUP1 17ED 01 ADD 17EE 60 PUSH1 0x01 17F0 01 ADD 17F1 85 DUP6 17F2 55 SSTORE 17F3 82 DUP3 17F4 15 ISZERO 17F5 61 PUSH2 0x1817 17F8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @17F2 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1817, if !stack[-3] label_17F9: // Incoming jump from 0x17F8, if not !stack[-3] // Inputs[2] // { // @17F9 stack[-1] // @17F9 stack[-3] // } 17F9 91 SWAP2 17FA 82 DUP3 17FB 01 ADD 17FC 5B JUMPDEST 17FD 82 DUP3 17FE 81 DUP2 17FF 11 GT 1800 15 ISZERO 1801 61 PUSH2 0x1817 1804 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @17F9 stack[-3] = stack[-1] // @17FB stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1817, if !(stack[-1] + stack[-3] > stack[-1]) label_1805: // Incoming jump from 0x1804, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1804, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1805 stack[-3] // @1806 memory[stack[-3]:stack[-3] + 0x20] // @1807 stack[-2] // @1809 stack[-1] // } 1805 82 DUP3 1806 51 MLOAD 1807 82 DUP3 1808 55 SSTORE 1809 91 SWAP2 180A 60 PUSH1 0x20 180C 01 ADD 180D 91 SWAP2 180E 90 SWAP1 180F 60 PUSH1 0x01 1811 01 ADD 1812 90 SWAP1 1813 61 PUSH2 0x17fc 1816 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1808 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @180D stack[-3] = 0x20 + stack[-3] // @1812 stack[-2] = 0x01 + stack[-2] // @1812 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x17fc label_1817: // Incoming jump from 0x1804, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x17F8, if !stack[-3] // Incoming jump from 0x17E9 // Incoming jump from 0x17D0 // Incoming jump from 0x1804, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @181C stack[-4] // @181D stack[-3] // } 1817 5B JUMPDEST 1818 50 POP 1819 61 PUSH2 0x1823 181C 92 SWAP3 181D 91 SWAP2 181E 50 POP 181F 61 PUSH2 0x1827 1822 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @181C stack[-4] = 0x1823 // @181D stack[-3] = stack[-4] // } // Block ends with call to 0x1827, returns to 0x1823 label_1823: // Incoming return from call to 0x1827 at 0x1822 // Incoming jump from 0x1830, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1830, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1825 stack[-3] // @1825 stack[-2] // } 1823 5B JUMPDEST 1824 50 POP 1825 90 SWAP1 1826 56 *JUMP // Stack delta = -2 // Outputs[1] { @1825 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1827: // Incoming call from 0x1822, returns to 0x1823 // Inputs[2] // { // @1829 stack[-1] // @182A stack[-2] // } 1827 5B JUMPDEST 1828 5B JUMPDEST 1829 80 DUP1 182A 82 DUP3 182B 11 GT 182C 15 ISZERO 182D 61 PUSH2 0x1823 1830 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1823, if !(stack[-2] > stack[-1]) label_1831: // Incoming jump from 0x1830, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1830, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1833 stack[-1] } 1831 60 PUSH1 0x00 1833 81 DUP2 1834 55 SSTORE 1835 60 PUSH1 0x01 1837 01 ADD 1838 61 PUSH2 0x1828 183B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1834 storage[stack[-1]] = 0x00 // @1837 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1828 label_183C: // Incoming call from 0x19DE, returns to 0x19DF // Incoming call from 0x1ADC, returns to 0x1323 // Inputs[1] { @1849 stack[-2] } 183C 5B JUMPDEST 183D 60 PUSH1 0x00 183F 67 PUSH8 0xffffffffffffffff 1848 80 DUP1 1849 84 DUP5 184A 11 GT 184B 15 ISZERO 184C 61 PUSH2 0x1857 184F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @183D stack[0] = 0x00 // @183F stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1857, if !(stack[-2] > 0xffffffffffffffff) label_1850: // Incoming jump from 0x184F, if not !(stack[-2] > 0xffffffffffffffff) 1850 61 PUSH2 0x1857 1853 61 PUSH2 0x1c4b 1856 56 *JUMP // Stack delta = +1 // Outputs[1] { @1850 stack[0] = 0x1857 } // Block ends with unconditional jump to 0x1c4b label_1857: // Incoming jump from 0x184F, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @185A memory[0x40:0x60] // @185D stack[-4] // @186C stack[-1] // } 1857 5B JUMPDEST 1858 60 PUSH1 0x40 185A 51 MLOAD 185B 60 PUSH1 0x1f 185D 85 DUP6 185E 01 ADD 185F 60 PUSH1 0x1f 1861 19 NOT 1862 90 SWAP1 1863 81 DUP2 1864 16 AND 1865 60 PUSH1 0x3f 1867 01 ADD 1868 16 AND 1869 81 DUP2 186A 01 ADD 186B 90 SWAP1 186C 82 DUP3 186D 82 DUP3 186E 11 GT 186F 81 DUP2 1870 83 DUP4 1871 10 LT 1872 17 OR 1873 15 ISZERO 1874 61 PUSH2 0x187f 1877 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @186B stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @186B stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x187f, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_1878: // Incoming jump from 0x1877, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 1878 61 PUSH2 0x187f 187B 61 PUSH2 0x1c4b 187E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1878 stack[0] = 0x187f } // Block ends with unconditional jump to 0x1c4b label_187F: // Incoming jump from 0x1877, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @1880 stack[-2] // @1884 stack[-1] // @1885 stack[-4] // @1887 stack[-6] // @188A stack[-7] // @188C stack[-5] // } 187F 5B JUMPDEST 1880 81 DUP2 1881 60 PUSH1 0x40 1883 52 MSTORE 1884 80 DUP1 1885 93 SWAP4 1886 50 POP 1887 85 DUP6 1888 81 DUP2 1889 52 MSTORE 188A 86 DUP7 188B 86 DUP7 188C 86 DUP7 188D 01 ADD 188E 11 GT 188F 15 ISZERO 1890 61 PUSH2 0x1898 1893 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1883 memory[0x40:0x60] = stack[-2] // @1885 stack[-4] = stack[-1] // @1889 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x1898, if !(stack[-5] + stack[-6] > stack[-7]) label_1894: // Incoming jump from 0x1893, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @1897 memory[0x00:0x00] } 1894 60 PUSH1 0x00 1896 80 DUP1 1897 FD *REVERT // Stack delta = +0 // Outputs[1] { @1897 revert(memory[0x00:0x00]); } // Block terminates label_1898: // Incoming jump from 0x1893, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @1899 stack[-6] // @189A stack[-5] // @189D stack[-1] // @189F msg.data[stack[-5]:stack[-5] + stack[-6]] // @18AC stack[-4] // @18AC stack[-8] // @18AD stack[-7] // } 1898 5B JUMPDEST 1899 85 DUP6 189A 85 DUP6 189B 60 PUSH1 0x20 189D 83 DUP4 189E 01 ADD 189F 37 CALLDATACOPY 18A0 60 PUSH1 0x00 18A2 60 PUSH1 0x20 18A4 87 DUP8 18A5 83 DUP4 18A6 01 ADD 18A7 01 ADD 18A8 52 MSTORE 18A9 50 POP 18AA 50 POP 18AB 50 POP 18AC 93 SWAP4 18AD 92 SWAP3 18AE 50 POP 18AF 50 POP 18B0 50 POP 18B1 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @189F memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @18A8 memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @18AC stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_18B2: // Incoming call from 0x1929, returns to 0x192A // Incoming call from 0x1950, returns to 0x1951 // Incoming call from 0x191B, returns to 0x191C // Incoming call from 0x198D, returns to 0x198E // Incoming call from 0x18F8, returns to 0x18F9 // Incoming call from 0x195E, returns to 0x195F // Incoming call from 0x199B, returns to 0x199C // Incoming call from 0x1A30, returns to 0x1A31 // Incoming call from 0x1A06, returns to 0x1A07 // Inputs[2] // { // @18B3 stack[-1] // @18B4 msg.data[stack[-1]:stack[-1] + 0x20] // } 18B2 5B JUMPDEST 18B3 80 DUP1 18B4 35 CALLDATALOAD 18B5 60 PUSH1 0x01 18B7 60 PUSH1 0x01 18B9 60 PUSH1 0xa0 18BB 1B SHL 18BC 03 SUB 18BD 81 DUP2 18BE 16 AND 18BF 81 DUP2 18C0 14 EQ 18C1 61 PUSH2 0x18c9 18C4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18B4 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x18c9, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_18C5: // Incoming jump from 0x18C4, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @18C8 memory[0x00:0x00] } 18C5 60 PUSH1 0x00 18C7 80 DUP1 18C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @18C8 revert(memory[0x00:0x00]); } // Block terminates label_18C9: // Incoming jump from 0x18D9, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x18C4, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @18CA stack[-3] // @18CA stack[-1] // @18CB stack[-2] // } 18C9 5B JUMPDEST 18CA 91 SWAP2 18CB 90 SWAP1 18CC 50 POP 18CD 56 *JUMP // Stack delta = -2 // Outputs[1] { @18CA stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_18CE: // Incoming call from 0x1A59, returns to 0x18F9 // Incoming call from 0x1A14, returns to 0x192A // Inputs[2] // { // @18CF stack[-1] // @18D0 msg.data[stack[-1]:stack[-1] + 0x20] // } 18CE 5B JUMPDEST 18CF 80 DUP1 18D0 35 CALLDATALOAD 18D1 80 DUP1 18D2 15 ISZERO 18D3 15 ISZERO 18D4 81 DUP2 18D5 14 EQ 18D6 61 PUSH2 0x18c9 18D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18D0 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x18c9, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_18DA: // Incoming jump from 0x18D9, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @18DD memory[0x00:0x00] } 18DA 60 PUSH1 0x00 18DC 80 DUP1 18DD FD *REVERT // Stack delta = +0 // Outputs[1] { @18DD revert(memory[0x00:0x00]); } // Block terminates label_18DE: // Incoming call from 0x0361, returns to 0x0362 // Incoming call from 0x028A, returns to 0x028B // Inputs[2] // { // @18E3 stack[-1] // @18E4 stack[-2] // } 18DE 5B JUMPDEST 18DF 60 PUSH1 0x00 18E1 60 PUSH1 0x20 18E3 82 DUP3 18E4 84 DUP5 18E5 03 SUB 18E6 12 SLT 18E7 15 ISZERO 18E8 61 PUSH2 0x18f0 18EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18DF stack[0] = 0x00 } // Block ends with conditional jump to 0x18f0, if !(stack[-2] - stack[-1] i< 0x20) label_18EC: // Incoming jump from 0x18EB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @18EF memory[0x00:0x00] } 18EC 60 PUSH1 0x00 18EE 80 DUP1 18EF FD *REVERT // Stack delta = +0 // Outputs[1] { @18EF revert(memory[0x00:0x00]); } // Block terminates label_18F0: // Incoming jump from 0x18EB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @18F4 stack[-2] } 18F0 5B JUMPDEST 18F1 61 PUSH2 0x18f9 18F4 82 DUP3 18F5 61 PUSH2 0x18b2 18F8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @18F1 stack[0] = 0x18f9 // @18F4 stack[1] = stack[-2] // } // Block ends with call to 0x18b2, returns to 0x18F9 label_18F9: // Incoming return from call to 0x18CE at 0x1A59 // Incoming return from call to 0x1AF6 at 0x1B91 // Incoming return from call to 0x18B2 at 0x18F8 // Incoming return from call to 0x1C61 at 0x1A76 // Inputs[3] // { // @18FA stack[-1] // @18FA stack[-5] // @18FB stack[-4] // } 18F9 5B JUMPDEST 18FA 93 SWAP4 18FB 92 SWAP3 18FC 50 POP 18FD 50 POP 18FE 50 POP 18FF 56 *JUMP // Stack delta = -4 // Outputs[1] { @18FA stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1900: // Incoming call from 0x0325, returns to 0x0326 // Inputs[2] // { // @1906 stack[-1] // @1907 stack[-2] // } 1900 5B JUMPDEST 1901 60 PUSH1 0x00 1903 80 DUP1 1904 60 PUSH1 0x40 1906 83 DUP4 1907 85 DUP6 1908 03 SUB 1909 12 SLT 190A 15 ISZERO 190B 61 PUSH2 0x1913 190E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1901 stack[0] = 0x00 // @1903 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1913, if !(stack[-2] - stack[-1] i< 0x40) label_190F: // Incoming jump from 0x190E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1912 memory[0x00:0x00] } 190F 60 PUSH1 0x00 1911 80 DUP1 1912 FD *REVERT // Stack delta = +0 // Outputs[1] { @1912 revert(memory[0x00:0x00]); } // Block terminates label_1913: // Incoming jump from 0x190E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1917 stack[-3] } 1913 5B JUMPDEST 1914 61 PUSH2 0x191c 1917 83 DUP4 1918 61 PUSH2 0x18b2 191B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1914 stack[0] = 0x191c // @1917 stack[1] = stack[-3] // } // Block ends with call to 0x18b2, returns to 0x191C label_191C: // Incoming return from call to 0x18B2 at 0x191B // Inputs[3] // { // @191D stack[-3] // @191D stack[-1] // @1924 stack[-4] // } 191C 5B JUMPDEST 191D 91 SWAP2 191E 50 POP 191F 61 PUSH2 0x192a 1922 60 PUSH1 0x20 1924 84 DUP5 1925 01 ADD 1926 61 PUSH2 0x18b2 1929 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @191D stack[-3] = stack[-1] // @191F stack[-1] = 0x192a // @1925 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x18b2, returns to 0x192A label_192A: // Incoming return from call to 0x18CE at 0x1A14 // Incoming return from call to 0x18B2 at 0x1929 // Inputs[6] // { // @192B stack[-1] // @192B stack[-2] // @192D stack[-5] // @192F stack[-3] // @192F stack[-6] // @1930 stack[-4] // } 192A 5B JUMPDEST 192B 90 SWAP1 192C 50 POP 192D 92 SWAP3 192E 50 POP 192F 92 SWAP3 1930 90 SWAP1 1931 50 POP 1932 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @192D stack[-5] = stack[-1] // @192F stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1933: // Incoming call from 0x0236, returns to 0x0237 // Incoming call from 0x025C, returns to 0x025D // Inputs[2] // { // @193B stack[-1] // @193C stack[-2] // } 1933 5B JUMPDEST 1934 60 PUSH1 0x00 1936 80 DUP1 1937 60 PUSH1 0x00 1939 60 PUSH1 0x60 193B 84 DUP5 193C 86 DUP7 193D 03 SUB 193E 12 SLT 193F 15 ISZERO 1940 61 PUSH2 0x1948 1943 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1934 stack[0] = 0x00 // @1936 stack[1] = 0x00 // @1937 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1948, if !(stack[-2] - stack[-1] i< 0x60) label_1944: // Incoming jump from 0x1943, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1947 memory[0x00:0x00] } 1944 60 PUSH1 0x00 1946 80 DUP1 1947 FD *REVERT // Stack delta = +0 // Outputs[1] { @1947 revert(memory[0x00:0x00]); } // Block terminates label_1948: // Incoming jump from 0x1943, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @194C stack[-4] } 1948 5B JUMPDEST 1949 61 PUSH2 0x1951 194C 84 DUP5 194D 61 PUSH2 0x18b2 1950 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1949 stack[0] = 0x1951 // @194C stack[1] = stack[-4] // } // Block ends with call to 0x18b2, returns to 0x1951 label_1951: // Incoming return from call to 0x18B2 at 0x1950 // Inputs[3] // { // @1952 stack[-1] // @1952 stack[-4] // @1959 stack[-5] // } 1951 5B JUMPDEST 1952 92 SWAP3 1953 50 POP 1954 61 PUSH2 0x195f 1957 60 PUSH1 0x20 1959 85 DUP6 195A 01 ADD 195B 61 PUSH2 0x18b2 195E 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1952 stack[-4] = stack[-1] // @1954 stack[-1] = 0x195f // @195A stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x18b2, returns to 0x195F label_195F: // Incoming return from call to 0x18B2 at 0x195E // Inputs[8] // { // @1960 stack[-1] // @1960 stack[-3] // @1964 stack[-5] // @1966 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1967 stack[-2] // @196B stack[-6] // @196D stack[-4] // @196D stack[-7] // } 195F 5B JUMPDEST 1960 91 SWAP2 1961 50 POP 1962 60 PUSH1 0x40 1964 84 DUP5 1965 01 ADD 1966 35 CALLDATALOAD 1967 90 SWAP1 1968 50 POP 1969 92 SWAP3 196A 50 POP 196B 92 SWAP3 196C 50 POP 196D 92 SWAP3 196E 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1969 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @196B stack[-6] = stack[-1] // @196D stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_196F: // Incoming call from 0x02F7, returns to 0x02F8 // Inputs[2] // { // @1978 stack[-1] // @1979 stack[-2] // } 196F 5B JUMPDEST 1970 60 PUSH1 0x00 1972 80 DUP1 1973 60 PUSH1 0x00 1975 80 DUP1 1976 60 PUSH1 0x80 1978 85 DUP6 1979 87 DUP8 197A 03 SUB 197B 12 SLT 197C 15 ISZERO 197D 61 PUSH2 0x1985 1980 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1970 stack[0] = 0x00 // @1972 stack[1] = 0x00 // @1973 stack[2] = 0x00 // @1975 stack[3] = 0x00 // } // Block ends with conditional jump to 0x1985, if !(stack[-2] - stack[-1] i< 0x80) label_1981: // Incoming jump from 0x1980, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1984 memory[0x00:0x00] } 1981 60 PUSH1 0x00 1983 80 DUP1 1984 FD *REVERT // Stack delta = +0 // Outputs[1] { @1984 revert(memory[0x00:0x00]); } // Block terminates label_1985: // Incoming jump from 0x1980, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @1989 stack[-5] } 1985 5B JUMPDEST 1986 61 PUSH2 0x198e 1989 85 DUP6 198A 61 PUSH2 0x18b2 198D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1986 stack[0] = 0x198e // @1989 stack[1] = stack[-5] // } // Block ends with call to 0x18b2, returns to 0x198E label_198E: // Incoming return from call to 0x18B2 at 0x198D // Inputs[3] // { // @198F stack[-5] // @198F stack[-1] // @1996 stack[-6] // } 198E 5B JUMPDEST 198F 93 SWAP4 1990 50 POP 1991 61 PUSH2 0x199c 1994 60 PUSH1 0x20 1996 86 DUP7 1997 01 ADD 1998 61 PUSH2 0x18b2 199B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @198F stack[-5] = stack[-1] // @1991 stack[-1] = 0x199c // @1997 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x18b2, returns to 0x199C label_199C: // Incoming return from call to 0x18B2 at 0x199B // Inputs[6] // { // @199D stack[-1] // @199D stack[-4] // @19A1 stack[-6] // @19A3 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @19A4 stack[-3] // @19AA msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 199C 5B JUMPDEST 199D 92 SWAP3 199E 50 POP 199F 60 PUSH1 0x40 19A1 85 DUP6 19A2 01 ADD 19A3 35 CALLDATALOAD 19A4 91 SWAP2 19A5 50 POP 19A6 60 PUSH1 0x60 19A8 85 DUP6 19A9 01 ADD 19AA 35 CALLDATALOAD 19AB 67 PUSH8 0xffffffffffffffff 19B4 81 DUP2 19B5 11 GT 19B6 15 ISZERO 19B7 61 PUSH2 0x19bf 19BA 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @199D stack[-4] = stack[-1] // @19A4 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @19AA stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x19bf, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_19BB: // Incoming jump from 0x19BA, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @19BE memory[0x00:0x00] } 19BB 60 PUSH1 0x00 19BD 80 DUP1 19BE FD *REVERT // Stack delta = +0 // Outputs[1] { @19BE revert(memory[0x00:0x00]); } // Block terminates label_19BF: // Incoming jump from 0x19BA, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @19C0 stack[-6] // @19C1 stack[-1] // @19C6 stack[-7] // } 19BF 5B JUMPDEST 19C0 85 DUP6 19C1 01 ADD 19C2 60 PUSH1 0x1f 19C4 81 DUP2 19C5 01 ADD 19C6 87 DUP8 19C7 13 SGT 19C8 61 PUSH2 0x19d0 19CB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @19C1 stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x19d0, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_19CC: // Incoming jump from 0x19CB, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @19CF memory[0x00:0x00] } 19CC 60 PUSH1 0x00 19CE 80 DUP1 19CF FD *REVERT // Stack delta = +0 // Outputs[1] { @19CF revert(memory[0x00:0x00]); } // Block terminates label_19D0: // Incoming jump from 0x19CB, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @19D4 stack[-7] // @19D5 stack[-1] // @19D6 msg.data[stack[-1]:stack[-1] + 0x20] // } 19D0 5B JUMPDEST 19D1 61 PUSH2 0x19df 19D4 87 DUP8 19D5 82 DUP3 19D6 35 CALLDATALOAD 19D7 60 PUSH1 0x20 19D9 84 DUP5 19DA 01 ADD 19DB 61 PUSH2 0x183c 19DE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19D1 stack[0] = 0x19df // @19D4 stack[1] = stack[-7] // @19D6 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @19DA stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x183c, returns to 0x19DF label_19DF: // Incoming return from call to 0x183C at 0x19DE // Inputs[8] // { // @19E0 stack[-1] // @19E0 stack[-3] // @19E3 stack[-6] // @19E4 stack[-9] // @19E5 stack[-5] // @19E6 stack[-8] // @19E8 stack[-4] // @19E8 stack[-7] // } 19DF 5B JUMPDEST 19E0 91 SWAP2 19E1 50 POP 19E2 50 POP 19E3 92 SWAP3 19E4 95 SWAP6 19E5 91 SWAP2 19E6 94 SWAP5 19E7 50 POP 19E8 92 SWAP3 19E9 50 POP 19EA 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @19E3 stack[-6] = stack[-1] // @19E4 stack[-9] = stack[-6] // @19E6 stack[-8] = stack[-5] // @19E8 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_19EB: // Incoming call from 0x02E4, returns to 0x02E5 // Inputs[2] // { // @19F1 stack[-1] // @19F2 stack[-2] // } 19EB 5B JUMPDEST 19EC 60 PUSH1 0x00 19EE 80 DUP1 19EF 60 PUSH1 0x40 19F1 83 DUP4 19F2 85 DUP6 19F3 03 SUB 19F4 12 SLT 19F5 15 ISZERO 19F6 61 PUSH2 0x19fe 19F9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @19EC stack[0] = 0x00 // @19EE stack[1] = 0x00 // } // Block ends with conditional jump to 0x19fe, if !(stack[-2] - stack[-1] i< 0x40) label_19FA: // Incoming jump from 0x19F9, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @19FD memory[0x00:0x00] } 19FA 60 PUSH1 0x00 19FC 80 DUP1 19FD FD *REVERT // Stack delta = +0 // Outputs[1] { @19FD revert(memory[0x00:0x00]); } // Block terminates label_19FE: // Incoming jump from 0x19F9, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1A02 stack[-3] } 19FE 5B JUMPDEST 19FF 61 PUSH2 0x1a07 1A02 83 DUP4 1A03 61 PUSH2 0x18b2 1A06 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @19FF stack[0] = 0x1a07 // @1A02 stack[1] = stack[-3] // } // Block ends with call to 0x18b2, returns to 0x1A07 label_1A07: // Incoming return from call to 0x18B2 at 0x1A06 // Inputs[3] // { // @1A08 stack[-3] // @1A08 stack[-1] // @1A0F stack[-4] // } 1A07 5B JUMPDEST 1A08 91 SWAP2 1A09 50 POP 1A0A 61 PUSH2 0x192a 1A0D 60 PUSH1 0x20 1A0F 84 DUP5 1A10 01 ADD 1A11 61 PUSH2 0x18ce 1A14 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1A08 stack[-3] = stack[-1] // @1A0A stack[-1] = 0x192a // @1A10 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x18ce, returns to 0x192A label_1A15: // Incoming call from 0x0207, returns to 0x0208 // Inputs[2] // { // @1A1B stack[-1] // @1A1C stack[-2] // } 1A15 5B JUMPDEST 1A16 60 PUSH1 0x00 1A18 80 DUP1 1A19 60 PUSH1 0x40 1A1B 83 DUP4 1A1C 85 DUP6 1A1D 03 SUB 1A1E 12 SLT 1A1F 15 ISZERO 1A20 61 PUSH2 0x1a28 1A23 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A16 stack[0] = 0x00 // @1A18 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a28, if !(stack[-2] - stack[-1] i< 0x40) label_1A24: // Incoming jump from 0x1A23, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1A27 memory[0x00:0x00] } 1A24 60 PUSH1 0x00 1A26 80 DUP1 1A27 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A27 revert(memory[0x00:0x00]); } // Block terminates label_1A28: // Incoming jump from 0x1A23, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1A2C stack[-3] } 1A28 5B JUMPDEST 1A29 61 PUSH2 0x1a31 1A2C 83 DUP4 1A2D 61 PUSH2 0x18b2 1A30 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A29 stack[0] = 0x1a31 // @1A2C stack[1] = stack[-3] // } // Block ends with call to 0x18b2, returns to 0x1A31 label_1A31: // Incoming return from call to 0x18B2 at 0x1A30 // Inputs[5] // { // @1A32 stack[-6] // @1A32 stack[-1] // @1A35 stack[-4] // @1A39 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1A3A stack[-5] // } 1A31 5B JUMPDEST 1A32 94 SWAP5 1A33 60 PUSH1 0x20 1A35 93 SWAP4 1A36 90 SWAP1 1A37 93 SWAP4 1A38 01 ADD 1A39 35 CALLDATALOAD 1A3A 93 SWAP4 1A3B 50 POP 1A3C 50 POP 1A3D 50 POP 1A3E 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1A32 stack[-6] = stack[-1] // @1A3A stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1A3F: // Incoming call from 0x02B8, returns to 0x02B9 // Inputs[2] // { // @1A44 stack[-1] // @1A45 stack[-2] // } 1A3F 5B JUMPDEST 1A40 60 PUSH1 0x00 1A42 60 PUSH1 0x20 1A44 82 DUP3 1A45 84 DUP5 1A46 03 SUB 1A47 12 SLT 1A48 15 ISZERO 1A49 61 PUSH2 0x1a51 1A4C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A40 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a51, if !(stack[-2] - stack[-1] i< 0x20) label_1A4D: // Incoming jump from 0x1A4C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1A50 memory[0x00:0x00] } 1A4D 60 PUSH1 0x00 1A4F 80 DUP1 1A50 FD *REVERT // Stack delta = +0 // Outputs[1] { @1A50 revert(memory[0x00:0x00]); } // Block terminates label_1A51: // Incoming jump from 0x1A4C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1A55 stack[-2] } 1A51 5B JUMPDEST 1A52 61 PUSH2 0x18f9 1A55 82 DUP3 1A56 61 PUSH2 0x18ce 1A59 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1A52 stack[0] = 0x18f9 // @1A55 stack[1] = stack[-2] // } // Block ends with call to 0x18ce, returns to 0x18F9 label_1A5A: // Incoming call from 0x019F, returns to 0x01A0 // Inputs[2] // { // @1A5F stack[-1] // @1A60 stack[-2] // } 1A5A 5B JUMPDEST 1A5B 60 PUSH1 0x00 1A5D 60 PUSH1 0x20 1A5F 82 DUP3 1A60 84 DUP5 1A61 03 SUB 1A62 12 SLT 1A63 15 ISZERO 1A64 61 PUSH2 0x1a6c 1A67 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A5B stack[0] = 0x00 } // Block ends with conditional jump to 0x1a6c, if !(stack[-2] - stack[-1] i< 0x20) label_1A68: // Incoming jump from 0x1A67, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1A6B memory[0x00:0x00] } 1A68 60 PUSH1 0x00 1A6A 80 DUP1 1A6B FD *REVERT // Stack delta = +0 // Outputs[1] { @1A6B revert(memory[0x00:0x00]); } // Block terminates label_1A6C: // Incoming jump from 0x1A67, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1A6D stack[-2] // @1A6E msg.data[stack[-2]:stack[-2] + 0x20] // } 1A6C 5B JUMPDEST 1A6D 81 DUP2 1A6E 35 CALLDATALOAD 1A6F 61 PUSH2 0x18f9 1A72 81 DUP2 1A73 61 PUSH2 0x1c61 1A76 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A6E stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1A6F stack[1] = 0x18f9 // @1A72 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1c61, returns to 0x18F9 1A77 5B JUMPDEST 1A78 60 PUSH1 0x00 1A7A 60 PUSH1 0x20 1A7C 82 DUP3 1A7D 84 DUP5 1A7E 03 SUB 1A7F 12 SLT 1A80 15 ISZERO 1A81 61 PUSH2 0x1a89 1A84 57 *JUMPI 1A85 60 PUSH1 0x00 1A87 80 DUP1 1A88 FD *REVERT 1A89 5B JUMPDEST 1A8A 81 DUP2 1A8B 51 MLOAD 1A8C 61 PUSH2 0x18f9 1A8F 81 DUP2 1A90 61 PUSH2 0x1c61 1A93 56 *JUMP label_1A94: // Incoming call from 0x0249, returns to 0x024A // Inputs[2] // { // @1A99 stack[-1] // @1A9A stack[-2] // } 1A94 5B JUMPDEST 1A95 60 PUSH1 0x00 1A97 60 PUSH1 0x20 1A99 82 DUP3 1A9A 84 DUP5 1A9B 03 SUB 1A9C 12 SLT 1A9D 15 ISZERO 1A9E 61 PUSH2 0x1aa6 1AA1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A95 stack[0] = 0x00 } // Block ends with conditional jump to 0x1aa6, if !(stack[-2] - stack[-1] i< 0x20) label_1AA2: // Incoming jump from 0x1AA1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1AA5 memory[0x00:0x00] } 1AA2 60 PUSH1 0x00 1AA4 80 DUP1 1AA5 FD *REVERT // Stack delta = +0 // Outputs[1] { @1AA5 revert(memory[0x00:0x00]); } // Block terminates label_1AA6: // Incoming jump from 0x1AA1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1AA7 stack[-2] // @1AA8 msg.data[stack[-2]:stack[-2] + 0x20] // } 1AA6 5B JUMPDEST 1AA7 81 DUP2 1AA8 35 CALLDATALOAD 1AA9 67 PUSH8 0xffffffffffffffff 1AB2 81 DUP2 1AB3 11 GT 1AB4 15 ISZERO 1AB5 61 PUSH2 0x1abd 1AB8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AA8 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1abd, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1AB9: // Incoming jump from 0x1AB8, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @1ABC memory[0x00:0x00] } 1AB9 60 PUSH1 0x00 1ABB 80 DUP1 1ABC FD *REVERT // Stack delta = +0 // Outputs[1] { @1ABC revert(memory[0x00:0x00]); } // Block terminates label_1ABD: // Incoming jump from 0x1AB8, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1ABE stack[-3] // @1ABF stack[-1] // @1AC4 stack[-4] // } 1ABD 5B JUMPDEST 1ABE 82 DUP3 1ABF 01 ADD 1AC0 60 PUSH1 0x1f 1AC2 81 DUP2 1AC3 01 ADD 1AC4 84 DUP5 1AC5 13 SGT 1AC6 61 PUSH2 0x1ace 1AC9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1ABF stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x1ace, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_1ACA: // Incoming jump from 0x1AC9, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @1ACD memory[0x00:0x00] } 1ACA 60 PUSH1 0x00 1ACC 80 DUP1 1ACD FD *REVERT // Stack delta = +0 // Outputs[1] { @1ACD revert(memory[0x00:0x00]); } // Block terminates label_1ACE: // Incoming jump from 0x1AC9, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @1AD2 stack[-4] // @1AD3 stack[-1] // @1AD4 msg.data[stack[-1]:stack[-1] + 0x20] // } 1ACE 5B JUMPDEST 1ACF 61 PUSH2 0x1323 1AD2 84 DUP5 1AD3 82 DUP3 1AD4 35 CALLDATALOAD 1AD5 60 PUSH1 0x20 1AD7 84 DUP5 1AD8 01 ADD 1AD9 61 PUSH2 0x183c 1ADC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1ACF stack[0] = 0x1323 // @1AD2 stack[1] = stack[-4] // @1AD4 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @1AD8 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x183c, returns to 0x1323 label_1ADD: // Incoming call from 0x030A, returns to 0x030B // Incoming call from 0x02A5, returns to 0x02A6 // Incoming call from 0x01DC, returns to 0x01DD // Incoming call from 0x026F, returns to 0x0270 // Inputs[2] // { // @1AE2 stack[-1] // @1AE3 stack[-2] // } 1ADD 5B JUMPDEST 1ADE 60 PUSH1 0x00 1AE0 60 PUSH1 0x20 1AE2 82 DUP3 1AE3 84 DUP5 1AE4 03 SUB 1AE5 12 SLT 1AE6 15 ISZERO 1AE7 61 PUSH2 0x1aef 1AEA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1ADE stack[0] = 0x00 } // Block ends with conditional jump to 0x1aef, if !(stack[-2] - stack[-1] i< 0x20) label_1AEB: // Incoming jump from 0x1AEA, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1AEE memory[0x00:0x00] } 1AEB 60 PUSH1 0x00 1AED 80 DUP1 1AEE FD *REVERT // Stack delta = +0 // Outputs[1] { @1AEE revert(memory[0x00:0x00]); } // Block terminates label_1AEF: // Incoming jump from 0x1AEA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1AF1 msg.data[stack[-2]:stack[-2] + 0x20] // @1AF1 stack[-2] // @1AF2 stack[-4] // @1AF3 stack[-3] // } 1AEF 5B JUMPDEST 1AF0 50 POP 1AF1 35 CALLDATALOAD 1AF2 91 SWAP2 1AF3 90 SWAP1 1AF4 50 POP 1AF5 56 *JUMP // Stack delta = -3 // Outputs[1] { @1AF2 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1AF6: // Incoming call from 0x1B91, returns to 0x18F9 // Inputs[3] // { // @1AF9 stack[-1] // @1AFA memory[stack[-1]:stack[-1] + 0x20] // @1AFC stack[-2] // } 1AF6 5B JUMPDEST 1AF7 60 PUSH1 0x00 1AF9 81 DUP2 1AFA 51 MLOAD 1AFB 80 DUP1 1AFC 84 DUP5 1AFD 52 MSTORE 1AFE 60 PUSH1 0x00 1B00 5B JUMPDEST 1B01 81 DUP2 1B02 81 DUP2 1B03 10 LT 1B04 15 ISZERO 1B05 61 PUSH2 0x1b1c 1B08 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @1AF7 stack[0] = 0x00 // @1AFA stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1AFD memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1AFE stack[2] = 0x00 // } // Block ends with conditional jump to 0x1b1c, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_1B09: // Incoming jump from 0x1B08, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1B08, if not !(stack[-1] < stack[-2]) // Inputs[4] // { // @1B0B stack[-1] // @1B0C stack[-4] // @1B10 memory[0x20 + stack[-4] + stack[-1]:0x20 + stack[-4] + stack[-1] + 0x20] // @1B11 stack[-5] // } 1B09 60 PUSH1 0x20 1B0B 81 DUP2 1B0C 85 DUP6 1B0D 01 ADD 1B0E 81 DUP2 1B0F 01 ADD 1B10 51 MLOAD 1B11 86 DUP7 1B12 83 DUP4 1B13 01 ADD 1B14 82 DUP3 1B15 01 ADD 1B16 52 MSTORE 1B17 01 ADD 1B18 61 PUSH2 0x1b00 1B1B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1B16 memory[0x20 + stack[-1] + stack[-5]:0x20 + stack[-1] + stack[-5] + 0x20] = memory[0x20 + stack[-4] + stack[-1]:0x20 + stack[-4] + stack[-1] + 0x20] // @1B17 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1b00 label_1B1C: // Incoming jump from 0x1B08, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x1B08, if !(stack[-1] < stack[-2]) // Inputs[2] // { // @1B1D stack[-2] // @1B1E stack[-1] // } 1B1C 5B JUMPDEST 1B1D 81 DUP2 1B1E 81 DUP2 1B1F 11 GT 1B20 15 ISZERO 1B21 61 PUSH2 0x1b2e 1B24 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b2e, if !(stack[-1] > stack[-2]) label_1B25: // Incoming jump from 0x1B24, if not !(stack[-1] > stack[-2]) // Inputs[4] // { // @1B29 stack[-2] // @1B2A stack[-5] // @1B38 stack[-3] // @1B3E stack[-6] // } 1B25 60 PUSH1 0x00 1B27 60 PUSH1 0x20 1B29 83 DUP4 1B2A 87 DUP8 1B2B 01 ADD 1B2C 01 ADD 1B2D 52 MSTORE 1B2E 5B JUMPDEST 1B2F 50 POP 1B30 60 PUSH1 0x1f 1B32 01 ADD 1B33 60 PUSH1 0x1f 1B35 19 NOT 1B36 16 AND 1B37 92 SWAP3 1B38 90 SWAP1 1B39 92 SWAP3 1B3A 01 ADD 1B3B 60 PUSH1 0x20 1B3D 01 ADD 1B3E 92 SWAP3 1B3F 91 SWAP2 1B40 50 POP 1B41 50 POP 1B42 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1B2D memory[stack[-5] + stack[-2] + 0x20:stack[-5] + stack[-2] + 0x20 + 0x20] = 0x00 // @1B3E stack[-6] = 0x20 + (~0x1f & 0x1f + stack[-2]) + stack[-5] // } // Block ends with unconditional jump to stack[-6] 1B43 5B JUMPDEST 1B44 60 PUSH1 0x00 1B46 60 PUSH1 0x01 1B48 60 PUSH1 0x01 1B4A 60 PUSH1 0xa0 1B4C 1B SHL 1B4D 03 SUB 1B4E 80 DUP1 1B4F 87 DUP8 1B50 16 AND 1B51 83 DUP4 1B52 52 MSTORE 1B53 80 DUP1 1B54 86 DUP7 1B55 16 AND 1B56 60 PUSH1 0x20 1B58 84 DUP5 1B59 01 ADD 1B5A 52 MSTORE 1B5B 50 POP 1B5C 83 DUP4 1B5D 60 PUSH1 0x40 1B5F 83 DUP4 1B60 01 ADD 1B61 52 MSTORE 1B62 60 PUSH1 0x80 1B64 60 PUSH1 0x60 1B66 83 DUP4 1B67 01 ADD 1B68 52 MSTORE 1B69 61 PUSH2 0x1b75 1B6C 60 PUSH1 0x80 1B6E 83 DUP4 1B6F 01 ADD 1B70 84 DUP5 1B71 61 PUSH2 0x1af6 1B74 56 *JUMP 1B75 5B JUMPDEST 1B76 96 SWAP7 1B77 95 SWAP6 1B78 50 POP 1B79 50 POP 1B7A 50 POP 1B7B 50 POP 1B7C 50 POP 1B7D 50 POP 1B7E 56 *JUMP label_1B7F: // Incoming jump from 0x01CE // Inputs[2] // { // @1B82 stack[-1] // @1B8D stack[-2] // } 1B7F 5B JUMPDEST 1B80 60 PUSH1 0x20 1B82 81 DUP2 1B83 52 MSTORE 1B84 60 PUSH1 0x00 1B86 61 PUSH2 0x18f9 1B89 60 PUSH1 0x20 1B8B 83 DUP4 1B8C 01 ADD 1B8D 84 DUP5 1B8E 61 PUSH2 0x1af6 1B91 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1B83 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1B84 stack[0] = 0x00 // @1B86 stack[1] = 0x18f9 // @1B8C stack[2] = stack[-1] + 0x20 // @1B8D stack[3] = stack[-2] // } // Block ends with call to 0x1af6, returns to 0x18F9 label_1B92: // Incoming call from 0x11B7, returns to 0x11B8 // Incoming call from 0x1587, returns to 0x1588 // Inputs[2] // { // @1B95 stack[-2] // @1B97 stack[-1] // } 1B92 5B JUMPDEST 1B93 60 PUSH1 0x00 1B95 82 DUP3 1B96 19 NOT 1B97 82 DUP3 1B98 11 GT 1B99 15 ISZERO 1B9A 61 PUSH2 0x1ba5 1B9D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1B93 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ba5, if !(stack[-1] > ~stack[-2]) label_1B9E: // Incoming jump from 0x1B9D, if not !(stack[-1] > ~stack[-2]) 1B9E 61 PUSH2 0x1ba5 1BA1 61 PUSH2 0x1c35 1BA4 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B9E stack[0] = 0x1ba5 } // Block ends with unconditional jump to 0x1c35 label_1BA5: // Incoming jump from 0x1B9D, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @1BA7 stack[-3] // @1BA7 stack[-2] // @1BA8 stack[-4] // } 1BA5 5B JUMPDEST 1BA6 50 POP 1BA7 01 ADD 1BA8 90 SWAP1 1BA9 56 *JUMP // Stack delta = -3 // Outputs[1] { @1BA8 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_1BAA: // Incoming call from 0x1559, returns to 0x155A // Inputs[2] // { // @1BAD stack[-2] // @1BAE stack[-1] // } 1BAA 5B JUMPDEST 1BAB 60 PUSH1 0x00 1BAD 82 DUP3 1BAE 82 DUP3 1BAF 10 LT 1BB0 15 ISZERO 1BB1 61 PUSH2 0x1bbc 1BB4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BAB stack[0] = 0x00 } // Block ends with conditional jump to 0x1bbc, if !(stack[-1] < stack[-2]) label_1BB5: // Incoming jump from 0x1BB4, if not !(stack[-1] < stack[-2]) 1BB5 61 PUSH2 0x1bbc 1BB8 61 PUSH2 0x1c35 1BBB 56 *JUMP // Stack delta = +1 // Outputs[1] { @1BB5 stack[0] = 0x1bbc } // Block ends with unconditional jump to 0x1c35 label_1BBC: // Incoming jump from 0x1BB4, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @1BBE stack[-2] // @1BBE stack[-3] // @1BBF stack[-4] // } 1BBC 5B JUMPDEST 1BBD 50 POP 1BBE 03 SUB 1BBF 90 SWAP1 1BC0 56 *JUMP // Stack delta = -3 // Outputs[1] { @1BBF stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_1BC1: // Incoming call from 0x0E85, returns to 0x0E86 // Incoming call from 0x0486, returns to 0x0487 // Incoming call from 0x0EB1, returns to 0x0EB2 // Incoming call from 0x17AE, returns to 0x17AF // Incoming call from 0x045A, returns to 0x045B // Incoming call from 0x0F19, returns to 0x045B // Incoming call from 0x0C98, returns to 0x045B // Inputs[1] { @1BC4 stack[-1] } 1BC1 5B JUMPDEST 1BC2 60 PUSH1 0x01 1BC4 81 DUP2 1BC5 81 DUP2 1BC6 1C SHR 1BC7 90 SWAP1 1BC8 82 DUP3 1BC9 16 AND 1BCA 80 DUP1 1BCB 61 PUSH2 0x1bd5 1BCE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1BC7 stack[0] = stack[-1] >> 0x01 // @1BC9 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1bd5, if stack[-1] & 0x01 label_1BCF: // Incoming jump from 0x1BCE, if not stack[-1] & 0x01 // Inputs[2] // { // @1BD1 stack[-2] // @1BDA stack[-1] // } 1BCF 60 PUSH1 0x7f 1BD1 82 DUP3 1BD2 16 AND 1BD3 91 SWAP2 1BD4 50 POP 1BD5 5B JUMPDEST 1BD6 60 PUSH1 0x20 1BD8 82 DUP3 1BD9 10 LT 1BDA 81 DUP2 1BDB 14 EQ 1BDC 15 ISZERO 1BDD 61 PUSH2 0x1bf6 1BE0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1BD3 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1bf6, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1BE1: // Incoming jump from 0x1BE0, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x1BE0, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @1BF5 memory[0x00:0x24] } 1BE1 63 PUSH4 0x4e487b71 1BE6 60 PUSH1 0xe0 1BE8 1B SHL 1BE9 60 PUSH1 0x00 1BEB 52 MSTORE 1BEC 60 PUSH1 0x22 1BEE 60 PUSH1 0x04 1BF0 52 MSTORE 1BF1 60 PUSH1 0x24 1BF3 60 PUSH1 0x00 1BF5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1BEB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1BF0 memory[0x04:0x24] = 0x22 // @1BF5 revert(memory[0x00:0x24]); // } // Block terminates label_1BF6: // Incoming jump from 0x1BE0, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x1BE0, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @1BF8 stack[-4] // @1BF8 stack[-2] // @1BF9 stack[-3] // } 1BF6 5B JUMPDEST 1BF7 50 POP 1BF8 91 SWAP2 1BF9 90 SWAP1 1BFA 50 POP 1BFB 56 *JUMP // Stack delta = -3 // Outputs[1] { @1BF8 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1BFC: // Incoming call from 0x0840, returns to 0x0841 // Inputs[1] { @1C20 stack[-1] } 1BFC 5B JUMPDEST 1BFD 60 PUSH1 0x00 1BFF 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1C20 82 DUP3 1C21 14 EQ 1C22 15 ISZERO 1C23 61 PUSH2 0x1c2e 1C26 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BFD stack[0] = 0x00 } // Block ends with conditional jump to 0x1c2e, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) label_1C27: // Incoming jump from 0x1C26, if not !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) 1C27 61 PUSH2 0x1c2e 1C2A 61 PUSH2 0x1c35 1C2D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C27 stack[0] = 0x1c2e } // Block ends with unconditional jump to 0x1c35 label_1C2E: // Incoming jump from 0x1C26, if !(stack[-1] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // Inputs[2] // { // @1C32 stack[-2] // @1C33 stack[-3] // } 1C2E 5B JUMPDEST 1C2F 50 POP 1C30 60 PUSH1 0x01 1C32 01 ADD 1C33 90 SWAP1 1C34 56 *JUMP // Stack delta = -2 // Outputs[1] { @1C33 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_1C35: // Incoming jump from 0x1C2D // Incoming jump from 0x1BBB // Incoming jump from 0x1BA4 // Inputs[1] { @1C4A memory[0x00:0x24] } 1C35 5B JUMPDEST 1C36 63 PUSH4 0x4e487b71 1C3B 60 PUSH1 0xe0 1C3D 1B SHL 1C3E 60 PUSH1 0x00 1C40 52 MSTORE 1C41 60 PUSH1 0x11 1C43 60 PUSH1 0x04 1C45 52 MSTORE 1C46 60 PUSH1 0x24 1C48 60 PUSH1 0x00 1C4A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C40 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1C45 memory[0x04:0x24] = 0x11 // @1C4A revert(memory[0x00:0x24]); // } // Block terminates label_1C4B: // Incoming jump from 0x1856 // Incoming jump from 0x187E // Inputs[1] { @1C60 memory[0x00:0x24] } 1C4B 5B JUMPDEST 1C4C 63 PUSH4 0x4e487b71 1C51 60 PUSH1 0xe0 1C53 1B SHL 1C54 60 PUSH1 0x00 1C56 52 MSTORE 1C57 60 PUSH1 0x41 1C59 60 PUSH1 0x04 1C5B 52 MSTORE 1C5C 60 PUSH1 0x24 1C5E 60 PUSH1 0x00 1C60 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C56 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1C5B memory[0x04:0x24] = 0x41 // @1C60 revert(memory[0x00:0x24]); // } // Block terminates label_1C61: // Incoming call from 0x1A76, returns to 0x18F9 // Inputs[1] { @1C83 stack[-1] } 1C61 5B JUMPDEST 1C62 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1C83 81 DUP2 1C84 16 AND 1C85 81 DUP2 1C86 14 EQ 1C87 61 PUSH2 0x1c8f 1C8A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c8f, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_1C8B: // Incoming jump from 0x1C8A, if not stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1C8E memory[0x00:0x00] } 1C8B 60 PUSH1 0x00 1C8D 80 DUP1 1C8E FD *REVERT // Stack delta = +0 // Outputs[1] { @1C8E revert(memory[0x00:0x00]); } // Block terminates label_1C8F: // Incoming jump from 0x1C8A, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1C91 stack[-2] } 1C8F 5B JUMPDEST 1C90 50 POP 1C91 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 1C92 FE *ASSERT 1C93 A2 LOG2 1C94 64 PUSH5 0x6970667358 1C9A 22 22 1C9B 12 SLT 1C9C 20 SHA3 1C9D BD BD 1C9E 1D SAR 1C9F 30 ADDRESS 1CA0 D9 D9 1CA1 05 SDIV 1CA2 B4 B4 1CA3 D9 D9 1CA4 0F 0F 1CA5 65 PUSH6 0x6064af988dbc 1CAC 87 DUP8 1CAD F8 F8 1CAE 41 COINBASE 1CAF A5 A5 1CB0 EA EA 1CB1 C4 C4 1CB2 07 SMOD 1CB3 D7 D7 1CB4 D8 D8 1CB5 2E 2E 1CB6 E8 E8 1CB7 41 COINBASE 1CB8 87 DUP8 1CB9 40 BLOCKHASH 1CBA 3D RETURNDATASIZE 1CBB 68 PUSH9 0x8564736f6c63430008 1CC5 06 MOD 1CC6 00 *STOP 1CC7 33 CALLER