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 0x01b9 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x01b9, 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 0x6352211e 0026 11 GT 0027 61 PUSH2 0x00f9 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00f9, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0x95d89b41 0031 11 GT 0032 61 PUSH2 0x0097 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0097, if 0x95d89b41 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0x95d89b41 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xb88d4fde 003C 11 GT 003D 61 PUSH2 0x0071 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xb88d4fde > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xb88d4fde > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xb88d4fde 0047 14 EQ 0048 61 PUSH2 0x0373 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0373, if 0xb88d4fde == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xb88d4fde == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xc87b56dd 0052 14 EQ 0053 61 PUSH2 0x0386 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0386, if 0xc87b56dd == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xe985e9c5 005D 14 EQ 005E 61 PUSH2 0x0399 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0399, if 0xe985e9c5 == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf2fde38b 0068 14 EQ 0069 61 PUSH2 0x03d5 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d5, if 0xf2fde38b == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x0040, if 0xb88d4fde > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0x95d89b41 0078 14 EQ 0079 61 PUSH2 0x0350 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0350, if 0x95d89b41 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x95d89b41 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xa22cb465 0083 14 EQ 0084 61 PUSH2 0x0358 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0358, if 0xa22cb465 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xa475b5dd 008E 14 EQ 008F 61 PUSH2 0x036b 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036b, if 0xa475b5dd == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xa475b5dd == stack[-1] // Inputs[1] { @0096 memory[0x00:0x00] } 0093 60 PUSH1 0x00 0095 80 DUP1 0096 FD *REVERT // Stack delta = +0 // Outputs[1] { @0096 revert(memory[0x00:0x00]); } // Block terminates label_0097: // Incoming jump from 0x0035, if 0x95d89b41 > stack[-1] // Inputs[1] { @0098 stack[-1] } 0097 5B JUMPDEST 0098 80 DUP1 0099 63 PUSH4 0x715018a6 009E 11 GT 009F 61 PUSH2 0x00d3 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d3, if 0x715018a6 > stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0x715018a6 > stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0x715018a6 00A9 14 EQ 00AA 61 PUSH2 0x0311 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0311, if 0x715018a6 == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x715018a6 == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x7dac7fd4 00B4 14 EQ 00B5 61 PUSH2 0x0319 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0319, if 0x7dac7fd4 == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x7dac7fd4 == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x8ba4cc3c 00BF 14 EQ 00C0 61 PUSH2 0x032c 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032c, if 0x8ba4cc3c == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x8ba4cc3c == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x8da5cb5b 00CA 14 EQ 00CB 61 PUSH2 0x033f 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x033f, if 0x8da5cb5b == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00D2 memory[0x00:0x00] } 00CF 60 PUSH1 0x00 00D1 80 DUP1 00D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D2 revert(memory[0x00:0x00]); } // Block terminates label_00D3: // Incoming jump from 0x00A2, if 0x715018a6 > stack[-1] // Inputs[1] { @00D4 stack[-1] } 00D3 5B JUMPDEST 00D4 80 DUP1 00D5 63 PUSH4 0x6352211e 00DA 14 EQ 00DB 61 PUSH2 0x02e0 00DE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e0, if 0x6352211e == stack[-1] label_00DF: // Incoming jump from 0x00DE, if not 0x6352211e == stack[-1] // Inputs[1] { @00DF stack[-1] } 00DF 80 DUP1 00E0 63 PUSH4 0x69d30a49 00E5 14 EQ 00E6 61 PUSH2 0x02f3 00E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f3, if 0x69d30a49 == stack[-1] label_00EA: // Incoming jump from 0x00E9, if not 0x69d30a49 == stack[-1] // Inputs[1] { @00EA stack[-1] } 00EA 80 DUP1 00EB 63 PUSH4 0x70a08231 00F0 14 EQ 00F1 61 PUSH2 0x02fe 00F4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fe, if 0x70a08231 == stack[-1] label_00F5: // Incoming jump from 0x00F4, if not 0x70a08231 == stack[-1] // Inputs[1] { @00F8 memory[0x00:0x00] } 00F5 60 PUSH1 0x00 00F7 80 DUP1 00F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F8 revert(memory[0x00:0x00]); } // Block terminates label_00F9: // Incoming jump from 0x002A, if 0x6352211e > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00FA stack[-1] } 00F9 5B JUMPDEST 00FA 80 DUP1 00FB 63 PUSH4 0x23b872dd 0100 11 GT 0101 61 PUSH2 0x0166 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0166, if 0x23b872dd > stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x23b872dd > stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x42842e0e 010B 11 GT 010C 61 PUSH2 0x0140 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0140, if 0x42842e0e > stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x42842e0e > stack[-1] // Inputs[1] { @0110 stack[-1] } 0110 80 DUP1 0111 63 PUSH4 0x42842e0e 0116 14 EQ 0117 61 PUSH2 0x029f 011A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x029f, if 0x42842e0e == stack[-1] label_011B: // Incoming jump from 0x011A, if not 0x42842e0e == stack[-1] // Inputs[1] { @011B stack[-1] } 011B 80 DUP1 011C 63 PUSH4 0x42966c68 0121 14 EQ 0122 61 PUSH2 0x02b2 0125 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b2, if 0x42966c68 == stack[-1] label_0126: // Incoming jump from 0x0125, if not 0x42966c68 == stack[-1] // Inputs[1] { @0126 stack[-1] } 0126 80 DUP1 0127 63 PUSH4 0x47ce07cc 012C 14 EQ 012D 61 PUSH2 0x02c5 0130 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c5, if 0x47ce07cc == stack[-1] label_0131: // Incoming jump from 0x0130, if not 0x47ce07cc == stack[-1] // Inputs[1] { @0131 stack[-1] } 0131 80 DUP1 0132 63 PUSH4 0x4f6ccce7 0137 14 EQ 0138 61 PUSH2 0x02cd 013B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02cd, if 0x4f6ccce7 == stack[-1] label_013C: // Incoming jump from 0x013B, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @013F memory[0x00:0x00] } 013C 60 PUSH1 0x00 013E 80 DUP1 013F FD *REVERT // Stack delta = +0 // Outputs[1] { @013F revert(memory[0x00:0x00]); } // Block terminates label_0140: // Incoming jump from 0x010F, if 0x42842e0e > stack[-1] // Inputs[1] { @0141 stack[-1] } 0140 5B JUMPDEST 0141 80 DUP1 0142 63 PUSH4 0x23b872dd 0147 14 EQ 0148 61 PUSH2 0x0264 014B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0264, if 0x23b872dd == stack[-1] label_014C: // Incoming jump from 0x014B, if not 0x23b872dd == stack[-1] // Inputs[1] { @014C stack[-1] } 014C 80 DUP1 014D 63 PUSH4 0x2f745c59 0152 14 EQ 0153 61 PUSH2 0x0277 0156 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0277, if 0x2f745c59 == stack[-1] label_0157: // Incoming jump from 0x0156, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0157 stack[-1] } 0157 80 DUP1 0158 63 PUSH4 0x41f43434 015D 14 EQ 015E 61 PUSH2 0x028a 0161 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028a, if 0x41f43434 == stack[-1] label_0162: // Incoming jump from 0x0161, if not 0x41f43434 == stack[-1] // Inputs[1] { @0165 memory[0x00:0x00] } 0162 60 PUSH1 0x00 0164 80 DUP1 0165 FD *REVERT // Stack delta = +0 // Outputs[1] { @0165 revert(memory[0x00:0x00]); } // Block terminates label_0166: // Incoming jump from 0x0104, if 0x23b872dd > stack[-1] // Inputs[1] { @0167 stack[-1] } 0166 5B JUMPDEST 0167 80 DUP1 0168 63 PUSH4 0x095ea7b3 016D 11 GT 016E 61 PUSH2 0x0197 0171 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0197, if 0x095ea7b3 > stack[-1] label_0172: // Incoming jump from 0x0171, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @0172 stack[-1] } 0172 80 DUP1 0173 63 PUSH4 0x095ea7b3 0178 14 EQ 0179 61 PUSH2 0x0226 017C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0226, if 0x095ea7b3 == stack[-1] label_017D: // Incoming jump from 0x017C, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @017D stack[-1] } 017D 80 DUP1 017E 63 PUSH4 0x18160ddd 0183 14 EQ 0184 61 PUSH2 0x023b 0187 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023b, if 0x18160ddd == stack[-1] label_0188: // Incoming jump from 0x0187, if not 0x18160ddd == stack[-1] // Inputs[1] { @0188 stack[-1] } 0188 80 DUP1 0189 63 PUSH4 0x1fe543e3 018E 14 EQ 018F 61 PUSH2 0x0251 0192 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0251, if 0x1fe543e3 == stack[-1] label_0193: // Incoming jump from 0x0192, if not 0x1fe543e3 == stack[-1] // Inputs[1] { @0196 memory[0x00:0x00] } 0193 60 PUSH1 0x00 0195 80 DUP1 0196 FD *REVERT // Stack delta = +0 // Outputs[1] { @0196 revert(memory[0x00:0x00]); } // Block terminates label_0197: // Incoming jump from 0x0171, if 0x095ea7b3 > stack[-1] // Inputs[1] { @0198 stack[-1] } 0197 5B JUMPDEST 0198 80 DUP1 0199 63 PUSH4 0x01ffc9a7 019E 14 EQ 019F 61 PUSH2 0x01be 01A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01be, if 0x01ffc9a7 == stack[-1] label_01A3: // Incoming jump from 0x01A2, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01A3 stack[-1] } 01A3 80 DUP1 01A4 63 PUSH4 0x06fdde03 01A9 14 EQ 01AA 61 PUSH2 0x01e6 01AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01e6, if 0x06fdde03 == stack[-1] label_01AE: // Incoming jump from 0x01AD, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01AE stack[-1] } 01AE 80 DUP1 01AF 63 PUSH4 0x081812fc 01B4 14 EQ 01B5 61 PUSH2 0x01fb 01B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01fb, if 0x081812fc == stack[-1] label_01B9: // Incoming jump from 0x01B8, if not 0x081812fc == stack[-1] // Incoming jump from 0x0019, if msg.data.length < 0x04 // Inputs[1] { @01BD memory[0x00:0x00] } 01B9 5B JUMPDEST 01BA 60 PUSH1 0x00 01BC 80 DUP1 01BD FD *REVERT // Stack delta = +0 // Outputs[1] { @01BD revert(memory[0x00:0x00]); } // Block terminates label_01BE: // Incoming jump from 0x01A2, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01C5 msg.data.length } 01BE 5B JUMPDEST 01BF 61 PUSH2 0x01d1 01C2 61 PUSH2 0x01cc 01C5 36 CALLDATASIZE 01C6 60 PUSH1 0x04 01C8 61 PUSH2 0x22cf 01CB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01BF stack[0] = 0x01d1 // @01C2 stack[1] = 0x01cc // @01C5 stack[2] = msg.data.length // @01C6 stack[3] = 0x04 // } // Block ends with call to 0x22cf, returns to 0x01CC label_01CC: // Incoming return from call to 0x22CF at 0x01CB 01CC 5B JUMPDEST 01CD 61 PUSH2 0x03e8 01D0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03e8 label_01D1: // Incoming jump from 0x02FD // Incoming return from call to 0x01CC at 0x01CB // Incoming return from call to 0x03A7 at 0x03A6 // Inputs[4] // { // @01D4 memory[0x40:0x60] // @01D5 stack[-1] // @01E0 memory[0x40:0x60] // @01E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 01D1 5B JUMPDEST 01D2 60 PUSH1 0x40 01D4 51 MLOAD 01D5 90 SWAP1 01D6 15 ISZERO 01D7 15 ISZERO 01D8 81 DUP2 01D9 52 MSTORE 01DA 60 PUSH1 0x20 01DC 01 ADD 01DD 5B JUMPDEST 01DE 60 PUSH1 0x40 01E0 51 MLOAD 01E1 80 DUP1 01E2 91 SWAP2 01E3 03 SUB 01E4 90 SWAP1 01E5 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @01D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01E5 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_01E6: // Incoming jump from 0x01AD, if 0x06fdde03 == stack[-1] 01E6 5B JUMPDEST 01E7 61 PUSH2 0x01ee 01EA 61 PUSH2 0x04b9 01ED 56 *JUMP // Stack delta = +1 // Outputs[1] { @01E7 stack[0] = 0x01ee } // Block ends with call to 0x04b9, returns to 0x01EE label_01EE: // Incoming return from call to 0x0B86 at 0x0357 // Incoming return from call to 0x04B9 at 0x01ED // Incoming return from call to 0x0394 at 0x0393 // Incoming return from call to 0x0394 at 0x0393 // Inputs[2] // { // @01F1 memory[0x40:0x60] // @01F5 stack[-1] // } 01EE 5B JUMPDEST 01EF 60 PUSH1 0x40 01F1 51 MLOAD 01F2 61 PUSH2 0x01dd 01F5 91 SWAP2 01F6 90 SWAP1 01F7 61 PUSH2 0x2343 01FA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @01F5 stack[-1] = 0x01dd // @01F6 stack[1] = memory[0x40:0x60] // @01F6 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2343 label_01FB: // Incoming jump from 0x01B8, if 0x081812fc == stack[-1] // Inputs[1] { @0202 msg.data.length } 01FB 5B JUMPDEST 01FC 61 PUSH2 0x020e 01FF 61 PUSH2 0x0209 0202 36 CALLDATASIZE 0203 60 PUSH1 0x04 0205 61 PUSH2 0x2356 0208 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01FC stack[0] = 0x020e // @01FF stack[1] = 0x0209 // @0202 stack[2] = msg.data.length // @0203 stack[3] = 0x04 // } // Block ends with call to 0x2356, returns to 0x0209 label_0209: // Incoming return from call to 0x2356 at 0x0208 0209 5B JUMPDEST 020A 61 PUSH2 0x054b 020D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x054b label_020E: // Incoming jump from 0x034F // Incoming jump from 0x029E // Incoming return from call to 0x0209 at 0x0208 // Inputs[2] // { // @0211 memory[0x40:0x60] // @021B stack[-1] // } 020E 5B JUMPDEST 020F 60 PUSH1 0x40 0211 51 MLOAD 0212 60 PUSH1 0x01 0214 60 PUSH1 0x01 0216 60 PUSH1 0xa0 0218 1B SHL 0219 03 SUB 021A 90 SWAP1 021B 91 SWAP2 021C 16 AND 021D 81 DUP2 021E 52 MSTORE 021F 60 PUSH1 0x20 0221 01 ADD 0222 61 PUSH2 0x01dd 0225 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @021E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0221 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01dd label_0226: // Incoming jump from 0x017C, if 0x095ea7b3 == stack[-1] // Inputs[1] { @022D msg.data.length } 0226 5B JUMPDEST 0227 61 PUSH2 0x0239 022A 61 PUSH2 0x0234 022D 36 CALLDATASIZE 022E 60 PUSH1 0x04 0230 61 PUSH2 0x2386 0233 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0227 stack[0] = 0x0239 // @022A stack[1] = 0x0234 // @022D stack[2] = msg.data.length // @022E stack[3] = 0x04 // } // Block ends with call to 0x2386, returns to 0x0234 label_0234: // Incoming return from call to 0x2386 at 0x0233 0234 5B JUMPDEST 0235 61 PUSH2 0x05e9 0238 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05e9 label_0239: // Incoming return from call to 0x025F at 0x025E // Incoming return from call to 0x0327 at 0x0326 0239 5B JUMPDEST 023A 00 *STOP // Stack delta = +0 // Outputs[1] { @023A stop(); } // Block terminates label_023B: // Incoming jump from 0x0187, if 0x18160ddd == stack[-1] 023B 5B JUMPDEST 023C 61 PUSH2 0x0243 023F 61 PUSH2 0x0602 0242 56 *JUMP // Stack delta = +1 // Outputs[1] { @023C stack[0] = 0x0243 } // Block ends with call to 0x0602, returns to 0x0243 label_0243: // Incoming return from call to 0x0602 at 0x0242 // Incoming return from call to 0x030C at 0x030B // Incoming jump from 0x02CC // Incoming return from call to 0x0285 at 0x0284 // Incoming return from call to 0x02DB at 0x02DA // Incoming return from call to 0x02DB at 0x02DA // Inputs[2] // { // @0246 memory[0x40:0x60] // @0247 stack[-1] // } 0243 5B JUMPDEST 0244 60 PUSH1 0x40 0246 51 MLOAD 0247 90 SWAP1 0248 81 DUP2 0249 52 MSTORE 024A 60 PUSH1 0x20 024C 01 ADD 024D 61 PUSH2 0x01dd 0250 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0249 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @024C stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01dd label_0251: // Incoming jump from 0x0192, if 0x1fe543e3 == stack[-1] // Inputs[1] { @0258 msg.data.length } 0251 5B JUMPDEST 0252 61 PUSH2 0x0239 0255 61 PUSH2 0x025f 0258 36 CALLDATASIZE 0259 60 PUSH1 0x04 025B 61 PUSH2 0x23f7 025E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0252 stack[0] = 0x0239 // @0255 stack[1] = 0x025f // @0258 stack[2] = msg.data.length // @0259 stack[3] = 0x04 // } // Block ends with call to 0x23f7, returns to 0x025F label_025F: // Incoming return from call to 0x23F7 at 0x025E 025F 5B JUMPDEST 0260 61 PUSH2 0x061e 0263 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x061e label_0264: // Incoming jump from 0x014B, if 0x23b872dd == stack[-1] // Inputs[1] { @026B msg.data.length } 0264 5B JUMPDEST 0265 61 PUSH2 0x0239 0268 61 PUSH2 0x0272 026B 36 CALLDATASIZE 026C 60 PUSH1 0x04 026E 61 PUSH2 0x24a9 0271 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0265 stack[0] = 0x0239 // @0268 stack[1] = 0x0272 // @026B stack[2] = msg.data.length // @026C stack[3] = 0x04 // } // Block ends with call to 0x24a9, returns to 0x0272 label_0272: // Incoming return from call to 0x24A9 at 0x0271 0272 5B JUMPDEST 0273 61 PUSH2 0x06bf 0276 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06bf label_0277: // Incoming jump from 0x0156, if 0x2f745c59 == stack[-1] // Inputs[1] { @027E msg.data.length } 0277 5B JUMPDEST 0278 61 PUSH2 0x0243 027B 61 PUSH2 0x0285 027E 36 CALLDATASIZE 027F 60 PUSH1 0x04 0281 61 PUSH2 0x2386 0284 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0278 stack[0] = 0x0243 // @027B stack[1] = 0x0285 // @027E stack[2] = msg.data.length // @027F stack[3] = 0x04 // } // Block ends with call to 0x2386, returns to 0x0285 label_0285: // Incoming return from call to 0x2386 at 0x0284 0285 5B JUMPDEST 0286 61 PUSH2 0x06ea 0289 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06ea label_028A: // Incoming jump from 0x0161, if 0x41f43434 == stack[-1] 028A 5B JUMPDEST 028B 61 PUSH2 0x020e 028E 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 029D 81 DUP2 029E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @028B stack[0] = 0x020e // @028E stack[1] = 0xaaeb6d7670e522a718067333cd4e // } // Block ends with unconditional jump to 0x020e label_029F: // Incoming jump from 0x011A, if 0x42842e0e == stack[-1] // Inputs[1] { @02A6 msg.data.length } 029F 5B JUMPDEST 02A0 61 PUSH2 0x0239 02A3 61 PUSH2 0x02ad 02A6 36 CALLDATASIZE 02A7 60 PUSH1 0x04 02A9 61 PUSH2 0x24a9 02AC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A0 stack[0] = 0x0239 // @02A3 stack[1] = 0x02ad // @02A6 stack[2] = msg.data.length // @02A7 stack[3] = 0x04 // } // Block ends with call to 0x24a9, returns to 0x02AD label_02AD: // Incoming return from call to 0x24A9 at 0x02AC 02AD 5B JUMPDEST 02AE 61 PUSH2 0x07cb 02B1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07cb label_02B2: // Incoming jump from 0x0125, if 0x42966c68 == stack[-1] // Inputs[1] { @02B9 msg.data.length } 02B2 5B JUMPDEST 02B3 61 PUSH2 0x0239 02B6 61 PUSH2 0x02c0 02B9 36 CALLDATASIZE 02BA 60 PUSH1 0x04 02BC 61 PUSH2 0x2356 02BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02B3 stack[0] = 0x0239 // @02B6 stack[1] = 0x02c0 // @02B9 stack[2] = msg.data.length // @02BA stack[3] = 0x04 // } // Block ends with call to 0x2356, returns to 0x02C0 label_02C0: // Incoming return from call to 0x2356 at 0x02BF 02C0 5B JUMPDEST 02C1 61 PUSH2 0x07f0 02C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07f0 label_02C5: // Incoming jump from 0x0130, if 0x47ce07cc == stack[-1] // Inputs[1] { @02C8 storage[0x04] } 02C5 5B JUMPDEST 02C6 60 PUSH1 0x04 02C8 54 SLOAD 02C9 61 PUSH2 0x0243 02CC 56 *JUMP // Stack delta = +1 // Outputs[1] { @02C8 stack[0] = storage[0x04] } // Block ends with unconditional jump to 0x0243 label_02CD: // Incoming jump from 0x013B, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @02D4 msg.data.length } 02CD 5B JUMPDEST 02CE 61 PUSH2 0x0243 02D1 61 PUSH2 0x02db 02D4 36 CALLDATASIZE 02D5 60 PUSH1 0x04 02D7 61 PUSH2 0x2356 02DA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02CE stack[0] = 0x0243 // @02D1 stack[1] = 0x02db // @02D4 stack[2] = msg.data.length // @02D5 stack[3] = 0x04 // } // Block ends with call to 0x2356, returns to 0x02DB label_02DB: // Incoming return from call to 0x2356 at 0x02DA 02DB 5B JUMPDEST 02DC 61 PUSH2 0x08db 02DF 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08db label_02E0: // Incoming jump from 0x00DE, if 0x6352211e == stack[-1] // Inputs[1] { @02E7 msg.data.length } 02E0 5B JUMPDEST 02E1 61 PUSH2 0x020e 02E4 61 PUSH2 0x02ee 02E7 36 CALLDATASIZE 02E8 60 PUSH1 0x04 02EA 61 PUSH2 0x2356 02ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E1 stack[0] = 0x020e // @02E4 stack[1] = 0x02ee // @02E7 stack[2] = msg.data.length // @02E8 stack[3] = 0x04 // } // Block ends with call to 0x2356, returns to 0x02EE label_02EE: // Incoming return from call to 0x2356 at 0x02ED 02EE 5B JUMPDEST 02EF 61 PUSH2 0x09aa 02F2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09aa label_02F3: // Incoming jump from 0x00E9, if 0x69d30a49 == stack[-1] // Inputs[1] { @02F6 storage[0x03] } 02F3 5B JUMPDEST 02F4 60 PUSH1 0x03 02F6 54 SLOAD 02F7 60 PUSH1 0xff 02F9 16 AND 02FA 61 PUSH2 0x01d1 02FD 56 *JUMP // Stack delta = +1 // Outputs[1] { @02F9 stack[0] = 0xff & storage[0x03] } // Block ends with unconditional jump to 0x01d1 label_02FE: // Incoming jump from 0x00F4, if 0x70a08231 == stack[-1] // Inputs[1] { @0305 msg.data.length } 02FE 5B JUMPDEST 02FF 61 PUSH2 0x0243 0302 61 PUSH2 0x030c 0305 36 CALLDATASIZE 0306 60 PUSH1 0x04 0308 61 PUSH2 0x24e5 030B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02FF stack[0] = 0x0243 // @0302 stack[1] = 0x030c // @0305 stack[2] = msg.data.length // @0306 stack[3] = 0x04 // } // Block ends with call to 0x24e5, returns to 0x030C label_030C: // Incoming return from call to 0x24E5 at 0x030B 030C 5B JUMPDEST 030D 61 PUSH2 0x09be 0310 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09be label_0311: // Incoming jump from 0x00AD, if 0x715018a6 == stack[-1] 0311 5B JUMPDEST 0312 61 PUSH2 0x0239 0315 61 PUSH2 0x0a9c 0318 56 *JUMP // Stack delta = +1 // Outputs[1] { @0312 stack[0] = 0x0239 } // Block ends with unconditional jump to 0x0a9c label_0319: // Incoming jump from 0x00B8, if 0x7dac7fd4 == stack[-1] // Inputs[1] { @0320 msg.data.length } 0319 5B JUMPDEST 031A 61 PUSH2 0x0239 031D 61 PUSH2 0x0327 0320 36 CALLDATASIZE 0321 60 PUSH1 0x04 0323 61 PUSH2 0x2500 0326 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @031A stack[0] = 0x0239 // @031D stack[1] = 0x0327 // @0320 stack[2] = msg.data.length // @0321 stack[3] = 0x04 // } // Block ends with call to 0x2500, returns to 0x0327 label_0327: // Incoming return from call to 0x2500 at 0x0326 0327 5B JUMPDEST 0328 61 PUSH2 0x0ab0 032B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ab0 label_032C: // Incoming jump from 0x00C3, if 0x8ba4cc3c == stack[-1] // Inputs[1] { @0333 msg.data.length } 032C 5B JUMPDEST 032D 61 PUSH2 0x0239 0330 61 PUSH2 0x033a 0333 36 CALLDATASIZE 0334 60 PUSH1 0x04 0336 61 PUSH2 0x2386 0339 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @032D stack[0] = 0x0239 // @0330 stack[1] = 0x033a // @0333 stack[2] = msg.data.length // @0334 stack[3] = 0x04 // } // Block ends with call to 0x2386, returns to 0x033A label_033A: // Incoming return from call to 0x2386 at 0x0339 033A 5B JUMPDEST 033B 61 PUSH2 0x0ac5 033E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ac5 label_033F: // Incoming jump from 0x00CE, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0342 storage[0x00] } 033F 5B JUMPDEST 0340 60 PUSH1 0x00 0342 54 SLOAD 0343 60 PUSH1 0x01 0345 60 PUSH1 0x01 0347 60 PUSH1 0xa0 0349 1B SHL 034A 03 SUB 034B 16 AND 034C 61 PUSH2 0x020e 034F 56 *JUMP // Stack delta = +1 // Outputs[1] { @034B stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to 0x020e label_0350: // Incoming jump from 0x007C, if 0x95d89b41 == stack[-1] 0350 5B JUMPDEST 0351 61 PUSH2 0x01ee 0354 61 PUSH2 0x0b86 0357 56 *JUMP // Stack delta = +1 // Outputs[1] { @0351 stack[0] = 0x01ee } // Block ends with call to 0x0b86, returns to 0x01EE label_0358: // Incoming jump from 0x0087, if 0xa22cb465 == stack[-1] // Inputs[1] { @035F msg.data.length } 0358 5B JUMPDEST 0359 61 PUSH2 0x0239 035C 61 PUSH2 0x0366 035F 36 CALLDATASIZE 0360 60 PUSH1 0x04 0362 61 PUSH2 0x2526 0365 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0359 stack[0] = 0x0239 // @035C stack[1] = 0x0366 // @035F stack[2] = msg.data.length // @0360 stack[3] = 0x04 // } // Block ends with call to 0x2526, returns to 0x0366 label_0366: // Incoming return from call to 0x2526 at 0x0365 0366 5B JUMPDEST 0367 61 PUSH2 0x0b95 036A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b95 label_036B: // Incoming jump from 0x0092, if 0xa475b5dd == stack[-1] 036B 5B JUMPDEST 036C 61 PUSH2 0x0239 036F 61 PUSH2 0x0ba9 0372 56 *JUMP // Stack delta = +1 // Outputs[1] { @036C stack[0] = 0x0239 } // Block ends with unconditional jump to 0x0ba9 label_0373: // Incoming jump from 0x004B, if 0xb88d4fde == stack[-1] // Inputs[1] { @037A msg.data.length } 0373 5B JUMPDEST 0374 61 PUSH2 0x0239 0377 61 PUSH2 0x0381 037A 36 CALLDATASIZE 037B 60 PUSH1 0x04 037D 61 PUSH2 0x255d 0380 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0374 stack[0] = 0x0239 // @0377 stack[1] = 0x0381 // @037A stack[2] = msg.data.length // @037B stack[3] = 0x04 // } // Block ends with call to 0x255d, returns to 0x0381 label_0381: // Incoming return from call to 0x255D at 0x0380 0381 5B JUMPDEST 0382 61 PUSH2 0x0c7a 0385 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c7a label_0386: // Incoming jump from 0x0056, if 0xc87b56dd == stack[-1] // Inputs[1] { @038D msg.data.length } 0386 5B JUMPDEST 0387 61 PUSH2 0x01ee 038A 61 PUSH2 0x0394 038D 36 CALLDATASIZE 038E 60 PUSH1 0x04 0390 61 PUSH2 0x2356 0393 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0387 stack[0] = 0x01ee // @038A stack[1] = 0x0394 // @038D stack[2] = msg.data.length // @038E stack[3] = 0x04 // } // Block ends with call to 0x2356, returns to 0x0394 label_0394: // Incoming return from call to 0x2356 at 0x0393 0394 5B JUMPDEST 0395 61 PUSH2 0x0ca7 0398 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ca7 label_0399: // Incoming jump from 0x0061, if 0xe985e9c5 == stack[-1] // Inputs[1] { @03A0 msg.data.length } 0399 5B JUMPDEST 039A 61 PUSH2 0x01d1 039D 61 PUSH2 0x03a7 03A0 36 CALLDATASIZE 03A1 60 PUSH1 0x04 03A3 61 PUSH2 0x261d 03A6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @039A stack[0] = 0x01d1 // @039D stack[1] = 0x03a7 // @03A0 stack[2] = msg.data.length // @03A1 stack[3] = 0x04 // } // Block ends with call to 0x261d, returns to 0x03A7 label_03A7: // Incoming return from call to 0x261D at 0x03A6 // Inputs[6] // { // @03B0 stack[-2] // @03C3 memory[0x00:0x40] // @03C4 stack[-1] // @03CE memory[0x00:0x40] // @03CF storage[keccak256(memory[0x00:0x40])] // @03D3 stack[-3] // } 03A7 5B JUMPDEST 03A8 60 PUSH1 0x01 03AA 60 PUSH1 0x01 03AC 60 PUSH1 0xa0 03AE 1B SHL 03AF 03 SUB 03B0 91 SWAP2 03B1 82 DUP3 03B2 16 AND 03B3 60 PUSH1 0x00 03B5 90 SWAP1 03B6 81 DUP2 03B7 52 MSTORE 03B8 60 PUSH1 0x0b 03BA 60 PUSH1 0x20 03BC 90 SWAP1 03BD 81 DUP2 03BE 52 MSTORE 03BF 60 PUSH1 0x40 03C1 80 DUP1 03C2 83 DUP4 03C3 20 SHA3 03C4 93 SWAP4 03C5 90 SWAP1 03C6 94 SWAP5 03C7 16 AND 03C8 82 DUP3 03C9 52 MSTORE 03CA 91 SWAP2 03CB 90 SWAP1 03CC 91 SWAP2 03CD 52 MSTORE 03CE 20 SHA3 03CF 54 SLOAD 03D0 60 PUSH1 0xff 03D2 16 AND 03D3 90 SWAP1 03D4 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @03B7 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @03BE memory[0x20:0x40] = 0x0b // @03C9 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @03CD memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @03D3 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_03D5: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @03DC msg.data.length } 03D5 5B JUMPDEST 03D6 61 PUSH2 0x0239 03D9 61 PUSH2 0x03e3 03DC 36 CALLDATASIZE 03DD 60 PUSH1 0x04 03DF 61 PUSH2 0x24e5 03E2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03D6 stack[0] = 0x0239 // @03D9 stack[1] = 0x03e3 // @03DC stack[2] = msg.data.length // @03DD stack[3] = 0x04 // } // Block ends with call to 0x24e5, returns to 0x03E3 label_03E3: // Incoming return from call to 0x24E5 at 0x03E2 03E3 5B JUMPDEST 03E4 61 PUSH2 0x0e20 03E7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e20 label_03E8: // Incoming jump from 0x01D0 // Inputs[1] { @03F4 stack[-1] } 03E8 5B JUMPDEST 03E9 60 PUSH1 0x00 03EB 60 PUSH1 0x01 03ED 60 PUSH1 0x01 03EF 60 PUSH1 0xe0 03F1 1B SHL 03F2 03 SUB 03F3 19 NOT 03F4 82 DUP3 03F5 16 AND 03F6 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 0417 14 EQ 0418 80 DUP1 0419 61 PUSH2 0x044b 041C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @03E9 stack[0] = 0x00 // @0417 stack[1] = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x044b, if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_041D: // Incoming jump from 0x041C, if not 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0427 stack[-3] } 041D 50 POP 041E 60 PUSH1 0x01 0420 60 PUSH1 0x01 0422 60 PUSH1 0xe0 0424 1B SHL 0425 03 SUB 0426 19 NOT 0427 82 DUP3 0428 16 AND 0429 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 044A 14 EQ 044B 5B JUMPDEST 044C 80 DUP1 044D 61 PUSH2 0x047f 0450 57 *JUMPI // Stack delta = +0 // Outputs[1] { @044A stack[-1] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x047f, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0451: // Incoming jump from 0x0450, if not stack[-1] // Incoming jump from 0x0450, if not 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @045B stack[-3] } 0451 50 POP 0452 60 PUSH1 0x01 0454 60 PUSH1 0x01 0456 60 PUSH1 0xe0 0458 1B SHL 0459 03 SUB 045A 19 NOT 045B 82 DUP3 045C 16 AND 045D 7F PUSH32 0x780e9d6300000000000000000000000000000000000000000000000000000000 047E 14 EQ 047F 5B JUMPDEST 0480 80 DUP1 0481 61 PUSH2 0x04b3 0484 57 *JUMPI // Stack delta = +0 // Outputs[1] { @047E stack[-1] = 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x04b3, if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0485: // Incoming jump from 0x0484, if not stack[-1] // Incoming jump from 0x0484, if not 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @04B0 stack[-3] } 0485 50 POP 0486 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 04A7 60 PUSH1 0x01 04A9 60 PUSH1 0x01 04AB 60 PUSH1 0xe0 04AD 1B SHL 04AE 03 SUB 04AF 19 NOT 04B0 83 DUP4 04B1 16 AND 04B2 14 EQ // Stack delta = +0 // Outputs[1] { @04B2 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block continues label_04B3: // Incoming return from call to 0x1F88 at 0x1D99 // Incoming jump from 0x277B, if !(stack[-1] > stack[-2] + stack[-1]) // Incoming jump from 0x073C // Incoming jump from 0x04B2 // Incoming jump from 0x0484, if stack[-1] // Incoming jump from 0x26A5, if !(stack[-1] - stack[-2] > stack[-1]) // Incoming jump from 0x0EE3 // Incoming jump from 0x0484, if 0x780e9d6300000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[3] // { // @04B4 stack[-4] // @04B4 stack[-1] // @04B5 stack[-3] // } 04B3 5B JUMPDEST 04B4 92 SWAP3 04B5 91 SWAP2 04B6 50 POP 04B7 50 POP 04B8 56 *JUMP // Stack delta = -3 // Outputs[1] { @04B4 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_04B9: // Incoming call from 0x01ED, returns to 0x01EE // Inputs[1] { @04BF storage[0x06] } 04B9 5B JUMPDEST 04BA 60 PUSH1 0x60 04BC 60 PUSH1 0x06 04BE 80 DUP1 04BF 54 SLOAD 04C0 61 PUSH2 0x04c8 04C3 90 SWAP1 04C4 61 PUSH2 0x2650 04C7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04BA stack[0] = 0x60 // @04BC stack[1] = 0x06 // @04C3 stack[2] = 0x04c8 // @04C3 stack[3] = storage[0x06] // } // Block ends with call to 0x2650, returns to 0x04C8 label_04C8: // Incoming return from call to 0x2650 at 0x0B94 // Incoming return from call to 0x2650 at 0x04C7 // Inputs[4] // { // @04C9 stack[-1] // @04D8 memory[0x40:0x60] // @04E0 stack[-2] // @04EB storage[stack[-2]] // } 04C8 5B JUMPDEST 04C9 80 DUP1 04CA 60 PUSH1 0x1f 04CC 01 ADD 04CD 60 PUSH1 0x20 04CF 80 DUP1 04D0 91 SWAP2 04D1 04 DIV 04D2 02 MUL 04D3 60 PUSH1 0x20 04D5 01 ADD 04D6 60 PUSH1 0x40 04D8 51 MLOAD 04D9 90 SWAP1 04DA 81 DUP2 04DB 01 ADD 04DC 60 PUSH1 0x40 04DE 52 MSTORE 04DF 80 DUP1 04E0 92 SWAP3 04E1 91 SWAP2 04E2 90 SWAP1 04E3 81 DUP2 04E4 81 DUP2 04E5 52 MSTORE 04E6 60 PUSH1 0x20 04E8 01 ADD 04E9 82 DUP3 04EA 80 DUP1 04EB 54 SLOAD 04EC 61 PUSH2 0x04f4 04EF 90 SWAP1 04F0 61 PUSH2 0x2650 04F3 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @04DE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @04E0 stack[-2] = memory[0x40:0x60] // @04E1 stack[-1] = stack[-2] // @04E2 stack[0] = stack[-1] // @04E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @04E8 stack[1] = 0x20 + memory[0x40:0x60] // @04E9 stack[2] = stack[-2] // @04EF stack[4] = storage[stack[-2]] // @04EF stack[3] = 0x04f4 // } // Block ends with call to 0x2650, returns to 0x04F4 label_04F4: // Incoming return from call to 0x2650 at 0x04F3 // Inputs[1] { @04F5 stack[-1] } 04F4 5B JUMPDEST 04F5 80 DUP1 04F6 15 ISZERO 04F7 61 PUSH2 0x0541 04FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0541, if !stack[-1] label_04FB: // Incoming jump from 0x04FA, if not !stack[-1] // Inputs[1] { @04FB stack[-1] } 04FB 80 DUP1 04FC 60 PUSH1 0x1f 04FE 10 LT 04FF 61 PUSH2 0x0516 0502 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0516, if 0x1f < stack[-1] label_0503: // Incoming jump from 0x0502, if not 0x1f < stack[-1] // Inputs[4] // { // @0507 stack[-2] // @0508 storage[stack[-2]] // @050B stack[-3] // @050D stack[-1] // } 0503 61 PUSH2 0x0100 0506 80 DUP1 0507 83 DUP4 0508 54 SLOAD 0509 04 DIV 050A 02 MUL 050B 83 DUP4 050C 52 MSTORE 050D 91 SWAP2 050E 60 PUSH1 0x20 0510 01 ADD 0511 91 SWAP2 0512 61 PUSH2 0x0541 0515 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @050C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0511 stack[-1] = stack[-1] // @0511 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0541 label_0516: // Incoming jump from 0x0502, if 0x1f < stack[-1] // Inputs[5] // { // @0517 stack[-3] // @0518 stack[-1] // @051A stack[-2] // @0522 memory[0x00:0x20] // @0526 storage[keccak256(memory[0x00:0x20])] // } 0516 5B JUMPDEST 0517 82 DUP3 0518 01 ADD 0519 91 SWAP2 051A 90 SWAP1 051B 60 PUSH1 0x00 051D 52 MSTORE 051E 60 PUSH1 0x20 0520 60 PUSH1 0x00 0522 20 SHA3 0523 90 SWAP1 0524 5B JUMPDEST 0525 81 DUP2 0526 54 SLOAD 0527 81 DUP2 0528 52 MSTORE 0529 90 SWAP1 052A 60 PUSH1 0x01 052C 01 ADD 052D 90 SWAP1 052E 60 PUSH1 0x20 0530 01 ADD 0531 80 DUP1 0532 83 DUP4 0533 11 GT 0534 61 PUSH2 0x0524 0537 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0519 stack[-3] = stack[-3] + stack[-1] // @051D memory[0x00:0x20] = stack[-2] // @0528 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @052D stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0530 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0524, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0538: // Incoming jump from 0x0537, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0537, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0538 stack[-3] // @0539 stack[-1] // } 0538 82 DUP3 0539 90 SWAP1 053A 03 SUB 053B 60 PUSH1 0x1f 053D 16 AND 053E 82 DUP3 053F 01 ADD 0540 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0540 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0540 stack[-1] = stack[-3] // } // Block continues label_0541: // Incoming jump from 0x04FA, if !stack[-1] // Incoming jump from 0x0540 // Incoming jump from 0x0515 // Inputs[3] // { // @0547 stack[-6] // @0547 stack[-7] // @0549 stack[-8] // } 0541 5B JUMPDEST 0542 50 POP 0543 50 POP 0544 50 POP 0545 50 POP 0546 50 POP 0547 90 SWAP1 0548 50 POP 0549 90 SWAP1 054A 56 *JUMP // Stack delta = -7 // Outputs[1] { @0549 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_054B: // Incoming jump from 0x020D // Inputs[1] { @0551 stack[-1] } 054B 5B JUMPDEST 054C 60 PUSH1 0x00 054E 61 PUSH2 0x0556 0551 82 DUP3 0552 61 PUSH2 0x0ead 0555 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @054C stack[0] = 0x00 // @054E stack[1] = 0x0556 // @0551 stack[2] = stack[-1] // } // Block ends with call to 0x0ead, returns to 0x0556 label_0556: // Incoming return from call to 0x0EAD at 0x0555 // Inputs[1] { @055A stack[-1] } 0556 5B JUMPDEST 0557 61 PUSH2 0x05cd 055A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x05cd, if stack[-1] label_055B: // Incoming jump from 0x055A, if not stack[-1] // Inputs[1] { @055D memory[0x40:0x60] } 055B 60 PUSH1 0x40 055D 51 MLOAD 055E 62 PUSH3 0x461bcd 0562 60 PUSH1 0xe5 0564 1B SHL 0565 81 DUP2 0566 52 MSTORE 0567 60 PUSH1 0x20 0569 60 PUSH1 0x04 056B 82 DUP3 056C 01 ADD 056D 52 MSTORE 056E 60 PUSH1 0x2f 0570 60 PUSH1 0x24 0572 82 DUP3 0573 01 ADD 0574 52 MSTORE 0575 7F PUSH32 0x4552433732315073693a20617070726f76656420717565727920666f72206e6f 0596 60 PUSH1 0x44 0598 82 DUP3 0599 01 ADD 059A 52 MSTORE 059B 7F PUSH32 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 05BC 60 PUSH1 0x64 05BE 82 DUP3 05BF 01 ADD 05C0 52 MSTORE 05C1 60 PUSH1 0x84 05C3 01 ADD // Stack delta = +1 // Outputs[6] // { // @0566 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @056D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0574 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @059A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a20617070726f76656420717565727920666f72206e6f // @05C0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 // @05C3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_05C4: // Incoming jump from 0x0A3B // Incoming jump from 0x0CFD // Incoming jump from 0x14BD // Incoming jump from 0x203F // Incoming jump from 0x0BF8 // Incoming jump from 0x05C3 // Incoming jump from 0x0B7B // Incoming jump from 0x0C71 // Incoming jump from 0x1AD2 // Incoming jump from 0x0B1C // Incoming jump from 0x15CE // Incoming jump from 0x137B // Incoming jump from 0x06B0 // Incoming jump from 0x0958 // Incoming jump from 0x1441 // Incoming jump from 0x0EA3 // Incoming jump from 0x0844 // Incoming jump from 0x12F7 // Incoming jump from 0x07CA // Inputs[3] // { // @05C7 memory[0x40:0x60] // @05C9 stack[-1] // @05CC memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 05C4 5B JUMPDEST 05C5 60 PUSH1 0x40 05C7 51 MLOAD 05C8 80 DUP1 05C9 91 SWAP2 05CA 03 SUB 05CB 90 SWAP1 05CC FD *REVERT // Stack delta = -1 // Outputs[1] { @05CC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_05CD: // Incoming jump from 0x055A, if stack[-1] // Inputs[4] // { // @05D1 stack[-2] // @05DC memory[0x00:0x40] // @05DD storage[keccak256(memory[0x00:0x40])] // @05E7 stack[-3] // } 05CD 5B JUMPDEST 05CE 50 POP 05CF 60 PUSH1 0x00 05D1 90 SWAP1 05D2 81 DUP2 05D3 52 MSTORE 05D4 60 PUSH1 0x0a 05D6 60 PUSH1 0x20 05D8 52 MSTORE 05D9 60 PUSH1 0x40 05DB 90 SWAP1 05DC 20 SHA3 05DD 54 SLOAD 05DE 60 PUSH1 0x01 05E0 60 PUSH1 0x01 05E2 60 PUSH1 0xa0 05E4 1B SHL 05E5 03 SUB 05E6 16 AND 05E7 90 SWAP1 05E8 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @05D3 memory[0x00:0x20] = stack[-2] // @05D8 memory[0x20:0x40] = 0x0a // @05E7 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_05E9: // Incoming jump from 0x0238 // Inputs[1] { @05EA stack[-2] } 05E9 5B JUMPDEST 05EA 81 DUP2 05EB 61 PUSH2 0x05f3 05EE 81 DUP2 05EF 61 PUSH2 0x0ee4 05F2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05EA stack[0] = stack[-2] // @05EB stack[1] = 0x05f3 // @05EE stack[2] = stack[-2] // } // Block ends with call to 0x0ee4, returns to 0x05F3 label_05F3: // Incoming return from call to 0x0EE4 at 0x05F2 // Inputs[2] // { // @05F7 stack[-3] // @05F8 stack[-2] // } 05F3 5B JUMPDEST 05F4 61 PUSH2 0x05fd 05F7 83 DUP4 05F8 83 DUP4 05F9 61 PUSH2 0x0fcf 05FC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05F4 stack[0] = 0x05fd // @05F7 stack[1] = stack[-3] // @05F8 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x0fcf label_05FD: // Incoming return from call to 0x1577 at 0x0BA8 // Incoming return from call to 0x26C6 at 0x0AC4 // Inputs[1] { @0601 stack[-4] } 05FD 5B JUMPDEST 05FE 50 POP 05FF 50 POP 0600 50 POP 0601 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0602: // Incoming call from 0x0242, returns to 0x0243 // Incoming call from 0x08E4, returns to 0x08E5 0602 5B JUMPDEST 0603 60 PUSH1 0x00 0605 61 PUSH2 0x060c 0608 61 PUSH2 0x10e1 060B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0603 stack[0] = 0x00 // @0605 stack[1] = 0x060c // } // Block ends with call to 0x10e1, returns to 0x060C label_060C: // Incoming return from call to 0x10E1 at 0x060B // Inputs[2] // { // @060F storage[0x09] // @0613 stack[-1] // } 060C 5B JUMPDEST 060D 60 PUSH1 0x09 060F 54 SLOAD 0610 61 PUSH2 0x0619 0613 91 SWAP2 0614 90 SWAP1 0615 61 PUSH2 0x269a 0618 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0613 stack[-1] = 0x0619 // @0614 stack[1] = storage[0x09] // @0614 stack[0] = stack[-1] // } // Block ends with call to 0x269a, returns to 0x0619 label_0619: // Incoming return from call to 0x269A at 0x0618 // Inputs[3] // { // @061A stack[-1] // @061A stack[-2] // @061C stack[-3] // } 0619 5B JUMPDEST 061A 90 SWAP1 061B 50 POP 061C 90 SWAP1 061D 56 *JUMP // Stack delta = -2 // Outputs[1] { @061C stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_061E: // Incoming jump from 0x0263 // Inputs[1] { @061F msg.sender } 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 7F PUSH32 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909 0649 16 AND 064A 14 EQ 064B 61 PUSH2 0x06b1 064E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06b1, if 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909 & (0x01 << 0xa0) - 0x01 == msg.sender label_064F: // Incoming jump from 0x064E, if not 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909 & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @0651 memory[0x40:0x60] // @0675 msg.sender // } 064F 60 PUSH1 0x40 0651 51 MLOAD 0652 7F PUSH32 0x1cf993f400000000000000000000000000000000000000000000000000000000 0673 81 DUP2 0674 52 MSTORE 0675 33 CALLER 0676 60 PUSH1 0x04 0678 82 DUP3 0679 01 ADD 067A 52 MSTORE 067B 60 PUSH1 0x01 067D 60 PUSH1 0x01 067F 60 PUSH1 0xa0 0681 1B SHL 0682 03 SUB 0683 7F PUSH32 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909 06A4 16 AND 06A5 60 PUSH1 0x24 06A7 82 DUP3 06A8 01 ADD 06A9 52 MSTORE 06AA 60 PUSH1 0x44 06AC 01 ADD 06AD 61 PUSH2 0x05c4 06B0 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0674 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1cf993f400000000000000000000000000000000000000000000000000000000 // @067A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @06A9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909 & (0x01 << 0xa0) - 0x01 // @06AC stack[0] = 0x44 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_06B1: // Incoming jump from 0x064E, if 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909 & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @06B5 stack[-2] // @06B6 stack[-1] // } 06B1 5B JUMPDEST 06B2 61 PUSH2 0x06bb 06B5 82 DUP3 06B6 82 DUP3 06B7 61 PUSH2 0x1141 06BA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @06B2 stack[0] = 0x06bb // @06B5 stack[1] = stack[-2] // @06B6 stack[2] = stack[-1] // } // Block ends with call to 0x1141, returns to 0x06BB label_06BB: // Incoming return from call to 0x13CC at 0x0B85 // Incoming return from call to 0x1141 at 0x06BA // Inputs[1] { @06BE stack[-3] } 06BB 5B JUMPDEST 06BC 50 POP 06BD 50 POP 06BE 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_06BF: // Incoming jump from 0x0276 // Inputs[2] // { // @06C0 stack[-3] // @06CB msg.sender // } 06BF 5B JUMPDEST 06C0 82 DUP3 06C1 60 PUSH1 0x01 06C3 60 PUSH1 0x01 06C5 60 PUSH1 0xa0 06C7 1B SHL 06C8 03 SUB 06C9 81 DUP2 06CA 16 AND 06CB 33 CALLER 06CC 14 EQ 06CD 61 PUSH2 0x06d9 06D0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06C0 stack[0] = stack[-3] } // Block ends with conditional jump to 0x06d9, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_06D1: // Incoming jump from 0x06D0, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @06D4 msg.sender } 06D1 61 PUSH2 0x06d9 06D4 33 CALLER 06D5 61 PUSH2 0x0ee4 06D8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06D1 stack[0] = 0x06d9 // @06D4 stack[1] = msg.sender // } // Block ends with call to 0x0ee4, returns to 0x06D9 label_06D9: // Incoming return from call to 0x0EE4 at 0x06D8 // Incoming jump from 0x06D0, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @06DD stack[-4] // @06DE stack[-3] // @06DF stack[-2] // } 06D9 5B JUMPDEST 06DA 61 PUSH2 0x06e4 06DD 84 DUP5 06DE 84 DUP5 06DF 84 DUP5 06E0 61 PUSH2 0x1170 06E3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06DA stack[0] = 0x06e4 // @06DD stack[1] = stack[-4] // @06DE stack[2] = stack[-3] // @06DF stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1170 label_06E4: // Incoming jump from 0x152D, if !(stack[-2] < stack[-1]) // Inputs[1] { @06E9 stack[-5] } 06E4 5B JUMPDEST 06E5 50 POP 06E6 50 POP 06E7 50 POP 06E8 50 POP 06E9 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_06EA: // Incoming jump from 0x0289 // Inputs[1] { @06F3 storage[0x09] } 06EA 5B JUMPDEST 06EB 60 PUSH1 0x00 06ED 80 DUP1 06EE 60 PUSH1 0x00 06F0 5B JUMPDEST 06F1 60 PUSH1 0x09 06F3 54 SLOAD 06F4 81 DUP2 06F5 10 LT 06F6 15 ISZERO 06F7 61 PUSH2 0x075d 06FA 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @06EB stack[0] = 0x00 // @06ED stack[1] = 0x00 // @06EE stack[2] = 0x00 // } // Block ends with conditional jump to 0x075d, if !(0x00 < storage[0x09]) label_06FB: // Incoming jump from 0x06FA, if not !(0x00 < storage[0x09]) // Incoming jump from 0x06FA, if not !(stack[-1] < storage[0x09]) // Inputs[1] { @06FE stack[-1] } 06FB 61 PUSH2 0x0703 06FE 81 DUP2 06FF 61 PUSH2 0x0ead 0702 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @06FB stack[0] = 0x0703 // @06FE stack[1] = stack[-1] // } // Block ends with call to 0x0ead, returns to 0x0703 label_0703: // Incoming return from call to 0x0EAD at 0x0702 // Inputs[1] { @0704 stack[-1] } 0703 5B JUMPDEST 0704 80 DUP1 0705 15 ISZERO 0706 61 PUSH2 0x0728 0709 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0728, if !stack[-1] label_070A: // Incoming jump from 0x0709, if not !stack[-1] // Inputs[1] { @070E stack[-2] } 070A 50 POP 070B 61 PUSH2 0x0713 070E 81 DUP2 070F 61 PUSH2 0x09aa 0712 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @070B stack[-1] = 0x0713 // @070E stack[0] = stack[-2] // } // Block ends with unconditional jump to 0x09aa 0713 5B JUMPDEST 0714 60 PUSH1 0x01 0716 60 PUSH1 0x01 0718 60 PUSH1 0xa0 071A 1B SHL 071B 03 SUB 071C 16 AND 071D 85 DUP6 071E 60 PUSH1 0x01 0720 60 PUSH1 0x01 0722 60 PUSH1 0xa0 0724 1B SHL 0725 03 SUB 0726 16 AND 0727 14 EQ label_0728: // Incoming jump from 0x0709, if !stack[-1] // Inputs[1] { @0729 stack[-1] } 0728 5B JUMPDEST 0729 15 ISZERO 072A 61 PUSH2 0x074b 072D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x074b, if !stack[-1] label_072E: // Incoming jump from 0x072D, if not !stack[-1] // Inputs[2] // { // @072E stack[-4] // @072F stack[-2] // } 072E 83 DUP4 072F 82 DUP3 0730 03 SUB 0731 61 PUSH2 0x073d 0734 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x073d, if stack[-2] - stack[-4] label_0735: // Incoming jump from 0x0734, if not stack[-2] - stack[-4] // Inputs[3] // { // @0735 stack[-3] // @0735 stack[-1] // @073A stack[-2] // } 0735 91 SWAP2 0736 50 POP 0737 61 PUSH2 0x04b3 073A 90 SWAP1 073B 50 POP 073C 56 *JUMP // Stack delta = -2 // Outputs[1] { @0735 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x04b3 label_073D: // Incoming jump from 0x0734, if stack[-2] - stack[-4] // Inputs[1] { @073E stack[-2] } 073D 5B JUMPDEST 073E 81 DUP2 073F 61 PUSH2 0x0747 0742 81 DUP2 0743 61 PUSH2 0x26ad 0746 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @073E stack[0] = stack[-2] // @073F stack[1] = 0x0747 // @0742 stack[2] = stack[-2] // } // Block ends with call to 0x26ad, returns to 0x0747 label_0747: // Incoming return from call to 0x26AD at 0x0746 // Inputs[2] // { // @0748 stack[-1] // @0748 stack[-4] // } 0747 5B JUMPDEST 0748 92 SWAP3 0749 50 POP 074A 50 POP // Stack delta = -2 // Outputs[1] { @0748 stack[-4] = stack[-1] } // Block continues label_074B: // Incoming jump from 0x072D, if !stack[-1] // Incoming jump from 0x074A // Inputs[1] { @074C stack[-1] } 074B 5B JUMPDEST 074C 80 DUP1 074D 61 PUSH2 0x0755 0750 81 DUP2 0751 61 PUSH2 0x26ad 0754 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @074C stack[0] = stack[-1] // @074D stack[1] = 0x0755 // @0750 stack[2] = stack[-1] // } // Block ends with call to 0x26ad, returns to 0x0755 label_0755: // Incoming return from call to 0x26AD at 0x0754 // Inputs[2] // { // @0756 stack[-1] // @0756 stack[-3] // } 0755 5B JUMPDEST 0756 91 SWAP2 0757 50 POP 0758 50 POP 0759 61 PUSH2 0x06f0 075C 56 *JUMP // Stack delta = -2 // Outputs[1] { @0756 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x06f0 label_075D: // Incoming jump from 0x06FA, if !(0x00 < storage[0x09]) // Incoming jump from 0x06FA, if !(stack[-1] < storage[0x09]) // Inputs[1] { @0761 memory[0x40:0x60] } 075D 5B JUMPDEST 075E 50 POP 075F 60 PUSH1 0x40 0761 51 MLOAD 0762 62 PUSH3 0x461bcd 0766 60 PUSH1 0xe5 0768 1B SHL 0769 81 DUP2 076A 52 MSTORE 076B 60 PUSH1 0x20 076D 60 PUSH1 0x04 076F 82 DUP3 0770 01 ADD 0771 52 MSTORE 0772 60 PUSH1 0x24 0774 80 DUP1 0775 82 DUP3 0776 01 ADD 0777 52 MSTORE 0778 7F PUSH32 0x4552433732315073693a206f776e657220696e646578206f7574206f6620626f 0799 60 PUSH1 0x44 079B 82 DUP3 079C 01 ADD 079D 52 MSTORE 079E 7F PUSH32 0x756e647300000000000000000000000000000000000000000000000000000000 07BF 60 PUSH1 0x64 07C1 82 DUP3 07C2 01 ADD 07C3 52 MSTORE 07C4 60 PUSH1 0x84 07C6 01 ADD 07C7 61 PUSH2 0x05c4 07CA 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @076A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0771 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0777 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @079D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a206f776e657220696e646578206f7574206f6620626f // @07C3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x756e647300000000000000000000000000000000000000000000000000000000 // @07C6 stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_07CB: // Incoming jump from 0x02B1 // Inputs[2] // { // @07CC stack[-3] // @07D7 msg.sender // } 07CB 5B JUMPDEST 07CC 82 DUP3 07CD 60 PUSH1 0x01 07CF 60 PUSH1 0x01 07D1 60 PUSH1 0xa0 07D3 1B SHL 07D4 03 SUB 07D5 81 DUP2 07D6 16 AND 07D7 33 CALLER 07D8 14 EQ 07D9 61 PUSH2 0x07e5 07DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07CC stack[0] = stack[-3] } // Block ends with conditional jump to 0x07e5, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_07DD: // Incoming jump from 0x07DC, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @07E0 msg.sender } 07DD 61 PUSH2 0x07e5 07E0 33 CALLER 07E1 61 PUSH2 0x0ee4 07E4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07DD stack[0] = 0x07e5 // @07E0 stack[1] = msg.sender // } // Block ends with call to 0x0ee4, returns to 0x07E5 label_07E5: // Incoming jump from 0x07DC, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x0EE4 at 0x07E4 // Inputs[3] // { // @07E9 stack[-4] // @07EA stack[-3] // @07EB stack[-2] // } 07E5 5B JUMPDEST 07E6 61 PUSH2 0x06e4 07E9 84 DUP5 07EA 84 DUP5 07EB 84 DUP5 07EC 61 PUSH2 0x11f7 07EF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @07E6 stack[0] = 0x06e4 // @07E9 stack[1] = stack[-4] // @07EA stack[2] = stack[-3] // @07EB stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x11f7 label_07F0: // Incoming jump from 0x02C4 // Inputs[1] { @07F4 stack[-1] } 07F0 5B JUMPDEST 07F1 61 PUSH2 0x07f9 07F4 81 DUP2 07F5 61 PUSH2 0x0ead 07F8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07F1 stack[0] = 0x07f9 // @07F4 stack[1] = stack[-1] // } // Block ends with call to 0x0ead, returns to 0x07F9 label_07F9: // Incoming return from call to 0x0EAD at 0x07F8 // Inputs[1] { @07FD stack[-1] } 07F9 5B JUMPDEST 07FA 61 PUSH2 0x0845 07FD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0845, if stack[-1] label_07FE: // Incoming jump from 0x07FD, if not stack[-1] // Inputs[1] { @0800 memory[0x40:0x60] } 07FE 60 PUSH1 0x40 0800 51 MLOAD 0801 62 PUSH3 0x461bcd 0805 60 PUSH1 0xe5 0807 1B SHL 0808 81 DUP2 0809 52 MSTORE 080A 60 PUSH1 0x20 080C 60 PUSH1 0x04 080E 82 DUP3 080F 01 ADD 0810 81 DUP2 0811 90 SWAP1 0812 52 MSTORE 0813 60 PUSH1 0x24 0815 82 DUP3 0816 01 ADD 0817 52 MSTORE 0818 7F PUSH32 0x4d6f6e7576657273655046503a206e6f6e206578697374656e7420746f6b656e 0839 60 PUSH1 0x44 083B 82 DUP3 083C 01 ADD 083D 52 MSTORE 083E 60 PUSH1 0x64 0840 01 ADD 0841 61 PUSH2 0x05c4 0844 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0809 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0812 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0817 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @083D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d6f6e7576657273655046503a206e6f6e206578697374656e7420746f6b656e // @0840 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0845: // Incoming jump from 0x07FD, if stack[-1] // Inputs[1] { @0849 stack[-1] } 0845 5B JUMPDEST 0846 61 PUSH2 0x084e 0849 81 DUP2 084A 61 PUSH2 0x09aa 084D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0846 stack[0] = 0x084e // @0849 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x09aa 084E 5B JUMPDEST 084F 60 PUSH1 0x01 0851 60 PUSH1 0x01 0853 60 PUSH1 0xa0 0855 1B SHL 0856 03 SUB 0857 16 AND 0858 33 CALLER 0859 60 PUSH1 0x01 085B 60 PUSH1 0x01 085D 60 PUSH1 0xa0 085F 1B SHL 0860 03 SUB 0861 16 AND 0862 14 EQ 0863 80 DUP1 0864 61 PUSH2 0x0877 0867 57 *JUMPI 0868 50 POP 0869 60 PUSH1 0x00 086B 54 SLOAD 086C 60 PUSH1 0x01 086E 60 PUSH1 0x01 0870 60 PUSH1 0xa0 0872 1B SHL 0873 03 SUB 0874 16 AND 0875 33 CALLER 0876 14 EQ 0877 5B JUMPDEST 0878 61 PUSH2 0x08cf 087B 57 *JUMPI 087C 60 PUSH1 0x40 087E 51 MLOAD 087F 62 PUSH3 0x461bcd 0883 60 PUSH1 0xe5 0885 1B SHL 0886 81 DUP2 0887 52 MSTORE 0888 60 PUSH1 0x20 088A 60 PUSH1 0x04 088C 82 DUP3 088D 01 ADD 088E 52 MSTORE 088F 60 PUSH1 0x24 0891 80 DUP1 0892 82 DUP3 0893 01 ADD 0894 52 MSTORE 0895 7F PUSH32 0x4d6f6e7576657273655046503a2073656e646572206e6f7420746f6b656e206f 08B6 60 PUSH1 0x44 08B8 82 DUP3 08B9 01 ADD 08BA 52 MSTORE 08BB 63 PUSH4 0x3bb732b9 08C0 60 PUSH1 0xe1 08C2 1B SHL 08C3 60 PUSH1 0x64 08C5 82 DUP3 08C6 01 ADD 08C7 52 MSTORE 08C8 60 PUSH1 0x84 08CA 01 ADD 08CB 61 PUSH2 0x05c4 08CE 56 *JUMP 08CF 5B JUMPDEST 08D0 61 PUSH2 0x08d8 08D3 81 DUP2 08D4 61 PUSH2 0x1212 08D7 56 *JUMP label_08D8: // Incoming jump from 0x22CA, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x137C at 0x0EAC // Incoming jump from 0x2521, if stack[-1] == !!stack[-1] // Incoming jump from 0x0EF9, if !address(0xaaeb6d7670e522a718067333cd4e).code.length // Inputs[1] { @08DA stack[-2] } 08D8 5B JUMPDEST 08D9 50 POP 08DA 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_08DB: // Incoming jump from 0x02DF 08DB 5B JUMPDEST 08DC 60 PUSH1 0x00 08DE 61 PUSH2 0x08e5 08E1 61 PUSH2 0x0602 08E4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @08DC stack[0] = 0x00 // @08DE stack[1] = 0x08e5 // } // Block ends with call to 0x0602, returns to 0x08E5 label_08E5: // Incoming return from call to 0x0602 at 0x08E4 // Inputs[2] // { // @08E6 stack[-3] // @08E7 stack[-1] // } 08E5 5B JUMPDEST 08E6 82 DUP3 08E7 10 LT 08E8 61 PUSH2 0x0959 08EB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0959, if stack[-3] < stack[-1] label_08EC: // Incoming jump from 0x08EB, if not stack[-3] < stack[-1] // Inputs[1] { @08EE memory[0x40:0x60] } 08EC 60 PUSH1 0x40 08EE 51 MLOAD 08EF 62 PUSH3 0x461bcd 08F3 60 PUSH1 0xe5 08F5 1B SHL 08F6 81 DUP2 08F7 52 MSTORE 08F8 60 PUSH1 0x20 08FA 60 PUSH1 0x04 08FC 82 DUP3 08FD 01 ADD 08FE 52 MSTORE 08FF 60 PUSH1 0x25 0901 60 PUSH1 0x24 0903 82 DUP3 0904 01 ADD 0905 52 MSTORE 0906 7F PUSH32 0x4552433732315073693a20676c6f62616c20696e646578206f7574206f662062 0927 60 PUSH1 0x44 0929 82 DUP3 092A 01 ADD 092B 52 MSTORE 092C 7F PUSH32 0x6f756e6473000000000000000000000000000000000000000000000000000000 094D 60 PUSH1 0x64 094F 82 DUP3 0950 01 ADD 0951 52 MSTORE 0952 60 PUSH1 0x84 0954 01 ADD 0955 61 PUSH2 0x05c4 0958 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @08F7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08FE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0905 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @092B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a20676c6f62616c20696e646578206f7574206f662062 // @0951 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6f756e6473000000000000000000000000000000000000000000000000000000 // @0954 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0959: // Incoming jump from 0x08EB, if stack[-3] < stack[-1] // Inputs[1] { @0960 storage[0x09] } 0959 5B JUMPDEST 095A 60 PUSH1 0x00 095C 80 DUP1 095D 5B JUMPDEST 095E 60 PUSH1 0x09 0960 54 SLOAD 0961 81 DUP2 0962 10 LT 0963 15 ISZERO 0964 61 PUSH2 0x09a3 0967 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @095A stack[0] = 0x00 // @095C stack[1] = 0x00 // } // Block ends with conditional jump to 0x09a3, if !(0x00 < storage[0x09]) label_0968: // Incoming jump from 0x0967, if not !(stack[-1] < storage[0x09]) // Incoming jump from 0x0967, if not !(0x00 < storage[0x09]) // Inputs[1] { @096B stack[-1] } 0968 61 PUSH2 0x0970 096B 81 DUP2 096C 61 PUSH2 0x0ead 096F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0968 stack[0] = 0x0970 // @096B stack[1] = stack[-1] // } // Block ends with call to 0x0ead, returns to 0x0970 label_0970: // Incoming return from call to 0x0EAD at 0x096F // Inputs[1] { @0971 stack[-1] } 0970 5B JUMPDEST 0971 15 ISZERO 0972 61 PUSH2 0x0991 0975 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0991, if !stack[-1] label_0976: // Incoming jump from 0x0975, if not !stack[-1] // Inputs[2] // { // @0976 stack[-4] // @0977 stack[-2] // } 0976 83 DUP4 0977 82 DUP3 0978 03 SUB 0979 61 PUSH2 0x0983 097C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0983, if stack[-2] - stack[-4] label_097D: // Incoming jump from 0x097C, if not stack[-2] - stack[-4] // Inputs[3] // { // @097D stack[-5] // @097D stack[-1] // @097E stack[-4] // } 097D 93 SWAP4 097E 92 SWAP3 097F 50 POP 0980 50 POP 0981 50 POP 0982 56 *JUMP // Stack delta = -4 // Outputs[1] { @097D stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_0983: // Incoming jump from 0x097C, if stack[-2] - stack[-4] // Inputs[1] { @0984 stack[-2] } 0983 5B JUMPDEST 0984 81 DUP2 0985 61 PUSH2 0x098d 0988 81 DUP2 0989 61 PUSH2 0x26ad 098C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0984 stack[0] = stack[-2] // @0985 stack[1] = 0x098d // @0988 stack[2] = stack[-2] // } // Block ends with call to 0x26ad, returns to 0x098D label_098D: // Incoming return from call to 0x26AD at 0x098C // Inputs[2] // { // @098E stack[-1] // @098E stack[-4] // } 098D 5B JUMPDEST 098E 92 SWAP3 098F 50 POP 0990 50 POP // Stack delta = -2 // Outputs[1] { @098E stack[-4] = stack[-1] } // Block continues label_0991: // Incoming jump from 0x0990 // Incoming jump from 0x0975, if !stack[-1] // Inputs[1] { @0992 stack[-1] } 0991 5B JUMPDEST 0992 80 DUP1 0993 61 PUSH2 0x099b 0996 81 DUP2 0997 61 PUSH2 0x26ad 099A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0992 stack[0] = stack[-1] // @0993 stack[1] = 0x099b // @0996 stack[2] = stack[-1] // } // Block ends with call to 0x26ad, returns to 0x099B label_099B: // Incoming return from call to 0x26AD at 0x099A // Inputs[2] // { // @099C stack[-1] // @099C stack[-3] // } 099B 5B JUMPDEST 099C 91 SWAP2 099D 50 POP 099E 50 POP 099F 61 PUSH2 0x095d 09A2 56 *JUMP // Stack delta = -2 // Outputs[1] { @099C stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x095d label_09A3: // Incoming jump from 0x0967, if !(stack[-1] < storage[0x09]) // Incoming jump from 0x0967, if !(0x00 < storage[0x09]) // Inputs[3] // { // @09A6 stack[-5] // @09A6 stack[-3] // @09A7 stack[-4] // } 09A3 5B JUMPDEST 09A4 50 POP 09A5 50 POP 09A6 91 SWAP2 09A7 90 SWAP1 09A8 50 POP 09A9 56 *JUMP // Stack delta = -4 // Outputs[1] { @09A6 stack[-5] = stack[-3] } // Block ends with unconditional jump to stack[-5] label_09AA: // Incoming jump from 0x0712 // Incoming jump from 0x1ADD // Incoming jump from 0x02F2 // Incoming jump from 0x0FD9 // Incoming jump from 0x0A60 // Incoming jump from 0x084D // Inputs[1] { @09B1 stack[-1] } 09AA 5B JUMPDEST 09AB 60 PUSH1 0x00 09AD 80 DUP1 09AE 61 PUSH2 0x09b6 09B1 83 DUP4 09B2 61 PUSH2 0x127a 09B5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @09AB stack[0] = 0x00 // @09AD stack[1] = 0x00 // @09AE stack[2] = 0x09b6 // @09B1 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x127a 09B6 5B JUMPDEST 09B7 50 POP 09B8 93 SWAP4 09B9 92 SWAP3 09BA 50 POP 09BB 50 POP 09BC 50 POP 09BD 56 *JUMP label_09BE: // Incoming jump from 0x0310 // Inputs[1] { @09C9 stack[-1] } 09BE 5B JUMPDEST 09BF 60 PUSH1 0x00 09C1 60 PUSH1 0x01 09C3 60 PUSH1 0x01 09C5 60 PUSH1 0xa0 09C7 1B SHL 09C8 03 SUB 09C9 82 DUP3 09CA 16 AND 09CB 61 PUSH2 0x0a3c 09CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09BF stack[0] = 0x00 } // Block ends with conditional jump to 0x0a3c, if stack[-1] & (0x01 << 0xa0) - 0x01 label_09CF: // Incoming jump from 0x09CE, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @09D1 memory[0x40:0x60] } 09CF 60 PUSH1 0x40 09D1 51 MLOAD 09D2 62 PUSH3 0x461bcd 09D6 60 PUSH1 0xe5 09D8 1B SHL 09D9 81 DUP2 09DA 52 MSTORE 09DB 60 PUSH1 0x20 09DD 60 PUSH1 0x04 09DF 82 DUP3 09E0 01 ADD 09E1 52 MSTORE 09E2 60 PUSH1 0x2d 09E4 60 PUSH1 0x24 09E6 82 DUP3 09E7 01 ADD 09E8 52 MSTORE 09E9 7F PUSH32 0x4552433732315073693a2062616c616e636520717565727920666f7220746865 0A0A 60 PUSH1 0x44 0A0C 82 DUP3 0A0D 01 ADD 0A0E 52 MSTORE 0A0F 7F PUSH32 0x207a65726f206164647265737300000000000000000000000000000000000000 0A30 60 PUSH1 0x64 0A32 82 DUP3 0A33 01 ADD 0A34 52 MSTORE 0A35 60 PUSH1 0x84 0A37 01 ADD 0A38 61 PUSH2 0x05c4 0A3B 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @09DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09E1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09E8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2d // @0A0E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a2062616c616e636520717565727920666f7220746865 // @0A34 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x207a65726f206164647265737300000000000000000000000000000000000000 // @0A37 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0A3C: // Incoming jump from 0x09CE, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A43 storage[0x09] } 0A3C 5B JUMPDEST 0A3D 60 PUSH1 0x00 0A3F 80 DUP1 0A40 5B JUMPDEST 0A41 60 PUSH1 0x09 0A43 54 SLOAD 0A44 81 DUP2 0A45 10 LT 0A46 15 ISZERO 0A47 61 PUSH2 0x0a95 0A4A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0A3D stack[0] = 0x00 // @0A3F stack[1] = 0x00 // } // Block ends with conditional jump to 0x0a95, if !(0x00 < storage[0x09]) label_0A4B: // Incoming jump from 0x0A4A, if not !(stack[-1] < storage[0x09]) // Incoming jump from 0x0A4A, if not !(0x00 < storage[0x09]) // Inputs[1] { @0A4E stack[-1] } 0A4B 61 PUSH2 0x0a53 0A4E 81 DUP2 0A4F 61 PUSH2 0x0ead 0A52 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A4B stack[0] = 0x0a53 // @0A4E stack[1] = stack[-1] // } // Block ends with call to 0x0ead, returns to 0x0A53 label_0A53: // Incoming return from call to 0x0EAD at 0x0A52 // Inputs[1] { @0A54 stack[-1] } 0A53 5B JUMPDEST 0A54 15 ISZERO 0A55 61 PUSH2 0x0a85 0A58 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0a85, if !stack[-1] label_0A59: // Incoming jump from 0x0A58, if not !stack[-1] // Inputs[1] { @0A5C stack[-1] } 0A59 61 PUSH2 0x0a61 0A5C 81 DUP2 0A5D 61 PUSH2 0x09aa 0A60 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A59 stack[0] = 0x0a61 // @0A5C stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x09aa 0A61 5B JUMPDEST 0A62 60 PUSH1 0x01 0A64 60 PUSH1 0x01 0A66 60 PUSH1 0xa0 0A68 1B SHL 0A69 03 SUB 0A6A 16 AND 0A6B 84 DUP5 0A6C 60 PUSH1 0x01 0A6E 60 PUSH1 0x01 0A70 60 PUSH1 0xa0 0A72 1B SHL 0A73 03 SUB 0A74 16 AND 0A75 03 SUB 0A76 61 PUSH2 0x0a85 0A79 57 *JUMPI 0A7A 61 PUSH2 0x0a82 0A7D 82 DUP3 0A7E 61 PUSH2 0x26ad 0A81 56 *JUMP 0A82 5B JUMPDEST 0A83 91 SWAP2 0A84 50 POP label_0A85: // Incoming jump from 0x0A58, if !stack[-1] // Inputs[1] { @0A89 stack[-1] } 0A85 5B JUMPDEST 0A86 61 PUSH2 0x0a8e 0A89 81 DUP2 0A8A 61 PUSH2 0x26ad 0A8D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A86 stack[0] = 0x0a8e // @0A89 stack[1] = stack[-1] // } // Block ends with call to 0x26ad, returns to 0x0A8E label_0A8E: // Incoming return from call to 0x26AD at 0x0A8D // Inputs[2] // { // @0A8F stack[-1] // @0A8F stack[-2] // } 0A8E 5B JUMPDEST 0A8F 90 SWAP1 0A90 50 POP 0A91 61 PUSH2 0x0a40 0A94 56 *JUMP // Stack delta = -1 // Outputs[1] { @0A8F stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0a40 label_0A95: // Incoming jump from 0x0A4A, if !(stack[-1] < storage[0x09]) // Incoming jump from 0x0A4A, if !(0x00 < storage[0x09]) // Inputs[3] // { // @0A97 stack[-5] // @0A97 stack[-2] // @0A98 stack[-4] // } 0A95 5B JUMPDEST 0A96 50 POP 0A97 92 SWAP3 0A98 91 SWAP2 0A99 50 POP 0A9A 50 POP 0A9B 56 *JUMP // Stack delta = -4 // Outputs[1] { @0A97 stack[-5] = stack[-2] } // Block ends with unconditional jump to stack[-5] label_0A9C: // Incoming jump from 0x0318 0A9C 5B JUMPDEST 0A9D 61 PUSH2 0x0aa4 0AA0 61 PUSH2 0x1322 0AA3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A9D stack[0] = 0x0aa4 } // Block ends with call to 0x1322, returns to 0x0AA4 label_0AA4: // Incoming return from call to 0x1322 at 0x0AA3 0AA4 5B JUMPDEST 0AA5 61 PUSH2 0x0aae 0AA8 60 PUSH1 0x00 0AAA 61 PUSH2 0x137c 0AAD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AA5 stack[0] = 0x0aae // @0AA8 stack[1] = 0x00 // } // Block ends with call to 0x137c, returns to 0x0AAE label_0AAE: // Incoming return from call to 0x163B at 0x0C79 // Incoming return from call to 0x137C at 0x0AAD // Incoming jump from 0x1334, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0AAF stack[-1] } 0AAE 5B JUMPDEST 0AAF 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0AB0: // Incoming jump from 0x032B 0AB0 5B JUMPDEST 0AB1 61 PUSH2 0x0ab8 0AB4 61 PUSH2 0x1322 0AB7 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AB1 stack[0] = 0x0ab8 } // Block ends with call to 0x1322, returns to 0x0AB8 label_0AB8: // Incoming return from call to 0x1322 at 0x0AB7 // Inputs[1] { @0AB9 stack[-1] } 0AB8 5B JUMPDEST 0AB9 80 DUP1 0ABA 60 PUSH1 0x01 0ABC 61 PUSH2 0x05fd 0ABF 82 DUP3 0AC0 82 DUP3 0AC1 61 PUSH2 0x26c6 0AC4 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0AB9 stack[0] = stack[-1] // @0ABA stack[1] = 0x01 // @0ABC stack[2] = 0x05fd // @0ABF stack[3] = stack[-1] // @0AC0 stack[4] = 0x01 // } // Block ends with call to 0x26c6, returns to 0x05FD label_0AC5: // Incoming jump from 0x033E 0AC5 5B JUMPDEST 0AC6 61 PUSH2 0x0acd 0AC9 61 PUSH2 0x1322 0ACC 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AC6 stack[0] = 0x0acd } // Block ends with call to 0x1322, returns to 0x0ACD label_0ACD: // Incoming return from call to 0x1322 at 0x0ACC // Inputs[1] { @0AD0 storage[0x04] } 0ACD 5B JUMPDEST 0ACE 60 PUSH1 0x04 0AD0 54 SLOAD 0AD1 15 ISZERO 0AD2 61 PUSH2 0x0b1d 0AD5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b1d, if !storage[0x04] label_0AD6: // Incoming jump from 0x0AD5, if not !storage[0x04] // Inputs[1] { @0AD8 memory[0x40:0x60] } 0AD6 60 PUSH1 0x40 0AD8 51 MLOAD 0AD9 62 PUSH3 0x461bcd 0ADD 60 PUSH1 0xe5 0ADF 1B SHL 0AE0 81 DUP2 0AE1 52 MSTORE 0AE2 60 PUSH1 0x20 0AE4 60 PUSH1 0x04 0AE6 82 DUP3 0AE7 01 ADD 0AE8 52 MSTORE 0AE9 60 PUSH1 0x1e 0AEB 60 PUSH1 0x24 0AED 82 DUP3 0AEE 01 ADD 0AEF 52 MSTORE 0AF0 7F PUSH32 0x4d6f6e7576657273655046503a20616c72656164792072657665616c65640000 0B11 60 PUSH1 0x44 0B13 82 DUP3 0B14 01 ADD 0B15 52 MSTORE 0B16 60 PUSH1 0x64 0B18 01 ADD 0B19 61 PUSH2 0x05c4 0B1C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0AE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AE8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AEF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0B15 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d6f6e7576657273655046503a20616c72656164792072657665616c65640000 // @0B18 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0B1D: // Incoming jump from 0x0AD5, if !storage[0x04] // Inputs[3] // { // @0B20 storage[0x0d] // @0B21 stack[-1] // @0B24 storage[0x09] // } 0B1D 5B JUMPDEST 0B1E 60 PUSH1 0x0d 0B20 54 SLOAD 0B21 81 DUP2 0B22 60 PUSH1 0x09 0B24 54 SLOAD 0B25 61 PUSH2 0x0b2e 0B28 91 SWAP2 0B29 90 SWAP1 0B2A 61 PUSH2 0x2770 0B2D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B20 stack[0] = storage[0x0d] // @0B28 stack[1] = 0x0b2e // @0B29 stack[2] = stack[-1] // @0B29 stack[3] = storage[0x09] // } // Block ends with call to 0x2770, returns to 0x0B2E label_0B2E: // Incoming return from call to 0x2770 at 0x0B2D // Inputs[2] // { // @0B2F stack[-2] // @0B2F stack[-1] // } 0B2E 5B JUMPDEST 0B2F 11 GT 0B30 15 ISZERO 0B31 61 PUSH2 0x0b7c 0B34 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0b7c, if !(stack[-1] > stack[-2]) label_0B35: // Incoming jump from 0x0B34, if not !(stack[-1] > stack[-2]) // Inputs[1] { @0B37 memory[0x40:0x60] } 0B35 60 PUSH1 0x40 0B37 51 MLOAD 0B38 62 PUSH3 0x461bcd 0B3C 60 PUSH1 0xe5 0B3E 1B SHL 0B3F 81 DUP2 0B40 52 MSTORE 0B41 60 PUSH1 0x20 0B43 60 PUSH1 0x04 0B45 82 DUP3 0B46 01 ADD 0B47 52 MSTORE 0B48 60 PUSH1 0x1e 0B4A 60 PUSH1 0x24 0B4C 82 DUP3 0B4D 01 ADD 0B4E 52 MSTORE 0B4F 7F PUSH32 0x4d6f6e7576657273655046503a20657863656564696e6720737570706c790000 0B70 60 PUSH1 0x44 0B72 82 DUP3 0B73 01 ADD 0B74 52 MSTORE 0B75 60 PUSH1 0x64 0B77 01 ADD 0B78 61 PUSH2 0x05c4 0B7B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0B40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B47 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B4E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0B74 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d6f6e7576657273655046503a20657863656564696e6720737570706c790000 // @0B77 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0B7C: // Incoming jump from 0x0B34, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @0B80 stack[-2] // @0B81 stack[-1] // } 0B7C 5B JUMPDEST 0B7D 61 PUSH2 0x06bb 0B80 82 DUP3 0B81 82 DUP3 0B82 61 PUSH2 0x13cc 0B85 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B7D stack[0] = 0x06bb // @0B80 stack[1] = stack[-2] // @0B81 stack[2] = stack[-1] // } // Block ends with call to 0x13cc, returns to 0x06BB label_0B86: // Incoming call from 0x0357, returns to 0x01EE // Inputs[1] { @0B8C storage[0x07] } 0B86 5B JUMPDEST 0B87 60 PUSH1 0x60 0B89 60 PUSH1 0x07 0B8B 80 DUP1 0B8C 54 SLOAD 0B8D 61 PUSH2 0x04c8 0B90 90 SWAP1 0B91 61 PUSH2 0x2650 0B94 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B87 stack[0] = 0x60 // @0B89 stack[1] = 0x07 // @0B90 stack[2] = 0x04c8 // @0B90 stack[3] = storage[0x07] // } // Block ends with call to 0x2650, returns to 0x04C8 label_0B95: // Incoming jump from 0x036A // Inputs[1] { @0B96 stack[-2] } 0B95 5B JUMPDEST 0B96 81 DUP2 0B97 61 PUSH2 0x0b9f 0B9A 81 DUP2 0B9B 61 PUSH2 0x0ee4 0B9E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0B96 stack[0] = stack[-2] // @0B97 stack[1] = 0x0b9f // @0B9A stack[2] = stack[-2] // } // Block ends with call to 0x0ee4, returns to 0x0B9F label_0B9F: // Incoming return from call to 0x0EE4 at 0x0B9E // Inputs[2] // { // @0BA3 stack[-3] // @0BA4 stack[-2] // } 0B9F 5B JUMPDEST 0BA0 61 PUSH2 0x05fd 0BA3 83 DUP4 0BA4 83 DUP4 0BA5 61 PUSH2 0x1577 0BA8 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BA0 stack[0] = 0x05fd // @0BA3 stack[1] = stack[-3] // @0BA4 stack[2] = stack[-2] // } // Block ends with call to 0x1577, returns to 0x05FD label_0BA9: // Incoming jump from 0x0372 // Inputs[1] { @0BAC storage[0x04] } 0BA9 5B JUMPDEST 0BAA 60 PUSH1 0x04 0BAC 54 SLOAD 0BAD 15 ISZERO 0BAE 61 PUSH2 0x0bf9 0BB1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bf9, if !storage[0x04] label_0BB2: // Incoming jump from 0x0BB1, if not !storage[0x04] // Inputs[1] { @0BB4 memory[0x40:0x60] } 0BB2 60 PUSH1 0x40 0BB4 51 MLOAD 0BB5 62 PUSH3 0x461bcd 0BB9 60 PUSH1 0xe5 0BBB 1B SHL 0BBC 81 DUP2 0BBD 52 MSTORE 0BBE 60 PUSH1 0x20 0BC0 60 PUSH1 0x04 0BC2 82 DUP3 0BC3 01 ADD 0BC4 52 MSTORE 0BC5 60 PUSH1 0x1e 0BC7 60 PUSH1 0x24 0BC9 82 DUP3 0BCA 01 ADD 0BCB 52 MSTORE 0BCC 7F PUSH32 0x4d6f6e7576657273655046503a20616c72656164792072657665616c65640000 0BED 60 PUSH1 0x44 0BEF 82 DUP3 0BF0 01 ADD 0BF1 52 MSTORE 0BF2 60 PUSH1 0x64 0BF4 01 ADD 0BF5 61 PUSH2 0x05c4 0BF8 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0BBD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BC4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0BCB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0BF1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d6f6e7576657273655046503a20616c72656164792072657665616c65640000 // @0BF4 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0BF9: // Incoming jump from 0x0BB1, if !storage[0x04] // Inputs[1] { @0BFC storage[0x03] } 0BF9 5B JUMPDEST 0BFA 60 PUSH1 0x03 0BFC 54 SLOAD 0BFD 60 PUSH1 0xff 0BFF 16 AND 0C00 15 ISZERO 0C01 61 PUSH2 0x0c72 0C04 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c72, if !(0xff & storage[0x03]) label_0C05: // Incoming jump from 0x0C04, if not !(0xff & storage[0x03]) // Inputs[1] { @0C07 memory[0x40:0x60] } 0C05 60 PUSH1 0x40 0C07 51 MLOAD 0C08 62 PUSH3 0x461bcd 0C0C 60 PUSH1 0xe5 0C0E 1B SHL 0C0F 81 DUP2 0C10 52 MSTORE 0C11 60 PUSH1 0x20 0C13 60 PUSH1 0x04 0C15 82 DUP3 0C16 01 ADD 0C17 52 MSTORE 0C18 60 PUSH1 0x22 0C1A 60 PUSH1 0x24 0C1C 82 DUP3 0C1D 01 ADD 0C1E 52 MSTORE 0C1F 7F PUSH32 0x4d6f6e7576657273655046503a2063757272656e746c792066756c66696c6c69 0C40 60 PUSH1 0x44 0C42 82 DUP3 0C43 01 ADD 0C44 52 MSTORE 0C45 7F PUSH32 0x6e67000000000000000000000000000000000000000000000000000000000000 0C66 60 PUSH1 0x64 0C68 82 DUP3 0C69 01 ADD 0C6A 52 MSTORE 0C6B 60 PUSH1 0x84 0C6D 01 ADD 0C6E 61 PUSH2 0x05c4 0C71 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C10 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C17 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C1E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @0C44 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d6f6e7576657273655046503a2063757272656e746c792066756c66696c6c69 // @0C6A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e67000000000000000000000000000000000000000000000000000000000000 // @0C6D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0C72: // Incoming jump from 0x0C04, if !(0xff & storage[0x03]) 0C72 5B JUMPDEST 0C73 61 PUSH2 0x0aae 0C76 61 PUSH2 0x163b 0C79 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C73 stack[0] = 0x0aae } // Block ends with call to 0x163b, returns to 0x0AAE label_0C7A: // Incoming jump from 0x0385 // Incoming jump from 0x1211 // Inputs[2] // { // @0C7B stack[-4] // @0C86 msg.sender // } 0C7A 5B JUMPDEST 0C7B 83 DUP4 0C7C 60 PUSH1 0x01 0C7E 60 PUSH1 0x01 0C80 60 PUSH1 0xa0 0C82 1B SHL 0C83 03 SUB 0C84 81 DUP2 0C85 16 AND 0C86 33 CALLER 0C87 14 EQ 0C88 61 PUSH2 0x0c94 0C8B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C7B stack[0] = stack[-4] } // Block ends with conditional jump to 0x0c94, if msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 label_0C8C: // Incoming jump from 0x0C8B, if not msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C8F msg.sender } 0C8C 61 PUSH2 0x0c94 0C8F 33 CALLER 0C90 61 PUSH2 0x0ee4 0C93 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C8C stack[0] = 0x0c94 // @0C8F stack[1] = msg.sender // } // Block ends with call to 0x0ee4, returns to 0x0C94 label_0C94: // Incoming jump from 0x0C8B, if msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x0EE4 at 0x0C93 // Inputs[4] // { // @0C98 stack[-5] // @0C99 stack[-4] // @0C9A stack[-3] // @0C9B stack[-2] // } 0C94 5B JUMPDEST 0C95 61 PUSH2 0x0ca0 0C98 85 DUP6 0C99 85 DUP6 0C9A 85 DUP6 0C9B 85 DUP6 0C9C 61 PUSH2 0x177d 0C9F 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0C95 stack[0] = 0x0ca0 // @0C98 stack[1] = stack[-5] // @0C99 stack[2] = stack[-4] // @0C9A stack[3] = stack[-3] // @0C9B stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x177d 0CA0 5B JUMPDEST 0CA1 50 POP 0CA2 50 POP 0CA3 50 POP 0CA4 50 POP 0CA5 50 POP 0CA6 56 *JUMP label_0CA7: // Incoming jump from 0x0398 // Inputs[1] { @0CAD stack[-1] } 0CA7 5B JUMPDEST 0CA8 60 PUSH1 0x60 0CAA 61 PUSH2 0x0cb2 0CAD 82 DUP3 0CAE 61 PUSH2 0x0ead 0CB1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CA8 stack[0] = 0x60 // @0CAA stack[1] = 0x0cb2 // @0CAD stack[2] = stack[-1] // } // Block ends with call to 0x0ead, returns to 0x0CB2 label_0CB2: // Incoming return from call to 0x0EAD at 0x0CB1 // Inputs[1] { @0CB6 stack[-1] } 0CB2 5B JUMPDEST 0CB3 61 PUSH2 0x0cfe 0CB6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0cfe, if stack[-1] label_0CB7: // Incoming jump from 0x0CB6, if not stack[-1] // Inputs[1] { @0CB9 memory[0x40:0x60] } 0CB7 60 PUSH1 0x40 0CB9 51 MLOAD 0CBA 62 PUSH3 0x461bcd 0CBE 60 PUSH1 0xe5 0CC0 1B SHL 0CC1 81 DUP2 0CC2 52 MSTORE 0CC3 60 PUSH1 0x20 0CC5 60 PUSH1 0x04 0CC7 82 DUP3 0CC8 01 ADD 0CC9 81 DUP2 0CCA 90 SWAP1 0CCB 52 MSTORE 0CCC 60 PUSH1 0x24 0CCE 82 DUP3 0CCF 01 ADD 0CD0 52 MSTORE 0CD1 7F PUSH32 0x4d6f6e7576657273655046503a206e6f6e206578697374656e7420746f6b656e 0CF2 60 PUSH1 0x44 0CF4 82 DUP3 0CF5 01 ADD 0CF6 52 MSTORE 0CF7 60 PUSH1 0x64 0CF9 01 ADD 0CFA 61 PUSH2 0x05c4 0CFD 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0CC2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CCB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CD0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0CF6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4d6f6e7576657273655046503a206e6f6e206578697374656e7420746f6b656e // @0CF9 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0CFE: // Incoming jump from 0x0CB6, if stack[-1] // Inputs[1] { @0D01 storage[0x04] } 0CFE 5B JUMPDEST 0CFF 60 PUSH1 0x04 0D01 54 SLOAD 0D02 60 PUSH1 0x00 0D04 03 SUB 0D05 61 PUSH2 0x0d9a 0D08 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d9a, if 0x00 - storage[0x04] label_0D09: // Incoming jump from 0x0D08, if not 0x00 - storage[0x04] // Inputs[1] { @0D0C storage[0x0e] } 0D09 60 PUSH1 0x0e 0D0B 80 DUP1 0D0C 54 SLOAD 0D0D 61 PUSH2 0x0d15 0D10 90 SWAP1 0D11 61 PUSH2 0x2650 0D14 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D09 stack[0] = 0x0e // @0D10 stack[1] = 0x0d15 // @0D10 stack[2] = storage[0x0e] // } // Block ends with call to 0x2650, returns to 0x0D15 label_0D15: // Incoming return from call to 0x2650 at 0x0D14 // Inputs[4] // { // @0D16 stack[-1] // @0D25 memory[0x40:0x60] // @0D2D stack[-2] // @0D38 storage[stack[-2]] // } 0D15 5B JUMPDEST 0D16 80 DUP1 0D17 60 PUSH1 0x1f 0D19 01 ADD 0D1A 60 PUSH1 0x20 0D1C 80 DUP1 0D1D 91 SWAP2 0D1E 04 DIV 0D1F 02 MUL 0D20 60 PUSH1 0x20 0D22 01 ADD 0D23 60 PUSH1 0x40 0D25 51 MLOAD 0D26 90 SWAP1 0D27 81 DUP2 0D28 01 ADD 0D29 60 PUSH1 0x40 0D2B 52 MSTORE 0D2C 80 DUP1 0D2D 92 SWAP3 0D2E 91 SWAP2 0D2F 90 SWAP1 0D30 81 DUP2 0D31 81 DUP2 0D32 52 MSTORE 0D33 60 PUSH1 0x20 0D35 01 ADD 0D36 82 DUP3 0D37 80 DUP1 0D38 54 SLOAD 0D39 61 PUSH2 0x0d41 0D3C 90 SWAP1 0D3D 61 PUSH2 0x2650 0D40 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0D2B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0D2D stack[-2] = memory[0x40:0x60] // @0D2E stack[-1] = stack[-2] // @0D2F stack[0] = stack[-1] // @0D32 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0D35 stack[1] = 0x20 + memory[0x40:0x60] // @0D36 stack[2] = stack[-2] // @0D3C stack[4] = storage[stack[-2]] // @0D3C stack[3] = 0x0d41 // } // Block ends with call to 0x2650, returns to 0x0D41 label_0D41: // Incoming return from call to 0x2650 at 0x0D40 // Inputs[1] { @0D42 stack[-1] } 0D41 5B JUMPDEST 0D42 80 DUP1 0D43 15 ISZERO 0D44 61 PUSH2 0x0d8e 0D47 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d8e, if !stack[-1] label_0D48: // Incoming jump from 0x0D47, if not !stack[-1] // Inputs[1] { @0D48 stack[-1] } 0D48 80 DUP1 0D49 60 PUSH1 0x1f 0D4B 10 LT 0D4C 61 PUSH2 0x0d63 0D4F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d63, if 0x1f < stack[-1] label_0D50: // Incoming jump from 0x0D4F, if not 0x1f < stack[-1] // Inputs[4] // { // @0D54 stack[-2] // @0D55 storage[stack[-2]] // @0D58 stack[-3] // @0D5A stack[-1] // } 0D50 61 PUSH2 0x0100 0D53 80 DUP1 0D54 83 DUP4 0D55 54 SLOAD 0D56 04 DIV 0D57 02 MUL 0D58 83 DUP4 0D59 52 MSTORE 0D5A 91 SWAP2 0D5B 60 PUSH1 0x20 0D5D 01 ADD 0D5E 91 SWAP2 0D5F 61 PUSH2 0x0d8e 0D62 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0D59 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0D5E stack[-1] = stack[-1] // @0D5E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0d8e label_0D63: // Incoming jump from 0x0D4F, if 0x1f < stack[-1] // Inputs[5] // { // @0D64 stack[-3] // @0D65 stack[-1] // @0D67 stack[-2] // @0D6F memory[0x00:0x20] // @0D73 storage[keccak256(memory[0x00:0x20])] // } 0D63 5B JUMPDEST 0D64 82 DUP3 0D65 01 ADD 0D66 91 SWAP2 0D67 90 SWAP1 0D68 60 PUSH1 0x00 0D6A 52 MSTORE 0D6B 60 PUSH1 0x20 0D6D 60 PUSH1 0x00 0D6F 20 SHA3 0D70 90 SWAP1 0D71 5B JUMPDEST 0D72 81 DUP2 0D73 54 SLOAD 0D74 81 DUP2 0D75 52 MSTORE 0D76 90 SWAP1 0D77 60 PUSH1 0x01 0D79 01 ADD 0D7A 90 SWAP1 0D7B 60 PUSH1 0x20 0D7D 01 ADD 0D7E 80 DUP1 0D7F 83 DUP4 0D80 11 GT 0D81 61 PUSH2 0x0d71 0D84 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0D66 stack[-3] = stack[-3] + stack[-1] // @0D6A memory[0x00:0x20] = stack[-2] // @0D75 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0D7A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0D7D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0d71, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0D85: // Incoming jump from 0x0D84, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x0D84, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @0D85 stack[-3] // @0D86 stack[-1] // } 0D85 82 DUP3 0D86 90 SWAP1 0D87 03 SUB 0D88 60 PUSH1 0x1f 0D8A 16 AND 0D8B 82 DUP3 0D8C 01 ADD 0D8D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0D8D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0D8D stack[-1] = stack[-3] // } // Block continues label_0D8E: // Incoming jump from 0x0D47, if !stack[-1] // Incoming jump from 0x0D8D // Incoming jump from 0x0D62 // Inputs[4] // { // @0D94 stack[-7] // @0D94 stack[-6] // @0D96 stack[-9] // @0D97 stack[-8] // } 0D8E 5B JUMPDEST 0D8F 50 POP 0D90 50 POP 0D91 50 POP 0D92 50 POP 0D93 50 POP 0D94 90 SWAP1 0D95 50 POP 0D96 91 SWAP2 0D97 90 SWAP1 0D98 50 POP 0D99 56 *JUMP // Stack delta = -8 // Outputs[1] { @0D96 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_0D9A: // Incoming jump from 0x0D08, if 0x00 - storage[0x04] // Inputs[1] { @0DA1 storage[0x0d] } 0D9A 5B JUMPDEST 0D9B 60 PUSH1 0x01 0D9D 60 PUSH1 0x04 0D9F 60 PUSH1 0x0d 0DA1 54 SLOAD 0DA2 61 PUSH2 0x0dab 0DA5 91 SWAP2 0DA6 90 SWAP1 0DA7 61 PUSH2 0x269a 0DAA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D9B stack[0] = 0x01 // @0DA5 stack[1] = 0x0dab // @0DA6 stack[2] = 0x04 // @0DA6 stack[3] = storage[0x0d] // } // Block ends with call to 0x269a, returns to 0x0DAB label_0DAB: // Incoming return from call to 0x269A at 0x0DAA // Inputs[2] // { // @0DAF stack[-2] // @0DB0 stack[-1] // } 0DAB 5B JUMPDEST 0DAC 61 PUSH2 0x0db5 0DAF 91 SWAP2 0DB0 90 SWAP1 0DB1 61 PUSH2 0x269a 0DB4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0DAF stack[-2] = 0x0db5 // @0DB0 stack[-1] = stack[-2] // @0DB0 stack[0] = stack[-1] // } // Block ends with call to 0x269a, returns to 0x0DB5 label_0DB5: // Incoming return from call to 0x269A at 0x0DB4 // Inputs[2] // { // @0DB6 stack[-3] // @0DB7 stack[-1] // } 0DB5 5B JUMPDEST 0DB6 82 DUP3 0DB7 11 GT 0DB8 15 ISZERO 0DB9 61 PUSH2 0x0dee 0DBC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dee, if !(stack[-3] > stack[-1]) label_0DBD: // Incoming jump from 0x0DBC, if not !(stack[-3] > stack[-1]) // Inputs[1] { @0DC2 stack[-2] } 0DBD 60 PUSH1 0x0f 0DBF 61 PUSH2 0x0dc7 0DC2 83 DUP4 0DC3 61 PUSH2 0x1805 0DC6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DBD stack[0] = 0x0f // @0DBF stack[1] = 0x0dc7 // @0DC2 stack[2] = stack[-2] // } // Block ends with call to 0x1805, returns to 0x0DC7 label_0DC7: // Incoming return from call to 0x1805 at 0x0DC6 // Inputs[3] // { // @0DCA memory[0x40:0x60] // @0DD1 stack[-2] // @0DD2 stack[-1] // } 0DC7 5B JUMPDEST 0DC8 60 PUSH1 0x40 0DCA 51 MLOAD 0DCB 60 PUSH1 0x20 0DCD 01 ADD 0DCE 61 PUSH2 0x0dd8 0DD1 92 SWAP3 0DD2 91 SWAP2 0DD3 90 SWAP1 0DD4 61 PUSH2 0x279f 0DD7 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0DD1 stack[-2] = 0x0dd8 // @0DD2 stack[-1] = stack[-2] // @0DD3 stack[1] = 0x20 + memory[0x40:0x60] // @0DD3 stack[0] = stack[-1] // } // Block ends with call to 0x279f, returns to 0x0DD8 label_0DD8: // Incoming return from call to 0x279F at 0x0DD7 // Inputs[5] // { // @0DDB memory[0x40:0x60] // @0DDF stack[-1] // @0DE8 stack[-2] // @0DEA stack[-4] // @0DEB stack[-3] // } 0DD8 5B JUMPDEST 0DD9 60 PUSH1 0x40 0DDB 51 MLOAD 0DDC 60 PUSH1 0x20 0DDE 81 DUP2 0DDF 83 DUP4 0DE0 03 SUB 0DE1 03 SUB 0DE2 81 DUP2 0DE3 52 MSTORE 0DE4 90 SWAP1 0DE5 60 PUSH1 0x40 0DE7 52 MSTORE 0DE8 90 SWAP1 0DE9 50 POP 0DEA 91 SWAP2 0DEB 90 SWAP1 0DEC 50 POP 0DED 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0DE3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @0DE7 memory[0x40:0x60] = stack[-1] // @0DEA stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_0DEE: // Incoming jump from 0x0DBC, if !(stack[-3] > stack[-1]) // Inputs[1] { @0DFC storage[0x04] } 0DEE 5B JUMPDEST 0DEF 60 PUSH1 0x0f 0DF1 61 PUSH2 0x0dc7 0DF4 61 PUSH2 0x0e16 0DF7 61 PUSH2 0x0dff 0DFA 60 PUSH1 0x04 0DFC 54 SLOAD 0DFD 90 SWAP1 0DFE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DEF stack[0] = 0x0f // @0DF1 stack[1] = 0x0dc7 // @0DF4 stack[2] = 0x0e16 // @0DFD stack[3] = storage[0x04] // } // Block ends with unconditional jump to 0x0dff label_0DFF: // Incoming jump from 0x0DFE // Inputs[1] { @0E04 storage[0x0d] } 0DFF 5B JUMPDEST 0E00 60 PUSH1 0x04 0E02 60 PUSH1 0x0d 0E04 54 SLOAD 0E05 61 PUSH2 0x0e0e 0E08 91 SWAP2 0E09 90 SWAP1 0E0A 61 PUSH2 0x269a 0E0D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E08 stack[0] = 0x0e0e // @0E09 stack[1] = 0x04 // @0E09 stack[2] = storage[0x0d] // } // Block ends with call to 0x269a, returns to 0x0E0E label_0E0E: // Incoming return from call to 0x269A at 0x0E0D // Inputs[3] // { // @0E0F stack[-7] // @0E10 stack[-2] // @0E11 stack[-1] // } 0E0E 5B JUMPDEST 0E0F 86 DUP7 0E10 91 SWAP2 0E11 90 SWAP1 0E12 61 PUSH2 0x1942 0E15 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0E10 stack[-2] = stack[-7] // @0E11 stack[-1] = stack[-2] // @0E11 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1942 0E16 5B JUMPDEST 0E17 61 PUSH2 0x1805 0E1A 56 *JUMP label_0E1B: // Incoming jump from 0x1A45, if !stack[-2] // Incoming jump from 0x1A45, if !stack[-1] // Incoming jump from 0x2381, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0E1C stack[-3] // @0E1C stack[-1] // @0E1D stack[-2] // } 0E1B 5B JUMPDEST 0E1C 91 SWAP2 0E1D 90 SWAP1 0E1E 50 POP 0E1F 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E1C stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0E20: // Incoming jump from 0x03E7 0E20 5B JUMPDEST 0E21 61 PUSH2 0x0e28 0E24 61 PUSH2 0x1322 0E27 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E21 stack[0] = 0x0e28 } // Block ends with call to 0x1322, returns to 0x0E28 label_0E28: // Incoming return from call to 0x1322 at 0x0E27 // Inputs[1] { @0E31 stack[-1] } 0E28 5B JUMPDEST 0E29 60 PUSH1 0x01 0E2B 60 PUSH1 0x01 0E2D 60 PUSH1 0xa0 0E2F 1B SHL 0E30 03 SUB 0E31 81 DUP2 0E32 16 AND 0E33 61 PUSH2 0x0ea4 0E36 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ea4, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0E37: // Incoming jump from 0x0E36, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0E39 memory[0x40:0x60] } 0E37 60 PUSH1 0x40 0E39 51 MLOAD 0E3A 62 PUSH3 0x461bcd 0E3E 60 PUSH1 0xe5 0E40 1B SHL 0E41 81 DUP2 0E42 52 MSTORE 0E43 60 PUSH1 0x20 0E45 60 PUSH1 0x04 0E47 82 DUP3 0E48 01 ADD 0E49 52 MSTORE 0E4A 60 PUSH1 0x26 0E4C 60 PUSH1 0x24 0E4E 82 DUP3 0E4F 01 ADD 0E50 52 MSTORE 0E51 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0E72 60 PUSH1 0x44 0E74 82 DUP3 0E75 01 ADD 0E76 52 MSTORE 0E77 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 0E98 60 PUSH1 0x64 0E9A 82 DUP3 0E9B 01 ADD 0E9C 52 MSTORE 0E9D 60 PUSH1 0x84 0E9F 01 ADD 0EA0 61 PUSH2 0x05c4 0EA3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0E42 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E49 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E50 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0E76 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0E9C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @0E9F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_0EA4: // Incoming jump from 0x0E36, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0EA8 stack[-1] } 0EA4 5B JUMPDEST 0EA5 61 PUSH2 0x08d8 0EA8 81 DUP2 0EA9 61 PUSH2 0x137c 0EAC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0EA5 stack[0] = 0x08d8 // @0EA8 stack[1] = stack[-1] // } // Block ends with call to 0x137c, returns to 0x08D8 label_0EAD: // Incoming call from 0x0A52, returns to 0x0A53 // Incoming call from 0x0702, returns to 0x0703 // Incoming call from 0x1285, returns to 0x1286 // Incoming call from 0x1A60, returns to 0x1A61 // Incoming call from 0x096F, returns to 0x0970 // Incoming call from 0x0555, returns to 0x0556 // Incoming call from 0x0CB1, returns to 0x0CB2 // Incoming call from 0x07F8, returns to 0x07F9 // Inputs[3] // { // @0EB0 stack[-1] // @0EC0 memory[0x00:0x40] // @0EC1 storage[keccak256(memory[0x00:0x40])] // } 0EAD 5B JUMPDEST 0EAE 60 PUSH1 0x08 0EB0 81 DUP2 0EB1 90 SWAP1 0EB2 1C SHR 0EB3 60 PUSH1 0x00 0EB5 90 SWAP1 0EB6 81 DUP2 0EB7 52 MSTORE 0EB8 60 PUSH1 0x0c 0EBA 60 PUSH1 0x20 0EBC 52 MSTORE 0EBD 60 PUSH1 0x40 0EBF 81 DUP2 0EC0 20 SHA3 0EC1 54 SLOAD 0EC2 60 PUSH1 0x01 0EC4 60 PUSH1 0xff 0EC6 1B SHL 0EC7 60 PUSH1 0xff 0EC9 84 DUP5 0ECA 16 AND 0ECB 1C SHR 0ECC 16 AND 0ECD 15 ISZERO 0ECE 61 PUSH2 0x0ed9 0ED1 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0EB5 stack[0] = 0x00 // @0EB7 memory[0x00:0x20] = stack[-1] >> 0x08 // @0EBC memory[0x20:0x40] = 0x0c // } // Block ends with conditional jump to 0x0ed9, if !(((0x01 << 0xff) >> (stack[-1] & 0xff)) & storage[keccak256(memory[0x00:0x40])]) label_0ED2: // Incoming jump from 0x0ED1, if not !(((0x01 << 0xff) >> (stack[-1] & 0xff)) & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @0ED5 stack[-3] // @0ED6 stack[-2] // } 0ED2 50 POP 0ED3 60 PUSH1 0x00 0ED5 91 SWAP2 0ED6 90 SWAP1 0ED7 50 POP 0ED8 56 *JUMP // Stack delta = -2 // Outputs[1] { @0ED5 stack[-3] = 0x00 } // Block ends with unconditional jump to stack[-3] label_0ED9: // Incoming jump from 0x0ED1, if !(((0x01 << 0xff) >> (stack[-1] & 0xff)) & storage[keccak256(memory[0x00:0x40])]) // Inputs[2] // { // @0EDD stack[-2] // @0EE0 storage[0x09] // } 0ED9 5B JUMPDEST 0EDA 61 PUSH2 0x04b3 0EDD 82 DUP3 0EDE 60 PUSH1 0x09 0EE0 54 SLOAD 0EE1 11 GT 0EE2 90 SWAP1 0EE3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EE2 stack[0] = storage[0x09] > stack[-2] } // Block ends with unconditional jump to 0x04b3 label_0EE4: // Incoming call from 0x06D8, returns to 0x06D9 // Incoming call from 0x07E4, returns to 0x07E5 // Incoming call from 0x0C93, returns to 0x0C94 // Incoming call from 0x0B9E, returns to 0x0B9F // Incoming call from 0x05F2, returns to 0x05F3 // Inputs[1] { @0EF4 address(0xaaeb6d7670e522a718067333cd4e).code.length } 0EE4 5B JUMPDEST 0EE5 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 0EF4 3B EXTCODESIZE 0EF5 15 ISZERO 0EF6 61 PUSH2 0x08d8 0EF9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08d8, if !address(0xaaeb6d7670e522a718067333cd4e).code.length label_0EFA: // Incoming jump from 0x0EF9, if not !address(0xaaeb6d7670e522a718067333cd4e).code.length // Inputs[7] // { // @0EFC memory[0x40:0x60] // @0F20 address(this) // @0F2E stack[-1] // @0F52 memory[0x40:0x60] // @0F58 msg.gas // @0F59 address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0F59 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0EFA 60 PUSH1 0x40 0EFC 51 MLOAD 0EFD 7F PUSH32 0xc617113400000000000000000000000000000000000000000000000000000000 0F1E 81 DUP2 0F1F 52 MSTORE 0F20 30 ADDRESS 0F21 60 PUSH1 0x04 0F23 82 DUP3 0F24 01 ADD 0F25 52 MSTORE 0F26 60 PUSH1 0x01 0F28 60 PUSH1 0x01 0F2A 60 PUSH1 0xa0 0F2C 1B SHL 0F2D 03 SUB 0F2E 82 DUP3 0F2F 16 AND 0F30 60 PUSH1 0x24 0F32 82 DUP3 0F33 01 ADD 0F34 52 MSTORE 0F35 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 0F44 90 SWAP1 0F45 63 PUSH4 0xc6171134 0F4A 90 SWAP1 0F4B 60 PUSH1 0x44 0F4D 01 ADD 0F4E 60 PUSH1 0x20 0F50 60 PUSH1 0x40 0F52 51 MLOAD 0F53 80 DUP1 0F54 83 DUP4 0F55 03 SUB 0F56 81 DUP2 0F57 86 DUP7 0F58 5A GAS 0F59 FA STATICCALL 0F5A 15 ISZERO 0F5B 80 DUP1 0F5C 15 ISZERO 0F5D 61 PUSH2 0x0f6a 0F60 57 *JUMPI // Stack delta = +4 // Outputs[8] // { // @0F1F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc617113400000000000000000000000000000000000000000000000000000000 // @0F25 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @0F34 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @0F44 stack[0] = 0xaaeb6d7670e522a718067333cd4e // @0F4A stack[1] = 0xc6171134 // @0F4D stack[2] = 0x44 + memory[0x40:0x60] // @0F59 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @0F5A stack[3] = !address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x0f6a, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_0F61: // Incoming jump from 0x0F60, if not !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @0F61 returndata.length // @0F65 returndata[0x00:0x00 + returndata.length] // @0F66 returndata.length // @0F69 memory[0x00:0x00 + returndata.length] // } 0F61 3D RETURNDATASIZE 0F62 60 PUSH1 0x00 0F64 80 DUP1 0F65 3E RETURNDATACOPY 0F66 3D RETURNDATASIZE 0F67 60 PUSH1 0x00 0F69 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F65 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0F69 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0F6A: // Incoming jump from 0x0F60, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @0F71 memory[0x40:0x60] // @0F72 returndata.length // } 0F6A 5B JUMPDEST 0F6B 50 POP 0F6C 50 POP 0F6D 50 POP 0F6E 50 POP 0F6F 60 PUSH1 0x40 0F71 51 MLOAD 0F72 3D RETURNDATASIZE 0F73 60 PUSH1 0x1f 0F75 19 NOT 0F76 60 PUSH1 0x1f 0F78 82 DUP3 0F79 01 ADD 0F7A 16 AND 0F7B 82 DUP3 0F7C 01 ADD 0F7D 80 DUP1 0F7E 60 PUSH1 0x40 0F80 52 MSTORE 0F81 50 POP 0F82 81 DUP2 0F83 01 ADD 0F84 90 SWAP1 0F85 61 PUSH2 0x0f8e 0F88 91 SWAP2 0F89 90 SWAP1 0F8A 61 PUSH2 0x286c 0F8D 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0F80 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0F88 stack[-4] = 0x0f8e // @0F89 stack[-2] = memory[0x40:0x60] // @0F89 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x286c 0F8E 5B JUMPDEST 0F8F 61 PUSH2 0x08d8 0F92 57 *JUMPI 0F93 60 PUSH1 0x40 0F95 51 MLOAD 0F96 7F PUSH32 0xede71dcc00000000000000000000000000000000000000000000000000000000 0FB7 81 DUP2 0FB8 52 MSTORE 0FB9 60 PUSH1 0x01 0FBB 60 PUSH1 0x01 0FBD 60 PUSH1 0xa0 0FBF 1B SHL 0FC0 03 SUB 0FC1 82 DUP3 0FC2 16 AND 0FC3 60 PUSH1 0x04 0FC5 82 DUP3 0FC6 01 ADD 0FC7 52 MSTORE 0FC8 60 PUSH1 0x24 0FCA 01 ADD 0FCB 61 PUSH2 0x05c4 0FCE 56 *JUMP label_0FCF: // Incoming jump from 0x05FC // Inputs[1] { @0FD5 stack[-1] } 0FCF 5B JUMPDEST 0FD0 60 PUSH1 0x00 0FD2 61 PUSH2 0x0fda 0FD5 82 DUP3 0FD6 61 PUSH2 0x09aa 0FD9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FD0 stack[0] = 0x00 // @0FD2 stack[1] = 0x0fda // @0FD5 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x09aa 0FDA 5B JUMPDEST 0FDB 90 SWAP1 0FDC 50 POP 0FDD 80 DUP1 0FDE 60 PUSH1 0x01 0FE0 60 PUSH1 0x01 0FE2 60 PUSH1 0xa0 0FE4 1B SHL 0FE5 03 SUB 0FE6 16 AND 0FE7 83 DUP4 0FE8 60 PUSH1 0x01 0FEA 60 PUSH1 0x01 0FEC 60 PUSH1 0xa0 0FEE 1B SHL 0FEF 03 SUB 0FF0 16 AND 0FF1 03 SUB 0FF2 61 PUSH2 0x1049 0FF5 57 *JUMPI 0FF6 60 PUSH1 0x40 0FF8 51 MLOAD 0FF9 62 PUSH3 0x461bcd 0FFD 60 PUSH1 0xe5 0FFF 1B SHL 1000 81 DUP2 1001 52 MSTORE 1002 60 PUSH1 0x20 1004 60 PUSH1 0x04 1006 82 DUP3 1007 01 ADD 1008 52 MSTORE 1009 60 PUSH1 0x24 100B 80 DUP1 100C 82 DUP3 100D 01 ADD 100E 52 MSTORE 100F 7F PUSH32 0x4552433732315073693a20617070726f76616c20746f2063757272656e74206f 1030 60 PUSH1 0x44 1032 82 DUP3 1033 01 ADD 1034 52 MSTORE 1035 63 PUSH4 0x3bb732b9 103A 60 PUSH1 0xe1 103C 1B SHL 103D 60 PUSH1 0x64 103F 82 DUP3 1040 01 ADD 1041 52 MSTORE 1042 60 PUSH1 0x84 1044 01 ADD 1045 61 PUSH2 0x05c4 1048 56 *JUMP 1049 5B JUMPDEST 104A 33 CALLER 104B 60 PUSH1 0x01 104D 60 PUSH1 0x01 104F 60 PUSH1 0xa0 1051 1B SHL 1052 03 SUB 1053 82 DUP3 1054 16 AND 1055 14 EQ 1056 80 DUP1 1057 61 PUSH2 0x1065 105A 57 *JUMPI 105B 50 POP 105C 61 PUSH2 0x1065 105F 81 DUP2 1060 33 CALLER 1061 61 PUSH2 0x03a7 1064 56 *JUMP 1065 5B JUMPDEST 1066 61 PUSH2 0x10d7 1069 57 *JUMPI 106A 60 PUSH1 0x40 106C 51 MLOAD 106D 62 PUSH3 0x461bcd 1071 60 PUSH1 0xe5 1073 1B SHL 1074 81 DUP2 1075 52 MSTORE 1076 60 PUSH1 0x20 1078 60 PUSH1 0x04 107A 82 DUP3 107B 01 ADD 107C 52 MSTORE 107D 60 PUSH1 0x3b 107F 60 PUSH1 0x24 1081 82 DUP3 1082 01 ADD 1083 52 MSTORE 1084 7F PUSH32 0x4552433732315073693a20617070726f76652063616c6c6572206973206e6f74 10A5 60 PUSH1 0x44 10A7 82 DUP3 10A8 01 ADD 10A9 52 MSTORE 10AA 7F PUSH32 0x206f776e6572206e6f7220617070726f76656420666f7220616c6c0000000000 10CB 60 PUSH1 0x64 10CD 82 DUP3 10CE 01 ADD 10CF 52 MSTORE 10D0 60 PUSH1 0x84 10D2 01 ADD 10D3 61 PUSH2 0x05c4 10D6 56 *JUMP 10D7 5B JUMPDEST 10D8 61 PUSH2 0x05fd 10DB 83 DUP4 10DC 83 DUP4 10DD 61 PUSH2 0x19ce 10E0 56 *JUMP label_10E1: // Incoming call from 0x060B, returns to 0x060C // Inputs[1] { @10E9 storage[0x09] } 10E1 5B JUMPDEST 10E2 60 PUSH1 0x00 10E4 80 DUP1 10E5 60 PUSH1 0x08 10E7 60 PUSH1 0x09 10E9 54 SLOAD 10EA 90 SWAP1 10EB 1C SHR 10EC 60 PUSH1 0x01 10EE 61 PUSH2 0x10f7 10F1 91 SWAP2 10F2 90 SWAP1 10F3 61 PUSH2 0x2770 10F6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @10E2 stack[0] = 0x00 // @10E4 stack[1] = 0x00 // @10F1 stack[2] = 0x10f7 // @10F2 stack[3] = storage[0x09] >> 0x08 // @10F2 stack[4] = 0x01 // } // Block ends with call to 0x2770, returns to 0x10F7 label_10F7: // Incoming return from call to 0x2770 at 0x10F6 // Inputs[2] // { // @10F8 stack[-1] // @10F8 stack[-2] // } 10F7 5B JUMPDEST 10F8 90 SWAP1 10F9 50 POP 10FA 60 PUSH1 0x00 10FC 5B JUMPDEST 10FD 81 DUP2 10FE 81 DUP2 10FF 10 LT 1100 15 ISZERO 1101 61 PUSH2 0x113c 1104 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @10F8 stack[-2] = stack[-1] // @10FA stack[-1] = 0x00 // } // Block ends with conditional jump to 0x113c, if !(0x00 < stack[-1]) label_1105: // Incoming jump from 0x1104, if not !(0x00 < stack[-1]) // Incoming jump from 0x1104, if not !(stack[-1] < stack[-2]) // Inputs[3] // { // @1107 stack[-1] // @1112 memory[0x00:0x40] // @1113 storage[keccak256(memory[0x00:0x40])] // } 1105 60 PUSH1 0x00 1107 81 DUP2 1108 81 DUP2 1109 52 MSTORE 110A 60 PUSH1 0x0c 110C 60 PUSH1 0x20 110E 52 MSTORE 110F 60 PUSH1 0x40 1111 90 SWAP1 1112 20 SHA3 1113 54 SLOAD 1114 61 PUSH2 0x111c 1117 81 DUP2 1118 61 PUSH2 0x1a3c 111B 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1109 memory[0x00:0x20] = stack[-1] // @110E memory[0x20:0x40] = 0x0c // @1113 stack[0] = storage[keccak256(memory[0x00:0x40])] // @1114 stack[1] = 0x111c // @1117 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1a3c, returns to 0x111C label_111C: // Incoming return from call to 0x1A3C at 0x111B // Inputs[2] // { // @1120 stack[-1] // @1121 stack[-5] // } 111C 5B JUMPDEST 111D 61 PUSH2 0x1126 1120 90 SWAP1 1121 85 DUP6 1122 61 PUSH2 0x2770 1125 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1120 stack[0] = stack[-1] // @1120 stack[-1] = 0x1126 // @1121 stack[1] = stack[-5] // } // Block ends with call to 0x2770, returns to 0x1126 label_1126: // Incoming return from call to 0x2770 at 0x1125 // Inputs[3] // { // @1127 stack[-5] // @1127 stack[-1] // @112A stack[-3] // } 1126 5B JUMPDEST 1127 93 SWAP4 1128 50 POP 1129 50 POP 112A 80 DUP1 112B 80 DUP1 112C 61 PUSH2 0x1134 112F 90 SWAP1 1130 61 PUSH2 0x26ad 1133 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1127 stack[-5] = stack[-1] // @112A stack[-2] = stack[-3] // @112F stack[0] = stack[-3] // @112F stack[-1] = 0x1134 // } // Block ends with call to 0x26ad, returns to 0x1134 label_1134: // Incoming return from call to 0x26AD at 0x1133 // Inputs[2] // { // @1135 stack[-3] // @1135 stack[-1] // } 1134 5B JUMPDEST 1135 91 SWAP2 1136 50 POP 1137 50 POP 1138 61 PUSH2 0x10fc 113B 56 *JUMP // Stack delta = -2 // Outputs[1] { @1135 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x10fc label_113C: // Incoming jump from 0x1104, if !(0x00 < stack[-1]) // Incoming jump from 0x1104, if !(stack[-1] < stack[-2]) // Inputs[2] // { // @113F stack[-3] // @113F stack[-4] // } 113C 5B JUMPDEST 113D 50 POP 113E 50 POP 113F 90 SWAP1 1140 56 *JUMP // Stack delta = -3 // Outputs[1] { @113F stack[-4] = stack[-3] } // Block ends with unconditional jump to stack[-4] label_1141: // Incoming call from 0x06BA, returns to 0x06BB // Inputs[2] // { // @1142 stack[-1] // @1146 memory[stack[-1]:stack[-1] + 0x20] // } 1141 5B JUMPDEST 1142 80 DUP1 1143 60 PUSH1 0x00 1145 81 DUP2 1146 51 MLOAD 1147 81 DUP2 1148 10 LT 1149 61 PUSH2 0x1154 114C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1142 stack[0] = stack[-1] // @1143 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1154, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] label_114D: // Incoming jump from 0x114C, if not 0x00 < memory[stack[-1]:stack[-1] + 0x20] 114D 61 PUSH2 0x1154 1150 61 PUSH2 0x2889 1153 56 *JUMP // Stack delta = +1 // Outputs[1] { @114D stack[0] = 0x1154 } // Block ends with unconditional jump to 0x2889 label_1154: // Incoming jump from 0x114C, if 0x00 < memory[stack[-1]:stack[-1] + 0x20] // Inputs[5] // { // @1157 stack[-1] // @115A stack[-2] // @115F memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] // @1168 storage[0x03] // @116F stack[-5] // } 1154 5B JUMPDEST 1155 60 PUSH1 0x20 1157 90 SWAP1 1158 81 DUP2 1159 02 MUL 115A 91 SWAP2 115B 90 SWAP1 115C 91 SWAP2 115D 01 ADD 115E 01 ADD 115F 51 MLOAD 1160 60 PUSH1 0x04 1162 55 SSTORE 1163 50 POP 1164 50 POP 1165 60 PUSH1 0x03 1167 80 DUP1 1168 54 SLOAD 1169 60 PUSH1 0xff 116B 19 NOT 116C 16 AND 116D 90 SWAP1 116E 55 SSTORE 116F 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1162 storage[0x04] = memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] // @116E storage[0x03] = ~0xff & storage[0x03] // } // Block ends with unconditional jump to stack[-5] label_1170: // Incoming jump from 0x06E3 // Inputs[2] // { // @1174 msg.sender // @1175 stack[-1] // } 1170 5B JUMPDEST 1171 61 PUSH2 0x117a 1174 33 CALLER 1175 82 DUP3 1176 61 PUSH2 0x1a56 1179 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1171 stack[0] = 0x117a // @1174 stack[1] = msg.sender // @1175 stack[2] = stack[-1] // } // Block ends with unconditional jump to 0x1a56 117A 5B JUMPDEST 117B 61 PUSH2 0x11ec 117E 57 *JUMPI 117F 60 PUSH1 0x40 1181 51 MLOAD 1182 62 PUSH3 0x461bcd 1186 60 PUSH1 0xe5 1188 1B SHL 1189 81 DUP2 118A 52 MSTORE 118B 60 PUSH1 0x20 118D 60 PUSH1 0x04 118F 82 DUP3 1190 01 ADD 1191 52 MSTORE 1192 60 PUSH1 0x34 1194 60 PUSH1 0x24 1196 82 DUP3 1197 01 ADD 1198 52 MSTORE 1199 7F PUSH32 0x4552433732315073693a207472616e736665722063616c6c6572206973206e6f 11BA 60 PUSH1 0x44 11BC 82 DUP3 11BD 01 ADD 11BE 52 MSTORE 11BF 7F PUSH32 0x74206f776e6572206e6f7220617070726f766564000000000000000000000000 11E0 60 PUSH1 0x64 11E2 82 DUP3 11E3 01 ADD 11E4 52 MSTORE 11E5 60 PUSH1 0x84 11E7 01 ADD 11E8 61 PUSH2 0x05c4 11EB 56 *JUMP 11EC 5B JUMPDEST 11ED 61 PUSH2 0x05fd 11F0 83 DUP4 11F1 83 DUP4 11F2 83 DUP4 11F3 61 PUSH2 0x1b4d 11F6 56 *JUMP label_11F7: // Incoming jump from 0x07EF // Inputs[4] // { // @11FB stack[-3] // @11FC stack[-2] // @11FD stack[-1] // @1200 memory[0x40:0x60] // } 11F7 5B JUMPDEST 11F8 61 PUSH2 0x05fd 11FB 83 DUP4 11FC 83 DUP4 11FD 83 DUP4 11FE 60 PUSH1 0x40 1200 51 MLOAD 1201 80 DUP1 1202 60 PUSH1 0x20 1204 01 ADD 1205 60 PUSH1 0x40 1207 52 MSTORE 1208 80 DUP1 1209 60 PUSH1 0x00 120B 81 DUP2 120C 52 MSTORE 120D 50 POP 120E 61 PUSH2 0x0c7a 1211 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @11F8 stack[0] = 0x05fd // @11FB stack[1] = stack[-3] // @11FC stack[2] = stack[-2] // @11FD stack[3] = stack[-1] // @1200 stack[4] = memory[0x40:0x60] // @1207 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @120C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0c7a 1212 5B JUMPDEST 1213 60 PUSH1 0x00 1215 61 PUSH2 0x121d 1218 82 DUP3 1219 61 PUSH2 0x09aa 121C 56 *JUMP 121D 5B JUMPDEST 121E 60 PUSH1 0x08 1220 83 DUP4 1221 90 SWAP1 1222 1C SHR 1223 60 PUSH1 0x00 1225 90 SWAP1 1226 81 DUP2 1227 52 MSTORE 1228 60 PUSH1 0x0c 122A 60 PUSH1 0x20 122C 52 MSTORE 122D 60 PUSH1 0x40 122F 80 DUP1 1230 82 DUP3 1231 20 SHA3 1232 80 DUP1 1233 54 SLOAD 1234 60 PUSH1 0x01 1236 60 PUSH1 0xff 1238 1B SHL 1239 60 PUSH1 0xff 123B 88 DUP9 123C 16 AND 123D 1C SHR 123E 17 OR 123F 90 SWAP1 1240 55 SSTORE 1241 51 MLOAD 1242 91 SWAP2 1243 92 SWAP3 1244 50 POP 1245 83 DUP4 1246 91 SWAP2 1247 60 PUSH1 0x01 1249 60 PUSH1 0x01 124B 60 PUSH1 0xa0 124D 1B SHL 124E 03 SUB 124F 84 DUP5 1250 16 AND 1251 90 SWAP1 1252 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1273 90 SWAP1 1274 83 DUP4 1275 90 SWAP1 1276 A4 LOG4 1277 50 POP 1278 50 POP 1279 56 *JUMP label_127A: // Incoming jump from 0x09B5 // Inputs[1] { @1281 stack[-1] } 127A 5B JUMPDEST 127B 60 PUSH1 0x00 127D 80 DUP1 127E 61 PUSH2 0x1286 1281 83 DUP4 1282 61 PUSH2 0x0ead 1285 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @127B stack[0] = 0x00 // @127D stack[1] = 0x00 // @127E stack[2] = 0x1286 // @1281 stack[3] = stack[-1] // } // Block ends with call to 0x0ead, returns to 0x1286 label_1286: // Incoming return from call to 0x0EAD at 0x1285 // Inputs[1] { @128A stack[-1] } 1286 5B JUMPDEST 1287 61 PUSH2 0x12f8 128A 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12f8, if stack[-1] label_128B: // Incoming jump from 0x128A, if not stack[-1] // Inputs[1] { @128D memory[0x40:0x60] } 128B 60 PUSH1 0x40 128D 51 MLOAD 128E 62 PUSH3 0x461bcd 1292 60 PUSH1 0xe5 1294 1B SHL 1295 81 DUP2 1296 52 MSTORE 1297 60 PUSH1 0x20 1299 60 PUSH1 0x04 129B 82 DUP3 129C 01 ADD 129D 52 MSTORE 129E 60 PUSH1 0x2c 12A0 60 PUSH1 0x24 12A2 82 DUP3 12A3 01 ADD 12A4 52 MSTORE 12A5 7F PUSH32 0x4552433732315073693a206f776e657220717565727920666f72206e6f6e6578 12C6 60 PUSH1 0x44 12C8 82 DUP3 12C9 01 ADD 12CA 52 MSTORE 12CB 7F PUSH32 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 12EC 60 PUSH1 0x64 12EE 82 DUP3 12EF 01 ADD 12F0 52 MSTORE 12F1 60 PUSH1 0x84 12F3 01 ADD 12F4 61 PUSH2 0x05c4 12F7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1296 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @129D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12A4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @12CA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a206f776e657220717565727920666f72206e6f6e6578 // @12F0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x697374656e7420746f6b656e0000000000000000000000000000000000000000 // @12F3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_12F8: // Incoming jump from 0x128A, if stack[-1] // Inputs[1] { @12FC stack[-3] } 12F8 5B JUMPDEST 12F9 61 PUSH2 0x1301 12FC 83 DUP4 12FD 61 PUSH2 0x1d8d 1300 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12F9 stack[0] = 0x1301 // @12FC stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x1d8d 1301 5B JUMPDEST 1302 60 PUSH1 0x00 1304 81 DUP2 1305 81 DUP2 1306 52 MSTORE 1307 60 PUSH1 0x08 1309 60 PUSH1 0x20 130B 52 MSTORE 130C 60 PUSH1 0x40 130E 90 SWAP1 130F 20 SHA3 1310 54 SLOAD 1311 60 PUSH1 0x01 1313 60 PUSH1 0x01 1315 60 PUSH1 0xa0 1317 1B SHL 1318 03 SUB 1319 16 AND 131A 94 SWAP5 131B 90 SWAP1 131C 93 SWAP4 131D 50 POP 131E 91 SWAP2 131F 50 POP 1320 50 POP 1321 56 *JUMP label_1322: // Incoming call from 0x0AA3, returns to 0x0AA4 // Incoming call from 0x0E27, returns to 0x0E28 // Incoming call from 0x0ACC, returns to 0x0ACD // Incoming call from 0x0AB7, returns to 0x0AB8 // Inputs[2] // { // @1325 storage[0x00] // @132F msg.sender // } 1322 5B JUMPDEST 1323 60 PUSH1 0x00 1325 54 SLOAD 1326 60 PUSH1 0x01 1328 60 PUSH1 0x01 132A 60 PUSH1 0xa0 132C 1B SHL 132D 03 SUB 132E 16 AND 132F 33 CALLER 1330 14 EQ 1331 61 PUSH2 0x0aae 1334 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0aae, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_1335: // Incoming jump from 0x1334, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @1337 memory[0x40:0x60] } 1335 60 PUSH1 0x40 1337 51 MLOAD 1338 62 PUSH3 0x461bcd 133C 60 PUSH1 0xe5 133E 1B SHL 133F 81 DUP2 1340 52 MSTORE 1341 60 PUSH1 0x20 1343 60 PUSH1 0x04 1345 82 DUP3 1346 01 ADD 1347 81 DUP2 1348 90 SWAP1 1349 52 MSTORE 134A 60 PUSH1 0x24 134C 82 DUP3 134D 01 ADD 134E 52 MSTORE 134F 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1370 60 PUSH1 0x44 1372 82 DUP3 1373 01 ADD 1374 52 MSTORE 1375 60 PUSH1 0x64 1377 01 ADD 1378 61 PUSH2 0x05c4 137B 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1340 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1349 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @134E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1374 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1377 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_137C: // Incoming call from 0x0AAD, returns to 0x0AAE // Incoming call from 0x0EAC, returns to 0x08D8 // Inputs[5] // { // @1380 storage[0x00] // @1389 stack[-1] // @139D memory[0x40:0x60] // @13C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @13CB stack[-2] // } 137C 5B JUMPDEST 137D 60 PUSH1 0x00 137F 80 DUP1 1380 54 SLOAD 1381 60 PUSH1 0x01 1383 60 PUSH1 0x01 1385 60 PUSH1 0xa0 1387 1B SHL 1388 03 SUB 1389 83 DUP4 138A 81 DUP2 138B 16 AND 138C 60 PUSH1 0x01 138E 60 PUSH1 0x01 1390 60 PUSH1 0xa0 1392 1B SHL 1393 03 SUB 1394 19 NOT 1395 83 DUP4 1396 16 AND 1397 81 DUP2 1398 17 OR 1399 84 DUP5 139A 55 SSTORE 139B 60 PUSH1 0x40 139D 51 MLOAD 139E 91 SWAP2 139F 90 SWAP1 13A0 92 SWAP3 13A1 16 AND 13A2 92 SWAP3 13A3 83 DUP4 13A4 91 SWAP2 13A5 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 13C6 91 SWAP2 13C7 90 SWAP1 13C8 A3 LOG3 13C9 50 POP 13CA 50 POP 13CB 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @139A storage[0x00] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x00] & ~((0x01 << 0xa0) - 0x01)) // @13C8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_13CC: // Incoming call from 0x0B85, returns to 0x06BB // Inputs[2] // { // @13CF storage[0x09] // @13D0 stack[-1] // } 13CC 5B JUMPDEST 13CD 60 PUSH1 0x09 13CF 54 SLOAD 13D0 81 DUP2 13D1 61 PUSH2 0x1442 13D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13CF stack[0] = storage[0x09] } // Block ends with conditional jump to 0x1442, if stack[-1] label_13D5: // Incoming jump from 0x13D4, if not stack[-1] // Inputs[1] { @13D7 memory[0x40:0x60] } 13D5 60 PUSH1 0x40 13D7 51 MLOAD 13D8 62 PUSH3 0x461bcd 13DC 60 PUSH1 0xe5 13DE 1B SHL 13DF 81 DUP2 13E0 52 MSTORE 13E1 60 PUSH1 0x20 13E3 60 PUSH1 0x04 13E5 82 DUP3 13E6 01 ADD 13E7 52 MSTORE 13E8 60 PUSH1 0x25 13EA 60 PUSH1 0x24 13EC 82 DUP3 13ED 01 ADD 13EE 52 MSTORE 13EF 7F PUSH32 0x4552433732315073693a207175616e74697479206d7573742062652067726561 1410 60 PUSH1 0x44 1412 82 DUP3 1413 01 ADD 1414 52 MSTORE 1415 7F PUSH32 0x7465722030000000000000000000000000000000000000000000000000000000 1436 60 PUSH1 0x64 1438 82 DUP3 1439 01 ADD 143A 52 MSTORE 143B 60 PUSH1 0x84 143D 01 ADD 143E 61 PUSH2 0x05c4 1441 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @13E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @13E7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @13EE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @1414 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a207175616e74697479206d7573742062652067726561 // @143A memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7465722030000000000000000000000000000000000000000000000000000000 // @143D stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_1442: // Incoming jump from 0x13D4, if stack[-1] // Inputs[1] { @144B stack[-3] } 1442 5B JUMPDEST 1443 60 PUSH1 0x01 1445 60 PUSH1 0x01 1447 60 PUSH1 0xa0 1449 1B SHL 144A 03 SUB 144B 83 DUP4 144C 16 AND 144D 61 PUSH2 0x14be 1450 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14be, if stack[-3] & (0x01 << 0xa0) - 0x01 label_1451: // Incoming jump from 0x1450, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1453 memory[0x40:0x60] } 1451 60 PUSH1 0x40 1453 51 MLOAD 1454 62 PUSH3 0x461bcd 1458 60 PUSH1 0xe5 145A 1B SHL 145B 81 DUP2 145C 52 MSTORE 145D 60 PUSH1 0x20 145F 60 PUSH1 0x04 1461 82 DUP3 1462 01 ADD 1463 52 MSTORE 1464 60 PUSH1 0x23 1466 60 PUSH1 0x24 1468 82 DUP3 1469 01 ADD 146A 52 MSTORE 146B 7F PUSH32 0x4552433732315073693a206d696e7420746f20746865207a65726f2061646472 148C 60 PUSH1 0x44 148E 82 DUP3 148F 01 ADD 1490 52 MSTORE 1491 7F PUSH32 0x6573730000000000000000000000000000000000000000000000000000000000 14B2 60 PUSH1 0x64 14B4 82 DUP3 14B5 01 ADD 14B6 52 MSTORE 14B7 60 PUSH1 0x84 14B9 01 ADD 14BA 61 PUSH2 0x05c4 14BD 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @145C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1463 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @146A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @1490 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a206d696e7420746f20746865207a65726f2061646472 // @14B6 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6573730000000000000000000000000000000000000000000000000000000000 // @14B9 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_14BE: // Incoming jump from 0x1450, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @14BF stack[-2] // @14C6 storage[0x09] // } 14BE 5B JUMPDEST 14BF 81 DUP2 14C0 60 PUSH1 0x09 14C2 60 PUSH1 0x00 14C4 82 DUP3 14C5 82 DUP3 14C6 54 SLOAD 14C7 61 PUSH2 0x14d0 14CA 91 SWAP2 14CB 90 SWAP1 14CC 61 PUSH2 0x2770 14CF 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @14BF stack[0] = stack[-2] // @14C0 stack[1] = 0x09 // @14C2 stack[2] = 0x00 // @14CA stack[3] = 0x14d0 // @14CB stack[4] = stack[-2] // @14CB stack[5] = storage[0x09] // } // Block ends with call to 0x2770, returns to 0x14D0 label_14D0: // Incoming return from call to 0x2770 at 0x14CF // Inputs[10] // { // @14D1 stack[-2] // @14D1 stack[-1] // @14D2 stack[-3] // @14D8 stack[-5] // @14E6 memory[0x00:0x40] // @14E8 storage[keccak256(memory[0x00:0x40])] // @14FB stack[-7] // @150B memory[0x00:0x40] // @150D storage[keccak256(memory[0x00:0x40])] // @1520 stack[-6] // } 14D0 5B JUMPDEST 14D1 90 SWAP1 14D2 91 SWAP2 14D3 55 SSTORE 14D4 50 POP 14D5 50 POP 14D6 60 PUSH1 0x00 14D8 81 DUP2 14D9 81 DUP2 14DA 52 MSTORE 14DB 60 PUSH1 0x08 14DD 60 PUSH1 0x20 14DF 81 DUP2 14E0 81 DUP2 14E1 52 MSTORE 14E2 60 PUSH1 0x40 14E4 80 DUP1 14E5 84 DUP5 14E6 20 SHA3 14E7 80 DUP1 14E8 54 SLOAD 14E9 60 PUSH1 0x01 14EB 60 PUSH1 0x01 14ED 60 PUSH1 0xa0 14EF 1B SHL 14F0 03 SUB 14F1 19 NOT 14F2 16 AND 14F3 60 PUSH1 0x01 14F5 60 PUSH1 0x01 14F7 60 PUSH1 0xa0 14F9 1B SHL 14FA 03 SUB 14FB 89 DUP10 14FC 16 AND 14FD 17 OR 14FE 90 SWAP1 14FF 55 SSTORE 1500 91 SWAP2 1501 84 DUP5 1502 90 SWAP1 1503 1C SHR 1504 83 DUP4 1505 52 MSTORE 1506 60 PUSH1 0x05 1508 90 SWAP1 1509 52 MSTORE 150A 90 SWAP1 150B 20 SHA3 150C 80 DUP1 150D 54 SLOAD 150E 60 PUSH1 0x01 1510 60 PUSH1 0xff 1512 1B SHL 1513 60 PUSH1 0xff 1515 84 DUP5 1516 16 AND 1517 1C SHR 1518 17 OR 1519 90 SWAP1 151A 55 SSTORE 151B 80 DUP1 151C 5B JUMPDEST 151D 61 PUSH2 0x1526 1520 83 DUP4 1521 83 DUP4 1522 61 PUSH2 0x2770 1525 56 *JUMP // Stack delta = +0 // Outputs[11] // { // @14D3 storage[stack[-3]] = stack[-1] // @14DA memory[0x00:0x20] = stack[-5] // @14E1 memory[0x20:0x40] = 0x08 // @14FF storage[keccak256(memory[0x00:0x40])] = (stack[-7] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1505 memory[0x00:0x20] = stack[-5] >> 0x08 // @1509 memory[0x20:0x40] = 0x05 // @151A storage[keccak256(memory[0x00:0x40])] = ((0x01 << 0xff) >> (stack[-5] & 0xff)) | storage[keccak256(memory[0x00:0x40])] // @151B stack[-4] = stack[-5] // @151D stack[-3] = 0x1526 // @1520 stack[-2] = stack[-6] // @1521 stack[-1] = stack[-5] // } // Block ends with call to 0x2770, returns to 0x1526 label_1526: // Incoming return from call to 0x2770 at 0x1525 // Incoming return from call to 0x2770 at 0x1525 // Inputs[2] // { // @1527 stack[-2] // @1528 stack[-1] // } 1526 5B JUMPDEST 1527 81 DUP2 1528 10 LT 1529 15 ISZERO 152A 61 PUSH2 0x06e4 152D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x06e4, if !(stack[-2] < stack[-1]) label_152E: // Incoming jump from 0x152D, if not !(stack[-2] < stack[-1]) // Inputs[4] // { // @1530 memory[0x40:0x60] // @1531 stack[-1] // @153B stack[-4] // @1565 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 152E 60 PUSH1 0x40 1530 51 MLOAD 1531 81 DUP2 1532 90 SWAP1 1533 60 PUSH1 0x01 1535 60 PUSH1 0x01 1537 60 PUSH1 0xa0 1539 1B SHL 153A 03 SUB 153B 86 DUP7 153C 16 AND 153D 90 SWAP1 153E 60 PUSH1 0x00 1540 90 SWAP1 1541 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1562 90 SWAP1 1563 82 DUP3 1564 90 SWAP1 1565 A4 LOG4 1566 80 DUP1 1567 61 PUSH2 0x156f 156A 81 DUP2 156B 61 PUSH2 0x26ad 156E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1565 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-4] & (0x01 << 0xa0) - 0x01, stack[-1]]); // @1566 stack[0] = stack[-1] // @1567 stack[1] = 0x156f // @156A stack[2] = stack[-1] // } // Block ends with call to 0x26ad, returns to 0x156F label_156F: // Incoming return from call to 0x26AD at 0x156E // Inputs[2] // { // @1570 stack[-3] // @1570 stack[-1] // } 156F 5B JUMPDEST 1570 91 SWAP2 1571 50 POP 1572 50 POP 1573 61 PUSH2 0x151c 1576 56 *JUMP // Stack delta = -2 // Outputs[1] { @1570 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x151c label_1577: // Incoming call from 0x0BA8, returns to 0x05FD // Inputs[2] // { // @1578 msg.sender // @1581 stack[-2] // } 1577 5B JUMPDEST 1578 33 CALLER 1579 60 PUSH1 0x01 157B 60 PUSH1 0x01 157D 60 PUSH1 0xa0 157F 1B SHL 1580 03 SUB 1581 83 DUP4 1582 16 AND 1583 03 SUB 1584 61 PUSH2 0x15cf 1587 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15cf, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender label_1588: // Incoming jump from 0x1587, if not (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[1] { @158A memory[0x40:0x60] } 1588 60 PUSH1 0x40 158A 51 MLOAD 158B 62 PUSH3 0x461bcd 158F 60 PUSH1 0xe5 1591 1B SHL 1592 81 DUP2 1593 52 MSTORE 1594 60 PUSH1 0x20 1596 60 PUSH1 0x04 1598 82 DUP3 1599 01 ADD 159A 52 MSTORE 159B 60 PUSH1 0x1c 159D 60 PUSH1 0x24 159F 82 DUP3 15A0 01 ADD 15A1 52 MSTORE 15A2 7F PUSH32 0x4552433732315073693a20617070726f766520746f2063616c6c657200000000 15C3 60 PUSH1 0x44 15C5 82 DUP3 15C6 01 ADD 15C7 52 MSTORE 15C8 60 PUSH1 0x64 15CA 01 ADD 15CB 61 PUSH2 0x05c4 15CE 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1593 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @159A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @15A1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1c // @15C7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a20617070726f766520746f2063616c6c657200000000 // @15CA stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_15CF: // Incoming jump from 0x1587, if (stack[-2] & (0x01 << 0xa0) - 0x01) - msg.sender // Inputs[10] // { // @15D0 msg.sender // @15E1 memory[0x00:0x40] // @15EA stack[-2] // @15F5 memory[0x00:0x40] // @15F7 storage[keccak256(memory[0x00:0x40])] // @15FC stack[-1] // @1606 memory[0x40:0x60] // @1632 memory[0x40:0x60] // @1637 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @163A stack[-3] // } 15CF 5B JUMPDEST 15D0 33 CALLER 15D1 60 PUSH1 0x00 15D3 81 DUP2 15D4 81 DUP2 15D5 52 MSTORE 15D6 60 PUSH1 0x0b 15D8 60 PUSH1 0x20 15DA 90 SWAP1 15DB 81 DUP2 15DC 52 MSTORE 15DD 60 PUSH1 0x40 15DF 80 DUP1 15E0 83 DUP4 15E1 20 SHA3 15E2 60 PUSH1 0x01 15E4 60 PUSH1 0x01 15E6 60 PUSH1 0xa0 15E8 1B SHL 15E9 03 SUB 15EA 87 DUP8 15EB 16 AND 15EC 80 DUP1 15ED 85 DUP6 15EE 52 MSTORE 15EF 90 SWAP1 15F0 83 DUP4 15F1 52 MSTORE 15F2 92 SWAP3 15F3 81 DUP2 15F4 90 SWAP1 15F5 20 SHA3 15F6 80 DUP1 15F7 54 SLOAD 15F8 60 PUSH1 0xff 15FA 19 NOT 15FB 16 AND 15FC 86 DUP7 15FD 15 ISZERO 15FE 15 ISZERO 15FF 90 SWAP1 1600 81 DUP2 1601 17 OR 1602 90 SWAP1 1603 91 SWAP2 1604 55 SSTORE 1605 90 SWAP1 1606 51 MLOAD 1607 90 SWAP1 1608 81 DUP2 1609 52 MSTORE 160A 91 SWAP2 160B 92 SWAP3 160C 91 SWAP2 160D 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 162E 91 SWAP2 162F 01 ADD 1630 60 PUSH1 0x40 1632 51 MLOAD 1633 80 DUP1 1634 91 SWAP2 1635 03 SUB 1636 90 SWAP1 1637 A3 LOG3 1638 50 POP 1639 50 POP 163A 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @15D5 memory[0x00:0x20] = msg.sender // @15DC memory[0x20:0x40] = 0x0b // @15EE memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @15F1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1604 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @1609 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @1637 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_163B: // Incoming call from 0x0C79, returns to 0x0AAE // Inputs[7] // { // @163F storage[0x01] // @1642 storage[0x02] // @1645 memory[0x40:0x60] // @16F2 memory[0x40:0x60] // @16FA msg.gas // @16FB address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @16FB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 163B 5B JUMPDEST 163C 60 PUSH1 0x01 163E 80 DUP1 163F 54 SLOAD 1640 60 PUSH1 0x02 1642 54 SLOAD 1643 60 PUSH1 0x40 1645 51 MLOAD 1646 7F PUSH32 0x5d3b1d3000000000000000000000000000000000000000000000000000000000 1667 81 DUP2 1668 52 MSTORE 1669 60 PUSH1 0x04 166B 81 DUP2 166C 01 ADD 166D 92 SWAP3 166E 90 SWAP1 166F 92 SWAP3 1670 52 MSTORE 1671 67 PUSH8 0xffffffffffffffff 167A 81 DUP2 167B 16 AND 167C 60 PUSH1 0x24 167E 83 DUP4 167F 01 ADD 1680 52 MSTORE 1681 68 PUSH9 0x010000000000000000 168B 81 DUP2 168C 04 DIV 168D 61 PUSH2 0xffff 1690 16 AND 1691 60 PUSH1 0x44 1693 83 DUP4 1694 01 ADD 1695 52 MSTORE 1696 6A PUSH11 0x0100000000000000000000 16A2 90 SWAP1 16A3 04 DIV 16A4 63 PUSH4 0xffffffff 16A9 16 AND 16AA 60 PUSH1 0x64 16AC 82 DUP3 16AD 01 ADD 16AE 52 MSTORE 16AF 60 PUSH1 0x84 16B1 81 DUP2 16B2 01 ADD 16B3 91 SWAP2 16B4 90 SWAP1 16B5 91 SWAP2 16B6 52 MSTORE 16B7 60 PUSH1 0x00 16B9 90 SWAP1 16BA 7F PUSH32 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909 16DB 60 PUSH1 0x01 16DD 60 PUSH1 0x01 16DF 60 PUSH1 0xa0 16E1 1B SHL 16E2 03 SUB 16E3 16 AND 16E4 90 SWAP1 16E5 63 PUSH4 0x5d3b1d30 16EA 90 SWAP1 16EB 60 PUSH1 0xa4 16ED 01 ADD 16EE 60 PUSH1 0x20 16F0 60 PUSH1 0x40 16F2 51 MLOAD 16F3 80 DUP1 16F4 83 DUP4 16F5 03 SUB 16F6 81 DUP2 16F7 60 PUSH1 0x00 16F9 87 DUP8 16FA 5A GAS 16FB F1 CALL 16FC 15 ISZERO 16FD 80 DUP1 16FE 15 ISZERO 16FF 61 PUSH2 0x170c 1702 57 *JUMPI // Stack delta = +5 // Outputs[12] // { // @1668 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5d3b1d3000000000000000000000000000000000000000000000000000000000 // @1670 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = storage[0x01] // @1680 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = storage[0x02] & 0xffffffffffffffff // @1695 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0xffff & storage[0x02] / 0x010000000000000000 // @16AE memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0xffffffff & storage[0x02] / 0x0100000000000000000000 // @16B6 memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x01 // @16B9 stack[0] = 0x00 // @16E4 stack[1] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909 // @16EA stack[2] = 0x5d3b1d30 // @16ED stack[3] = 0xa4 + memory[0x40:0x60] // @16FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @16FC stack[4] = !address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x170c, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_1703: // Incoming jump from 0x1702, if not !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @1703 returndata.length // @1707 returndata[0x00:0x00 + returndata.length] // @1708 returndata.length // @170B memory[0x00:0x00 + returndata.length] // } 1703 3D RETURNDATASIZE 1704 60 PUSH1 0x00 1706 80 DUP1 1707 3E RETURNDATACOPY 1708 3D RETURNDATASIZE 1709 60 PUSH1 0x00 170B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1707 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @170B revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_170C: // Incoming jump from 0x1702, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa4 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @1713 memory[0x40:0x60] // @1714 returndata.length // } 170C 5B JUMPDEST 170D 50 POP 170E 50 POP 170F 50 POP 1710 50 POP 1711 60 PUSH1 0x40 1713 51 MLOAD 1714 3D RETURNDATASIZE 1715 60 PUSH1 0x1f 1717 19 NOT 1718 60 PUSH1 0x1f 171A 82 DUP3 171B 01 ADD 171C 16 AND 171D 82 DUP3 171E 01 ADD 171F 80 DUP1 1720 60 PUSH1 0x40 1722 52 MSTORE 1723 50 POP 1724 81 DUP2 1725 01 ADD 1726 90 SWAP1 1727 61 PUSH2 0x1730 172A 91 SWAP2 172B 90 SWAP1 172C 61 PUSH2 0x289f 172F 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1722 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @172A stack[-4] = 0x1730 // @172B stack[-2] = memory[0x40:0x60] // @172B stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x289f, returns to 0x1730 label_1730: // Incoming return from call to 0x289F at 0x172F // Inputs[4] // { // @1734 storage[0x03] // @1740 memory[0x40:0x60] // @1741 stack[-1] // @1742 stack[-2] // } 1730 5B JUMPDEST 1731 60 PUSH1 0x03 1733 80 DUP1 1734 54 SLOAD 1735 60 PUSH1 0xff 1737 19 NOT 1738 16 AND 1739 60 PUSH1 0x01 173B 17 OR 173C 90 SWAP1 173D 55 SSTORE 173E 60 PUSH1 0x40 1740 51 MLOAD 1741 90 SWAP1 1742 91 SWAP2 1743 50 POP 1744 7F PUSH32 0x9ac10fb18c93d33ad7b0a941897aef048d0f8d30756684e82b4552ba12764d45 1765 90 SWAP1 1766 61 PUSH2 0x1772 1769 90 SWAP1 176A 83 DUP4 176B 81 DUP2 176C 52 MSTORE 176D 60 PUSH1 0x20 176F 01 ADD 1770 90 SWAP1 1771 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @173D storage[0x03] = 0x01 | (~0xff & storage[0x03]) // @1742 stack[-2] = stack[-1] // @1765 stack[-1] = 0x9ac10fb18c93d33ad7b0a941897aef048d0f8d30756684e82b4552ba12764d45 // @176C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1770 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1772 label_1772: // Incoming jump from 0x1771 // Inputs[5] // { // @1775 memory[0x40:0x60] // @1777 stack[-1] // @177A stack[-2] // @177A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @177C stack[-4] // } 1772 5B JUMPDEST 1773 60 PUSH1 0x40 1775 51 MLOAD 1776 80 DUP1 1777 91 SWAP2 1778 03 SUB 1779 90 SWAP1 177A A1 LOG1 177B 50 POP 177C 56 *JUMP // Stack delta = -4 // Outputs[1] { @177A log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2]]); } // Block ends with unconditional jump to stack[-4] label_177D: // Incoming jump from 0x0C9F // Inputs[2] // { // @1781 msg.sender // @1782 stack[-2] // } 177D 5B JUMPDEST 177E 61 PUSH2 0x1787 1781 33 CALLER 1782 83 DUP4 1783 61 PUSH2 0x1a56 1786 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @177E stack[0] = 0x1787 // @1781 stack[1] = msg.sender // @1782 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x1a56 1787 5B JUMPDEST 1788 61 PUSH2 0x17f9 178B 57 *JUMPI 178C 60 PUSH1 0x40 178E 51 MLOAD 178F 62 PUSH3 0x461bcd 1793 60 PUSH1 0xe5 1795 1B SHL 1796 81 DUP2 1797 52 MSTORE 1798 60 PUSH1 0x20 179A 60 PUSH1 0x04 179C 82 DUP3 179D 01 ADD 179E 52 MSTORE 179F 60 PUSH1 0x34 17A1 60 PUSH1 0x24 17A3 82 DUP3 17A4 01 ADD 17A5 52 MSTORE 17A6 7F PUSH32 0x4552433732315073693a207472616e736665722063616c6c6572206973206e6f 17C7 60 PUSH1 0x44 17C9 82 DUP3 17CA 01 ADD 17CB 52 MSTORE 17CC 7F PUSH32 0x74206f776e6572206e6f7220617070726f766564000000000000000000000000 17ED 60 PUSH1 0x64 17EF 82 DUP3 17F0 01 ADD 17F1 52 MSTORE 17F2 60 PUSH1 0x84 17F4 01 ADD 17F5 61 PUSH2 0x05c4 17F8 56 *JUMP 17F9 5B JUMPDEST 17FA 61 PUSH2 0x06e4 17FD 84 DUP5 17FE 84 DUP5 17FF 84 DUP5 1800 84 DUP5 1801 61 PUSH2 0x1d9a 1804 56 *JUMP label_1805: // Incoming call from 0x0DC6, returns to 0x0DC7 // Inputs[1] { @1808 stack[-1] } 1805 5B JUMPDEST 1806 60 PUSH1 0x60 1808 81 DUP2 1809 60 PUSH1 0x00 180B 03 SUB 180C 61 PUSH2 0x1848 180F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1806 stack[0] = 0x60 } // Block ends with conditional jump to 0x1848, if 0x00 - stack[-1] label_1810: // Incoming jump from 0x180F, if not 0x00 - stack[-1] // Inputs[2] // { // @1815 memory[0x40:0x60] // @1846 stack[-3] // } 1810 50 POP 1811 50 POP 1812 60 PUSH1 0x40 1814 80 DUP1 1815 51 MLOAD 1816 80 DUP1 1817 82 DUP3 1818 01 ADD 1819 90 SWAP1 181A 91 SWAP2 181B 52 MSTORE 181C 60 PUSH1 0x01 181E 81 DUP2 181F 52 MSTORE 1820 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 1841 60 PUSH1 0x20 1843 82 DUP3 1844 01 ADD 1845 52 MSTORE 1846 90 SWAP1 1847 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @181B memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @181F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1845 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @1846 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1848: // Incoming jump from 0x180F, if 0x00 - stack[-1] // Inputs[1] { @1849 stack[-2] } 1848 5B JUMPDEST 1849 81 DUP2 184A 60 PUSH1 0x00 184C 5B JUMPDEST 184D 81 DUP2 184E 15 ISZERO 184F 61 PUSH2 0x1872 1852 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1849 stack[0] = stack[-2] // @184A stack[1] = 0x00 // } // Block ends with conditional jump to 0x1872, if !stack[-2] label_1853: // Incoming jump from 0x1852, if not !stack[-2] // Incoming jump from 0x1852, if not !stack[-2] // Inputs[1] { @1853 stack[-1] } 1853 80 DUP1 1854 61 PUSH2 0x185c 1857 81 DUP2 1858 61 PUSH2 0x26ad 185B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1853 stack[0] = stack[-1] // @1854 stack[1] = 0x185c // @1857 stack[2] = stack[-1] // } // Block ends with call to 0x26ad, returns to 0x185C label_185C: // Incoming return from call to 0x26AD at 0x185B // Inputs[4] // { // @185D stack[-1] // @185D stack[-3] // @1862 stack[-2] // @1866 stack[-4] // } 185C 5B JUMPDEST 185D 91 SWAP2 185E 50 POP 185F 61 PUSH2 0x186b 1862 90 SWAP1 1863 50 POP 1864 60 PUSH1 0x0a 1866 83 DUP4 1867 61 PUSH2 0x28ce 186A 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @185D stack[-3] = stack[-1] // @1862 stack[-2] = 0x186b // @1864 stack[-1] = 0x0a // @1866 stack[0] = stack[-4] // } // Block ends with call to 0x28ce, returns to 0x186B label_186B: // Incoming return from call to 0x28CE at 0x186A // Inputs[2] // { // @186C stack[-1] // @186C stack[-3] // } 186B 5B JUMPDEST 186C 91 SWAP2 186D 50 POP 186E 61 PUSH2 0x184c 1871 56 *JUMP // Stack delta = -1 // Outputs[1] { @186C stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x184c label_1872: // Incoming jump from 0x1852, if !stack[-2] // Incoming jump from 0x1852, if !stack[-2] // Inputs[1] { @1875 stack[-1] } 1872 5B JUMPDEST 1873 60 PUSH1 0x00 1875 81 DUP2 1876 67 PUSH8 0xffffffffffffffff 187F 81 DUP2 1880 11 GT 1881 15 ISZERO 1882 61 PUSH2 0x188d 1885 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1873 stack[0] = 0x00 // @1875 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x188d, if !(stack[-1] > 0xffffffffffffffff) label_1886: // Incoming jump from 0x1885, if not !(stack[-1] > 0xffffffffffffffff) 1886 61 PUSH2 0x188d 1889 61 PUSH2 0x23b0 188C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1886 stack[0] = 0x188d } // Block ends with unconditional jump to 0x23b0 label_188D: // Incoming jump from 0x1885, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1890 memory[0x40:0x60] // @1891 stack[-1] // } 188D 5B JUMPDEST 188E 60 PUSH1 0x40 1890 51 MLOAD 1891 90 SWAP1 1892 80 DUP1 1893 82 DUP3 1894 52 MSTORE 1895 80 DUP1 1896 60 PUSH1 0x1f 1898 01 ADD 1899 60 PUSH1 0x1f 189B 19 NOT 189C 16 AND 189D 60 PUSH1 0x20 189F 01 ADD 18A0 82 DUP3 18A1 01 ADD 18A2 60 PUSH1 0x40 18A4 52 MSTORE 18A5 80 DUP1 18A6 15 ISZERO 18A7 61 PUSH2 0x18b7 18AA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1891 stack[-1] = memory[0x40:0x60] // @1891 stack[0] = stack[-1] // @1894 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @18A4 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x18b7, if !stack[-1] label_18AB: // Incoming jump from 0x18AA, if not !stack[-1] // Inputs[6] // { // @18AD stack[-2] // @18AF stack[-1] // @18B1 msg.data.length // @18B3 msg.data[msg.data.length:msg.data.length + stack[-1]] // @18B9 stack[-3] // @18BC stack[-7] // } 18AB 60 PUSH1 0x20 18AD 82 DUP3 18AE 01 ADD 18AF 81 DUP2 18B0 80 DUP1 18B1 36 CALLDATASIZE 18B2 83 DUP4 18B3 37 CALLDATACOPY 18B4 01 ADD 18B5 90 SWAP1 18B6 50 POP 18B7 5B JUMPDEST 18B8 50 POP 18B9 90 SWAP1 18BA 50 POP 18BB 5B JUMPDEST 18BC 84 DUP5 18BD 15 ISZERO 18BE 61 PUSH2 0x193a 18C1 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @18B3 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @18B9 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x193a, if !stack[-7] label_18C2: // Incoming jump from 0x18C1, if not !stack[-5] // Incoming jump from 0x18C1, if not !stack[-7] // Incoming jump from 0x18C1, if not !stack[-7] // Inputs[1] { @18C7 stack[-2] } 18C2 61 PUSH2 0x18cc 18C5 60 PUSH1 0x01 18C7 83 DUP4 18C8 61 PUSH2 0x269a 18CB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18C2 stack[0] = 0x18cc // @18C5 stack[1] = 0x01 // @18C7 stack[2] = stack[-2] // } // Block ends with call to 0x269a, returns to 0x18CC label_18CC: // Incoming return from call to 0x269A at 0x18CB // Inputs[3] // { // @18CD stack[-3] // @18CD stack[-1] // @18D4 stack[-6] // } 18CC 5B JUMPDEST 18CD 91 SWAP2 18CE 50 POP 18CF 61 PUSH2 0x18d9 18D2 60 PUSH1 0x0a 18D4 86 DUP7 18D5 61 PUSH2 0x28e2 18D8 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @18CD stack[-3] = stack[-1] // @18CF stack[-1] = 0x18d9 // @18D2 stack[0] = 0x0a // @18D4 stack[1] = stack[-6] // } // Block ends with call to 0x28e2, returns to 0x18D9 label_18D9: // Incoming return from call to 0x28E2 at 0x18D8 // Inputs[1] { @18DD stack[-1] } 18D9 5B JUMPDEST 18DA 61 PUSH2 0x18e4 18DD 90 SWAP1 18DE 60 PUSH1 0x30 18E0 61 PUSH2 0x2770 18E3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18DD stack[0] = stack[-1] // @18DD stack[-1] = 0x18e4 // @18DE stack[1] = 0x30 // } // Block ends with call to 0x2770, returns to 0x18E4 label_18E4: // Incoming return from call to 0x2770 at 0x18E3 // Inputs[4] // { // @18E7 stack[-1] // @18E8 stack[-2] // @18E9 stack[-3] // @18EB memory[stack[-2]:stack[-2] + 0x20] // } 18E4 5B JUMPDEST 18E5 60 PUSH1 0xf8 18E7 1B SHL 18E8 81 DUP2 18E9 83 DUP4 18EA 81 DUP2 18EB 51 MLOAD 18EC 81 DUP2 18ED 10 LT 18EE 61 PUSH2 0x18f9 18F1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @18E7 stack[-1] = stack[-1] << 0xf8 // @18E8 stack[0] = stack[-2] // @18E9 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x18f9, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_18F2: // Incoming jump from 0x18F1, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] 18F2 61 PUSH2 0x18f9 18F5 61 PUSH2 0x2889 18F8 56 *JUMP // Stack delta = +1 // Outputs[1] { @18F2 stack[0] = 0x18f9 } // Block ends with unconditional jump to 0x2889 label_18F9: // Incoming jump from 0x18F1, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @18FC stack[-1] // @18FD stack[-2] // @18FE stack[-3] // @192E stack[-8] // } 18F9 5B JUMPDEST 18FA 60 PUSH1 0x20 18FC 01 ADD 18FD 01 ADD 18FE 90 SWAP1 18FF 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 191F 19 NOT 1920 16 AND 1921 90 SWAP1 1922 81 DUP2 1923 60 PUSH1 0x00 1925 1A BYTE 1926 90 SWAP1 1927 53 MSTORE8 1928 50 POP 1929 61 PUSH2 0x1933 192C 60 PUSH1 0x0a 192E 86 DUP7 192F 61 PUSH2 0x28ce 1932 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1927 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @1929 stack[-3] = 0x1933 // @192C stack[-2] = 0x0a // @192E stack[-1] = stack[-8] // } // Block ends with call to 0x28ce, returns to 0x1933 label_1933: // Incoming return from call to 0x28CE at 0x1932 // Inputs[2] // { // @1934 stack[-1] // @1934 stack[-6] // } 1933 5B JUMPDEST 1934 94 SWAP5 1935 50 POP 1936 61 PUSH2 0x18bb 1939 56 *JUMP // Stack delta = -1 // Outputs[1] { @1934 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x18bb label_193A: // Incoming jump from 0x18C1, if !stack[-5] // Incoming jump from 0x18C1, if !stack[-7] // Incoming jump from 0x18C1, if !stack[-7] // Inputs[3] // { // @193B stack[-1] // @193B stack[-6] // @193C stack[-5] // } 193A 5B JUMPDEST 193B 94 SWAP5 193C 93 SWAP4 193D 50 POP 193E 50 POP 193F 50 POP 1940 50 POP 1941 56 *JUMP // Stack delta = -5 // Outputs[1] { @193B stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1942: // Incoming jump from 0x0E15 // Inputs[3] // { // @1945 stack[-1] // @1946 stack[-3] // @194A memory[0x40:0x60] // } 1942 5B JUMPDEST 1943 60 PUSH1 0x00 1945 81 DUP2 1946 84 DUP5 1947 10 LT 1948 60 PUSH1 0x40 194A 51 MLOAD 194B 80 DUP1 194C 60 PUSH1 0x40 194E 01 ADD 194F 60 PUSH1 0x40 1951 52 MSTORE 1952 80 DUP1 1953 60 PUSH1 0x1e 1955 81 DUP2 1956 52 MSTORE 1957 60 PUSH1 0x20 1959 01 ADD 195A 7F PUSH32 0x696e707574206973206e6f742077697468696e2074686520646f6d61696e0000 197B 81 DUP2 197C 52 MSTORE 197D 50 POP 197E 90 SWAP1 197F 61 PUSH2 0x199b 1982 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @1943 stack[0] = 0x00 // @1951 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1956 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x1e // @197C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x696e707574206973206e6f742077697468696e2074686520646f6d61696e0000 // @197E stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x199b, if stack[-3] < stack[-1] label_1983: // Incoming jump from 0x1982, if not stack[-3] < stack[-1] // Inputs[2] // { // @1985 memory[0x40:0x60] // @1995 stack[-1] // } 1983 60 PUSH1 0x40 1985 51 MLOAD 1986 62 PUSH3 0x461bcd 198A 60 PUSH1 0xe5 198C 1B SHL 198D 81 DUP2 198E 52 MSTORE 198F 60 PUSH1 0x04 1991 01 ADD 1992 61 PUSH2 0x05c4 1995 91 SWAP2 1996 90 SWAP1 1997 61 PUSH2 0x2343 199A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @198E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1995 stack[-1] = 0x05c4 // @1996 stack[1] = 0x04 + memory[0x40:0x60] // @1996 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x2343 label_199B: // Incoming jump from 0x1982, if stack[-3] < stack[-1] // Inputs[1] { @19A2 stack[-3] } 199B 5B JUMPDEST 199C 50 POP 199D 60 PUSH1 0x00 199F 61 PUSH2 0x19a7 19A2 83 DUP4 19A3 61 PUSH2 0x1e25 19A6 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @199D stack[-1] = 0x00 // @199F stack[0] = 0x19a7 // @19A2 stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x1e25 19A7 5B JUMPDEST 19A8 60 PUSH1 0x01 19AA 01 ADD 19AB 60 PUSH1 0xff 19AD 16 AND 19AE 90 SWAP1 19AF 50 POP 19B0 5B JUMPDEST 19B1 61 PUSH2 0x19bd 19B4 85 DUP6 19B5 85 DUP6 19B6 60 PUSH1 0x03 19B8 84 DUP5 19B9 61 PUSH2 0x1e8f 19BC 56 *JUMP 19BD 5B JUMPDEST 19BE 91 SWAP2 19BF 50 POP 19C0 82 DUP3 19C1 82 DUP3 19C2 10 LT 19C3 61 PUSH2 0x09b6 19C6 57 *JUMPI 19C7 81 DUP2 19C8 94 SWAP5 19C9 50 POP 19CA 61 PUSH2 0x19b0 19CD 56 *JUMP 19CE 5B JUMPDEST 19CF 60 PUSH1 0x00 19D1 81 DUP2 19D2 81 DUP2 19D3 52 MSTORE 19D4 60 PUSH1 0x0a 19D6 60 PUSH1 0x20 19D8 52 MSTORE 19D9 60 PUSH1 0x40 19DB 90 SWAP1 19DC 20 SHA3 19DD 80 DUP1 19DE 54 SLOAD 19DF 60 PUSH1 0x01 19E1 60 PUSH1 0x01 19E3 60 PUSH1 0xa0 19E5 1B SHL 19E6 03 SUB 19E7 19 NOT 19E8 16 AND 19E9 60 PUSH1 0x01 19EB 60 PUSH1 0x01 19ED 60 PUSH1 0xa0 19EF 1B SHL 19F0 03 SUB 19F1 84 DUP5 19F2 16 AND 19F3 90 SWAP1 19F4 81 DUP2 19F5 17 OR 19F6 90 SWAP1 19F7 91 SWAP2 19F8 55 SSTORE 19F9 81 DUP2 19FA 90 SWAP1 19FB 61 PUSH2 0x1a03 19FE 82 DUP3 19FF 61 PUSH2 0x09aa 1A02 56 *JUMP 1A03 5B JUMPDEST 1A04 60 PUSH1 0x01 1A06 60 PUSH1 0x01 1A08 60 PUSH1 0xa0 1A0A 1B SHL 1A0B 03 SUB 1A0C 16 AND 1A0D 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1A2E 60 PUSH1 0x40 1A30 51 MLOAD 1A31 60 PUSH1 0x40 1A33 51 MLOAD 1A34 80 DUP1 1A35 91 SWAP2 1A36 03 SUB 1A37 90 SWAP1 1A38 A4 LOG4 1A39 50 POP 1A3A 50 POP 1A3B 56 *JUMP label_1A3C: // Incoming call from 0x111B, returns to 0x111C // Inputs[1] { @1A40 stack[-1] } 1A3C 5B JUMPDEST 1A3D 60 PUSH1 0x00 1A3F 5B JUMPDEST 1A40 81 DUP2 1A41 15 ISZERO 1A42 61 PUSH2 0x0e1b 1A45 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A3D stack[0] = 0x00 } // Block ends with conditional jump to 0x0e1b, if !stack[-1] label_1A46: // Incoming jump from 0x1A45, if not !stack[-1] // Incoming jump from 0x1A45, if not !stack[-2] // Inputs[2] // { // @1A49 stack[-2] // @1A4B stack[-1] // } 1A46 60 PUSH1 0x00 1A48 19 NOT 1A49 82 DUP3 1A4A 01 ADD 1A4B 90 SWAP1 1A4C 91 SWAP2 1A4D 16 AND 1A4E 90 SWAP1 1A4F 60 PUSH1 0x01 1A51 01 ADD 1A52 61 PUSH2 0x1a3f 1A55 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1A4E stack[-2] = stack[-2] & stack[-2] + ~0x00 // @1A51 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1a3f label_1A56: // Incoming jump from 0x1786 // Incoming jump from 0x1179 // Inputs[1] { @1A5C stack[-1] } 1A56 5B JUMPDEST 1A57 60 PUSH1 0x00 1A59 61 PUSH2 0x1a61 1A5C 82 DUP3 1A5D 61 PUSH2 0x0ead 1A60 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1A57 stack[0] = 0x00 // @1A59 stack[1] = 0x1a61 // @1A5C stack[2] = stack[-1] // } // Block ends with call to 0x0ead, returns to 0x1A61 label_1A61: // Incoming return from call to 0x0EAD at 0x1A60 // Inputs[1] { @1A65 stack[-1] } 1A61 5B JUMPDEST 1A62 61 PUSH2 0x1ad3 1A65 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1ad3, if stack[-1] label_1A66: // Incoming jump from 0x1A65, if not stack[-1] // Inputs[1] { @1A68 memory[0x40:0x60] } 1A66 60 PUSH1 0x40 1A68 51 MLOAD 1A69 62 PUSH3 0x461bcd 1A6D 60 PUSH1 0xe5 1A6F 1B SHL 1A70 81 DUP2 1A71 52 MSTORE 1A72 60 PUSH1 0x20 1A74 60 PUSH1 0x04 1A76 82 DUP3 1A77 01 ADD 1A78 52 MSTORE 1A79 60 PUSH1 0x2f 1A7B 60 PUSH1 0x24 1A7D 82 DUP3 1A7E 01 ADD 1A7F 52 MSTORE 1A80 7F PUSH32 0x4552433732315073693a206f70657261746f7220717565727920666f72206e6f 1AA1 60 PUSH1 0x44 1AA3 82 DUP3 1AA4 01 ADD 1AA5 52 MSTORE 1AA6 7F PUSH32 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 1AC7 60 PUSH1 0x64 1AC9 82 DUP3 1ACA 01 ADD 1ACB 52 MSTORE 1ACC 60 PUSH1 0x84 1ACE 01 ADD 1ACF 61 PUSH2 0x05c4 1AD2 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1A71 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1A78 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1A7F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @1AA5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732315073693a206f70657261746f7220717565727920666f72206e6f // @1ACB memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6578697374656e7420746f6b656e0000000000000000000000000000000000 // @1ACE stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_1AD3: // Incoming jump from 0x1A65, if stack[-1] // Inputs[1] { @1AD9 stack[-2] } 1AD3 5B JUMPDEST 1AD4 60 PUSH1 0x00 1AD6 61 PUSH2 0x1ade 1AD9 83 DUP4 1ADA 61 PUSH2 0x09aa 1ADD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1AD4 stack[0] = 0x00 // @1AD6 stack[1] = 0x1ade // @1AD9 stack[2] = stack[-2] // } // Block ends with unconditional jump to 0x09aa 1ADE 5B JUMPDEST 1ADF 90 SWAP1 1AE0 50 POP 1AE1 80 DUP1 1AE2 60 PUSH1 0x01 1AE4 60 PUSH1 0x01 1AE6 60 PUSH1 0xa0 1AE8 1B SHL 1AE9 03 SUB 1AEA 16 AND 1AEB 84 DUP5 1AEC 60 PUSH1 0x01 1AEE 60 PUSH1 0x01 1AF0 60 PUSH1 0xa0 1AF2 1B SHL 1AF3 03 SUB 1AF4 16 AND 1AF5 14 EQ 1AF6 80 DUP1 1AF7 61 PUSH2 0x1b19 1AFA 57 *JUMPI 1AFB 50 POP 1AFC 83 DUP4 1AFD 60 PUSH1 0x01 1AFF 60 PUSH1 0x01 1B01 60 PUSH1 0xa0 1B03 1B SHL 1B04 03 SUB 1B05 16 AND 1B06 61 PUSH2 0x1b0e 1B09 84 DUP5 1B0A 61 PUSH2 0x054b 1B0D 56 *JUMP 1B0E 5B JUMPDEST 1B0F 60 PUSH1 0x01 1B11 60 PUSH1 0x01 1B13 60 PUSH1 0xa0 1B15 1B SHL 1B16 03 SUB 1B17 16 AND 1B18 14 EQ 1B19 5B JUMPDEST 1B1A 80 DUP1 1B1B 61 PUSH2 0x193a 1B1E 57 *JUMPI 1B1F 50 POP 1B20 60 PUSH1 0x01 1B22 60 PUSH1 0x01 1B24 60 PUSH1 0xa0 1B26 1B SHL 1B27 03 SUB 1B28 80 DUP1 1B29 82 DUP3 1B2A 16 AND 1B2B 60 PUSH1 0x00 1B2D 90 SWAP1 1B2E 81 DUP2 1B2F 52 MSTORE 1B30 60 PUSH1 0x0b 1B32 60 PUSH1 0x20 1B34 90 SWAP1 1B35 81 DUP2 1B36 52 MSTORE 1B37 60 PUSH1 0x40 1B39 80 DUP1 1B3A 83 DUP4 1B3B 20 SHA3 1B3C 93 SWAP4 1B3D 88 DUP9 1B3E 16 AND 1B3F 83 DUP4 1B40 52 MSTORE 1B41 92 SWAP3 1B42 90 SWAP1 1B43 52 MSTORE 1B44 20 SHA3 1B45 54 SLOAD 1B46 60 PUSH1 0xff 1B48 16 AND 1B49 61 PUSH2 0x193a 1B4C 56 *JUMP 1B4D 5B JUMPDEST 1B4E 60 PUSH1 0x00 1B50 80 DUP1 1B51 61 PUSH2 0x1b59 1B54 83 DUP4 1B55 61 PUSH2 0x127a 1B58 56 *JUMP 1B59 5B JUMPDEST 1B5A 91 SWAP2 1B5B 50 POP 1B5C 91 SWAP2 1B5D 50 POP 1B5E 84 DUP5 1B5F 60 PUSH1 0x01 1B61 60 PUSH1 0x01 1B63 60 PUSH1 0xa0 1B65 1B SHL 1B66 03 SUB 1B67 16 AND 1B68 82 DUP3 1B69 60 PUSH1 0x01 1B6B 60 PUSH1 0x01 1B6D 60 PUSH1 0xa0 1B6F 1B SHL 1B70 03 SUB 1B71 16 AND 1B72 14 EQ 1B73 61 PUSH2 0x1be4 1B76 57 *JUMPI 1B77 60 PUSH1 0x40 1B79 51 MLOAD 1B7A 62 PUSH3 0x461bcd 1B7E 60 PUSH1 0xe5 1B80 1B SHL 1B81 81 DUP2 1B82 52 MSTORE 1B83 60 PUSH1 0x20 1B85 60 PUSH1 0x04 1B87 82 DUP3 1B88 01 ADD 1B89 52 MSTORE 1B8A 60 PUSH1 0x2c 1B8C 60 PUSH1 0x24 1B8E 82 DUP3 1B8F 01 ADD 1B90 52 MSTORE 1B91 7F PUSH32 0x4552433732315073693a207472616e73666572206f6620746f6b656e20746861 1BB2 60 PUSH1 0x44 1BB4 82 DUP3 1BB5 01 ADD 1BB6 52 MSTORE 1BB7 7F PUSH32 0x74206973206e6f74206f776e0000000000000000000000000000000000000000 1BD8 60 PUSH1 0x64 1BDA 82 DUP3 1BDB 01 ADD 1BDC 52 MSTORE 1BDD 60 PUSH1 0x84 1BDF 01 ADD 1BE0 61 PUSH2 0x05c4 1BE3 56 *JUMP 1BE4 5B JUMPDEST 1BE5 60 PUSH1 0x01 1BE7 60 PUSH1 0x01 1BE9 60 PUSH1 0xa0 1BEB 1B SHL 1BEC 03 SUB 1BED 84 DUP5 1BEE 16 AND 1BEF 61 PUSH2 0x1c60 1BF2 57 *JUMPI 1BF3 60 PUSH1 0x40 1BF5 51 MLOAD 1BF6 62 PUSH3 0x461bcd 1BFA 60 PUSH1 0xe5 1BFC 1B SHL 1BFD 81 DUP2 1BFE 52 MSTORE 1BFF 60 PUSH1 0x20 1C01 60 PUSH1 0x04 1C03 82 DUP3 1C04 01 ADD 1C05 52 MSTORE 1C06 60 PUSH1 0x27 1C08 60 PUSH1 0x24 1C0A 82 DUP3 1C0B 01 ADD 1C0C 52 MSTORE 1C0D 7F PUSH32 0x4552433732315073693a207472616e7366657220746f20746865207a65726f20 1C2E 60 PUSH1 0x44 1C30 82 DUP3 1C31 01 ADD 1C32 52 MSTORE 1C33 7F PUSH32 0x6164647265737300000000000000000000000000000000000000000000000000 1C54 60 PUSH1 0x64 1C56 82 DUP3 1C57 01 ADD 1C58 52 MSTORE 1C59 60 PUSH1 0x84 1C5B 01 ADD 1C5C 61 PUSH2 0x05c4 1C5F 56 *JUMP 1C60 5B JUMPDEST 1C61 61 PUSH2 0x1c6b 1C64 60 PUSH1 0x00 1C66 84 DUP5 1C67 61 PUSH2 0x19ce 1C6A 56 *JUMP 1C6B 5B JUMPDEST 1C6C 60 PUSH1 0x00 1C6E 61 PUSH2 0x1c78 1C71 84 DUP5 1C72 60 PUSH1 0x01 1C74 61 PUSH2 0x2770 1C77 56 *JUMP 1C78 5B JUMPDEST 1C79 60 PUSH1 0x08 1C7B 81 DUP2 1C7C 90 SWAP1 1C7D 1C SHR 1C7E 60 PUSH1 0x00 1C80 90 SWAP1 1C81 81 DUP2 1C82 52 MSTORE 1C83 60 PUSH1 0x05 1C85 60 PUSH1 0x20 1C87 52 MSTORE 1C88 60 PUSH1 0x40 1C8A 90 SWAP1 1C8B 20 SHA3 1C8C 54 SLOAD 1C8D 90 SWAP1 1C8E 91 SWAP2 1C8F 50 POP 1C90 60 PUSH1 0x01 1C92 60 PUSH1 0xff 1C94 1B SHL 1C95 60 PUSH1 0xff 1C97 83 DUP4 1C98 16 AND 1C99 1C SHR 1C9A 16 AND 1C9B 15 ISZERO 1C9C 80 DUP1 1C9D 15 ISZERO 1C9E 61 PUSH2 0x1ca8 1CA1 57 *JUMPI 1CA2 50 POP 1CA3 60 PUSH1 0x09 1CA5 54 SLOAD 1CA6 81 DUP2 1CA7 10 LT 1CA8 5B JUMPDEST 1CA9 15 ISZERO 1CAA 61 PUSH2 0x1cf3 1CAD 57 *JUMPI 1CAE 60 PUSH1 0x00 1CB0 81 DUP2 1CB1 81 DUP2 1CB2 52 MSTORE 1CB3 60 PUSH1 0x08 1CB5 60 PUSH1 0x20 1CB7 81 DUP2 1CB8 81 DUP2 1CB9 52 MSTORE 1CBA 60 PUSH1 0x40 1CBC 80 DUP1 1CBD 84 DUP5 1CBE 20 SHA3 1CBF 80 DUP1 1CC0 54 SLOAD 1CC1 60 PUSH1 0x01 1CC3 60 PUSH1 0x01 1CC5 60 PUSH1 0xa0 1CC7 1B SHL 1CC8 03 SUB 1CC9 19 NOT 1CCA 16 AND 1CCB 60 PUSH1 0x01 1CCD 60 PUSH1 0x01 1CCF 60 PUSH1 0xa0 1CD1 1B SHL 1CD2 03 SUB 1CD3 8C DUP13 1CD4 16 AND 1CD5 17 OR 1CD6 90 SWAP1 1CD7 55 SSTORE 1CD8 91 SWAP2 1CD9 84 DUP5 1CDA 90 SWAP1 1CDB 1C SHR 1CDC 83 DUP4 1CDD 52 MSTORE 1CDE 60 PUSH1 0x05 1CE0 90 SWAP1 1CE1 52 MSTORE 1CE2 90 SWAP1 1CE3 20 SHA3 1CE4 80 DUP1 1CE5 54 SLOAD 1CE6 60 PUSH1 0x01 1CE8 60 PUSH1 0xff 1CEA 1B SHL 1CEB 60 PUSH1 0xff 1CED 84 DUP5 1CEE 16 AND 1CEF 1C SHR 1CF0 17 OR 1CF1 90 SWAP1 1CF2 55 SSTORE 1CF3 5B JUMPDEST 1CF4 60 PUSH1 0x00 1CF6 84 DUP5 1CF7 81 DUP2 1CF8 52 MSTORE 1CF9 60 PUSH1 0x08 1CFB 60 PUSH1 0x20 1CFD 52 MSTORE 1CFE 60 PUSH1 0x40 1D00 90 SWAP1 1D01 20 SHA3 1D02 80 DUP1 1D03 54 SLOAD 1D04 60 PUSH1 0x01 1D06 60 PUSH1 0x01 1D08 60 PUSH1 0xa0 1D0A 1B SHL 1D0B 03 SUB 1D0C 19 NOT 1D0D 16 AND 1D0E 60 PUSH1 0x01 1D10 60 PUSH1 0x01 1D12 60 PUSH1 0xa0 1D14 1B SHL 1D15 03 SUB 1D16 87 DUP8 1D17 16 AND 1D18 17 OR 1D19 90 SWAP1 1D1A 55 SSTORE 1D1B 81 DUP2 1D1C 84 DUP5 1D1D 14 EQ 1D1E 61 PUSH2 0x1d44 1D21 57 *JUMPI 1D22 60 PUSH1 0x08 1D24 84 DUP5 1D25 90 SWAP1 1D26 1C SHR 1D27 60 PUSH1 0x00 1D29 90 SWAP1 1D2A 81 DUP2 1D2B 52 MSTORE 1D2C 60 PUSH1 0x05 1D2E 60 PUSH1 0x20 1D30 52 MSTORE 1D31 60 PUSH1 0x40 1D33 90 SWAP1 1D34 20 SHA3 1D35 80 DUP1 1D36 54 SLOAD 1D37 60 PUSH1 0x01 1D39 60 PUSH1 0xff 1D3B 1B SHL 1D3C 60 PUSH1 0xff 1D3E 87 DUP8 1D3F 16 AND 1D40 1C SHR 1D41 17 OR 1D42 90 SWAP1 1D43 55 SSTORE 1D44 5B JUMPDEST 1D45 83 DUP4 1D46 85 DUP6 1D47 60 PUSH1 0x01 1D49 60 PUSH1 0x01 1D4B 60 PUSH1 0xa0 1D4D 1B SHL 1D4E 03 SUB 1D4F 16 AND 1D50 87 DUP8 1D51 60 PUSH1 0x01 1D53 60 PUSH1 0x01 1D55 60 PUSH1 0xa0 1D57 1B SHL 1D58 03 SUB 1D59 16 AND 1D5A 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1D7B 60 PUSH1 0x40 1D7D 51 MLOAD 1D7E 60 PUSH1 0x40 1D80 51 MLOAD 1D81 80 DUP1 1D82 91 SWAP2 1D83 03 SUB 1D84 90 SWAP1 1D85 A4 LOG4 1D86 50 POP 1D87 50 POP 1D88 50 POP 1D89 50 POP 1D8A 50 POP 1D8B 50 POP 1D8C 56 *JUMP label_1D8D: // Incoming jump from 0x1300 // Inputs[1] { @1D95 stack[-1] } 1D8D 5B JUMPDEST 1D8E 60 PUSH1 0x00 1D90 61 PUSH2 0x04b3 1D93 60 PUSH1 0x05 1D95 83 DUP4 1D96 61 PUSH2 0x1f88 1D99 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D8E stack[0] = 0x00 // @1D90 stack[1] = 0x04b3 // @1D93 stack[2] = 0x05 // @1D95 stack[3] = stack[-1] // } // Block ends with call to 0x1f88, returns to 0x04B3 1D9A 5B JUMPDEST 1D9B 61 PUSH2 0x1da5 1D9E 84 DUP5 1D9F 84 DUP5 1DA0 84 DUP5 1DA1 61 PUSH2 0x1b4d 1DA4 56 *JUMP 1DA5 5B JUMPDEST 1DA6 61 PUSH2 0x1db3 1DA9 84 DUP5 1DAA 84 DUP5 1DAB 84 DUP5 1DAC 60 PUSH1 0x01 1DAE 85 DUP6 1DAF 61 PUSH2 0x2089 1DB2 56 *JUMP 1DB3 5B JUMPDEST 1DB4 61 PUSH2 0x06e4 1DB7 57 *JUMPI 1DB8 60 PUSH1 0x40 1DBA 51 MLOAD 1DBB 62 PUSH3 0x461bcd 1DBF 60 PUSH1 0xe5 1DC1 1B SHL 1DC2 81 DUP2 1DC3 52 MSTORE 1DC4 60 PUSH1 0x20 1DC6 60 PUSH1 0x04 1DC8 82 DUP3 1DC9 01 ADD 1DCA 52 MSTORE 1DCB 60 PUSH1 0x35 1DCD 60 PUSH1 0x24 1DCF 82 DUP3 1DD0 01 ADD 1DD1 52 MSTORE 1DD2 7F PUSH32 0x4552433732315073693a207472616e7366657220746f206e6f6e204552433732 1DF3 60 PUSH1 0x44 1DF5 82 DUP3 1DF6 01 ADD 1DF7 52 MSTORE 1DF8 7F PUSH32 0x31526563656976657220696d706c656d656e7465720000000000000000000000 1E19 60 PUSH1 0x64 1E1B 82 DUP3 1E1C 01 ADD 1E1D 52 MSTORE 1E1E 60 PUSH1 0x84 1E20 01 ADD 1E21 61 PUSH2 0x05c4 1E24 56 *JUMP label_1E25: // Incoming jump from 0x19A6 // Inputs[2] // { // @1E2A memory[0x40:0x60] // @1E69 stack[-1] // } 1E25 5B JUMPDEST 1E26 60 PUSH1 0x00 1E28 60 PUSH1 0x40 1E2A 51 MLOAD 1E2B 80 DUP1 1E2C 61 PUSH2 0x0120 1E2F 01 ADD 1E30 60 PUSH1 0x40 1E32 52 MSTORE 1E33 80 DUP1 1E34 61 PUSH2 0x0100 1E37 81 DUP2 1E38 52 MSTORE 1E39 60 PUSH1 0x20 1E3B 01 ADD 1E3C 61 PUSH2 0x2950 1E3F 61 PUSH2 0x0100 1E42 91 SWAP2 1E43 39 CODECOPY 1E44 60 PUSH1 0xf8 1E46 7E PUSH31 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff 1E66 61 PUSH2 0x1e6e 1E69 85 DUP6 1E6A 61 PUSH2 0x2216 1E6D 56 *JUMP // Stack delta = +6 // Outputs[9] // { // @1E26 stack[0] = 0x00 // @1E2A stack[1] = memory[0x40:0x60] // @1E32 memory[0x40:0x60] = 0x0120 + memory[0x40:0x60] // @1E38 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100 // @1E43 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x0100] = code[0x2950:0x2a50] // @1E44 stack[2] = 0xf8 // @1E46 stack[3] = 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff // @1E66 stack[4] = 0x1e6e // @1E69 stack[5] = stack[-1] // } // Block ends with call to 0x2216, returns to 0x1E6E label_1E6E: // Incoming return from call to 0x2216 at 0x1E6D // Incoming return from call to 0x22AF at 0x22AA // Inputs[5] // { // @1E6F stack[-1] // @1E6F stack[-2] // @1E70 stack[-3] // @1E72 stack[-4] // @1E73 memory[stack[-4]:stack[-4] + 0x20] // } 1E6E 5B JUMPDEST 1E6F 02 MUL 1E70 90 SWAP1 1E71 1C SHR 1E72 81 DUP2 1E73 51 MLOAD 1E74 81 DUP2 1E75 10 LT 1E76 61 PUSH2 0x1e81 1E79 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1E71 stack[-3] = stack[-1] * stack[-2] >> stack[-3] } // Block ends with conditional jump to 0x1e81, if stack[-1] * stack[-2] >> stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_1E7A: // Incoming jump from 0x1E79, if not stack[-1] * stack[-2] >> stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 1E7A 61 PUSH2 0x1e81 1E7D 61 PUSH2 0x2889 1E80 56 *JUMP // Stack delta = +1 // Outputs[1] { @1E7A stack[0] = 0x1e81 } // Block ends with unconditional jump to 0x2889 label_1E81: // Incoming jump from 0x1E79, if stack[-1] * stack[-2] >> stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @1E82 stack[-2] // @1E82 stack[-1] // @1E86 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] // @1E8A stack[-5] // @1E8B stack[-4] // } 1E81 5B JUMPDEST 1E82 01 ADD 1E83 60 PUSH1 0x20 1E85 01 ADD 1E86 51 MLOAD 1E87 60 PUSH1 0xf8 1E89 1C SHR 1E8A 92 SWAP3 1E8B 91 SWAP2 1E8C 50 POP 1E8D 50 POP 1E8E 56 *JUMP // Stack delta = -4 // Outputs[1] { @1E8A stack[-5] = memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] >> 0xf8 } // Block ends with unconditional jump to stack[-5] 1E8F 5B JUMPDEST 1E90 60 PUSH1 0x00 1E92 60 PUSH1 0x02 1E94 82 DUP3 1E95 04 DIV 1E96 80 DUP1 1E97 83 DUP4 1E98 03 SUB 1E99 60 PUSH1 0x01 1E9B 80 DUP1 1E9C 82 DUP3 1E9D 1B SHL 1E9E 60 PUSH1 0x00 1EA0 19 NOT 1EA1 90 SWAP1 1EA2 81 DUP2 1EA3 01 ADD 1EA4 91 SWAP2 1EA5 84 DUP5 1EA6 1B SHL 1EA7 01 ADD 1EA8 88 DUP9 1EA9 84 DUP5 1EAA 1C SHR 1EAB 82 DUP3 1EAC 16 AND 1EAD 89 DUP10 1EAE 82 DUP3 1EAF 16 AND 1EB0 86 DUP7 1EB1 5B JUMPDEST 1EB2 89 DUP10 1EB3 81 DUP2 1EB4 10 LT 1EB5 15 ISZERO 1EB6 61 PUSH2 0x1f5c 1EB9 57 *JUMPI 1EBA 60 PUSH1 0x40 1EBC 80 DUP1 1EBD 51 MLOAD 1EBE 60 PUSH1 0x20 1EC0 80 DUP1 1EC1 82 DUP3 1EC2 01 ADD 1EC3 8E DUP15 1EC4 90 SWAP1 1EC5 52 MSTORE 1EC6 81 DUP2 1EC7 83 DUP4 1EC8 01 ADD 1EC9 84 DUP5 1ECA 90 SWAP1 1ECB 52 MSTORE 1ECC 82 DUP3 1ECD 51 MLOAD 1ECE 80 DUP1 1ECF 83 DUP4 1ED0 03 SUB 1ED1 84 DUP5 1ED2 01 ADD 1ED3 81 DUP2 1ED4 52 MSTORE 1ED5 60 PUSH1 0x60 1ED7 90 SWAP1 1ED8 92 SWAP3 1ED9 01 ADD 1EDA 90 SWAP1 1EDB 92 SWAP3 1EDC 52 MSTORE 1EDD 80 DUP1 1EDE 51 MLOAD 1EDF 91 SWAP2 1EE0 01 ADD 1EE1 20 SHA3 1EE2 82 DUP3 1EE3 60 PUSH1 0x00 1EE5 60 PUSH1 0x01 1EE7 84 DUP5 1EE8 16 AND 1EE9 81 DUP2 1EEA 03 SUB 1EEB 61 PUSH2 0x1f20 1EEE 57 *JUMPI 1EEF 50 POP 1EF0 60 PUSH1 0x40 1EF2 80 DUP1 1EF3 51 MLOAD 1EF4 60 PUSH1 0x20 1EF6 80 DUP1 1EF7 82 DUP3 1EF8 01 ADD 1EF9 87 DUP8 1EFA 90 SWAP1 1EFB 52 MSTORE 1EFC 81 DUP2 1EFD 83 DUP4 1EFE 01 ADD 1EFF 85 DUP6 1F00 90 SWAP1 1F01 52 MSTORE 1F02 82 DUP3 1F03 51 MLOAD 1F04 80 DUP1 1F05 83 DUP4 1F06 03 SUB 1F07 84 DUP5 1F08 01 ADD 1F09 81 DUP2 1F0A 52 MSTORE 1F0B 60 PUSH1 0x60 1F0D 90 SWAP1 1F0E 92 SWAP3 1F0F 01 ADD 1F10 90 SWAP1 1F11 92 SWAP3 1F12 52 MSTORE 1F13 80 DUP1 1F14 51 MLOAD 1F15 91 SWAP2 1F16 01 ADD 1F17 20 SHA3 1F18 87 DUP8 1F19 16 AND 1F1A 85 DUP6 1F1B 18 XOR 1F1C 61 PUSH2 0x1f4e 1F1F 56 *JUMP 1F20 5B JUMPDEST 1F21 50 POP 1F22 60 PUSH1 0x40 1F24 80 DUP1 1F25 51 MLOAD 1F26 60 PUSH1 0x20 1F28 80 DUP1 1F29 82 DUP3 1F2A 01 ADD 1F2B 87 DUP8 1F2C 90 SWAP1 1F2D 52 MSTORE 1F2E 81 DUP2 1F2F 83 DUP4 1F30 01 ADD 1F31 85 DUP6 1F32 90 SWAP1 1F33 52 MSTORE 1F34 82 DUP3 1F35 51 MLOAD 1F36 80 DUP1 1F37 83 DUP4 1F38 03 SUB 1F39 84 DUP5 1F3A 01 ADD 1F3B 81 DUP2 1F3C 52 MSTORE 1F3D 60 PUSH1 0x60 1F3F 90 SWAP1 1F40 92 SWAP3 1F41 01 ADD 1F42 90 SWAP1 1F43 92 SWAP3 1F44 52 MSTORE 1F45 80 DUP1 1F46 51 MLOAD 1F47 91 SWAP2 1F48 01 ADD 1F49 20 SHA3 1F4A 86 DUP7 1F4B 16 AND 1F4C 85 DUP6 1F4D 18 XOR 1F4E 5B JUMPDEST 1F4F 90 SWAP1 1F50 94 SWAP5 1F51 50 POP 1F52 92 SWAP3 1F53 50 POP 1F54 50 POP 1F55 60 PUSH1 0x01 1F57 01 ADD 1F58 61 PUSH2 0x1eb1 1F5B 56 *JUMP 1F5C 5B JUMPDEST 1F5D 50 POP 1F5E 60 PUSH1 0x02 1F60 89 DUP10 1F61 06 MOD 1F62 60 PUSH1 0x00 1F64 03 SUB 1F65 61 PUSH2 0x1f78 1F68 57 *JUMPI 1F69 94 SWAP5 1F6A 1B SHL 1F6B 90 SWAP1 1F6C 93 SWAP4 1F6D 17 OR 1F6E 93 SWAP4 1F6F 50 POP 1F70 61 PUSH2 0x193a 1F73 92 SWAP3 1F74 50 POP 1F75 50 POP 1F76 50 POP 1F77 56 *JUMP 1F78 5B JUMPDEST 1F79 93 SWAP4 1F7A 1B SHL 1F7B 90 SWAP1 1F7C 92 SWAP3 1F7D 17 OR 1F7E 93 SWAP4 1F7F 50 POP 1F80 61 PUSH2 0x193a 1F83 92 SWAP3 1F84 50 POP 1F85 50 POP 1F86 50 POP 1F87 56 *JUMP label_1F88: // Incoming call from 0x1D99, returns to 0x04B3 // Inputs[4] // { // @1F8B stack[-1] // @1F95 stack[-2] // @1F9B memory[0x00:0x40] // @1F9C storage[keccak256(memory[0x00:0x40])] // } 1F88 5B JUMPDEST 1F89 60 PUSH1 0x08 1F8B 81 DUP2 1F8C 90 SWAP1 1F8D 1C SHR 1F8E 60 PUSH1 0x00 1F90 81 DUP2 1F91 81 DUP2 1F92 52 MSTORE 1F93 60 PUSH1 0x20 1F95 84 DUP5 1F96 90 SWAP1 1F97 52 MSTORE 1F98 60 PUSH1 0x40 1F9A 81 DUP2 1F9B 20 SHA3 1F9C 54 SLOAD 1F9D 90 SWAP1 1F9E 91 SWAP2 1F9F 90 SWAP1 1FA0 60 PUSH1 0xff 1FA2 80 DUP1 1FA3 85 DUP6 1FA4 16 AND 1FA5 91 SWAP2 1FA6 90 SWAP1 1FA7 82 DUP3 1FA8 18 XOR 1FA9 1C SHR 1FAA 80 DUP1 1FAB 15 ISZERO 1FAC 61 PUSH2 0x1fca 1FAF 57 *JUMPI // Stack delta = +4 // Outputs[6] // { // @1F92 memory[0x00:0x20] = stack[-1] >> 0x08 // @1F97 memory[0x20:0x40] = stack[-2] // @1F9E stack[0] = 0x00 // @1F9F stack[1] = stack[-1] >> 0x08 // @1FA5 stack[2] = stack[-1] & 0xff // @1FA9 stack[3] = storage[keccak256(memory[0x00:0x40])] >> ((stack[-1] & 0xff) ~ 0xff) // } // Block ends with conditional jump to 0x1fca, if !(storage[keccak256(memory[0x00:0x40])] >> ((stack[-1] & 0xff) ~ 0xff)) label_1FB0: // Incoming jump from 0x1FAF, if not !(storage[keccak256(memory[0x00:0x40])] >> ((stack[-1] & 0xff) ~ 0xff)) // Inputs[1] { @1FB3 stack[-1] } 1FB0 61 PUSH2 0x1fb8 1FB3 81 DUP2 1FB4 61 PUSH2 0x225d 1FB7 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1FB0 stack[0] = 0x1fb8 // @1FB3 stack[1] = stack[-1] // } // Block ends with call to 0x225d, returns to 0x1FB8 label_1FB8: // Incoming return from call to 0x225D at 0x1FB7 // Inputs[4] // { // @1FBB stack[-1] // @1FBC stack[-3] // @1FC0 stack[-4] // @1FC4 stack[-5] // } 1FB8 5B JUMPDEST 1FB9 60 PUSH1 0xff 1FBB 16 AND 1FBC 82 DUP3 1FBD 03 SUB 1FBE 60 PUSH1 0x08 1FC0 84 DUP5 1FC1 90 SWAP1 1FC2 1B SHL 1FC3 17 OR 1FC4 93 SWAP4 1FC5 50 POP 1FC6 61 PUSH2 0x2080 1FC9 56 *JUMP // Stack delta = -1 // Outputs[1] { @1FC4 stack[-5] = (stack[-4] << 0x08) | stack[-3] - (0xff & stack[-1]) } // Block ends with unconditional jump to 0x2080 label_1FCA: // Incoming jump from 0x1FAF, if !(storage[keccak256(memory[0x00:0x40])] >> ((stack[-1] & 0xff) ~ 0xff)) // Incoming jump from 0x207F // Inputs[1] { @1FCD stack[-3] } 1FCA 5B JUMPDEST 1FCB 60 PUSH1 0x00 1FCD 83 DUP4 1FCE 11 GT 1FCF 61 PUSH2 0x2040 1FD2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2040, if stack[-3] > 0x00 label_1FD3: // Incoming jump from 0x1FD2, if not stack[-3] > 0x00 // Inputs[1] { @1FD5 memory[0x40:0x60] } 1FD3 60 PUSH1 0x40 1FD5 51 MLOAD 1FD6 62 PUSH3 0x461bcd 1FDA 60 PUSH1 0xe5 1FDC 1B SHL 1FDD 81 DUP2 1FDE 52 MSTORE 1FDF 60 PUSH1 0x20 1FE1 60 PUSH1 0x04 1FE3 82 DUP3 1FE4 01 ADD 1FE5 52 MSTORE 1FE6 60 PUSH1 0x34 1FE8 60 PUSH1 0x24 1FEA 82 DUP3 1FEB 01 ADD 1FEC 52 MSTORE 1FED 7F PUSH32 0x4269744d6170733a205468652073657420626974206265666f72652074686520 200E 60 PUSH1 0x44 2010 82 DUP3 2011 01 ADD 2012 52 MSTORE 2013 7F PUSH32 0x696e64657820646f65736e27742065786973742e000000000000000000000000 2034 60 PUSH1 0x64 2036 82 DUP3 2037 01 ADD 2038 52 MSTORE 2039 60 PUSH1 0x84 203B 01 ADD 203C 61 PUSH2 0x05c4 203F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1FDE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1FE5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1FEC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x34 // @2012 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4269744d6170733a205468652073657420626974206265666f72652074686520 // @2038 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x696e64657820646f65736e27742065786973742e000000000000000000000000 // @203B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x05c4 label_2040: // Incoming jump from 0x1FD2, if stack[-3] > 0x00 // Inputs[5] // { // @2045 stack[-2] // @2046 stack[-3] // @204F stack[-6] // @2055 memory[0x00:0x40] // @2056 storage[keccak256(memory[0x00:0x40])] // } 2040 5B JUMPDEST 2041 50 POP 2042 60 PUSH1 0x00 2044 19 NOT 2045 90 SWAP1 2046 91 SWAP2 2047 01 ADD 2048 60 PUSH1 0x00 204A 81 DUP2 204B 81 DUP2 204C 52 MSTORE 204D 60 PUSH1 0x20 204F 86 DUP7 2050 90 SWAP1 2051 52 MSTORE 2052 60 PUSH1 0x40 2054 90 SWAP1 2055 20 SHA3 2056 54 SLOAD 2057 90 SWAP1 2058 91 SWAP2 2059 90 SWAP1 205A 80 DUP1 205B 15 ISZERO 205C 61 PUSH2 0x207b 205F 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @204C memory[0x00:0x20] = stack[-3] + ~0x00 // @2051 memory[0x20:0x40] = stack[-6] // @2058 stack[-3] = stack[-3] + ~0x00 // @2059 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @2059 stack[-2] = stack[-2] // } // Block ends with conditional jump to 0x207b, if !storage[keccak256(memory[0x00:0x40])] label_2060: // Incoming jump from 0x205F, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @2063 stack[-1] } 2060 61 PUSH2 0x2068 2063 81 DUP2 2064 61 PUSH2 0x225d 2067 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2060 stack[0] = 0x2068 // @2063 stack[1] = stack[-1] // } // Block ends with call to 0x225d, returns to 0x2068 label_2068: // Incoming return from call to 0x225D at 0x2067 // Inputs[3] // { // @206B stack[-1] // @2071 stack[-4] // @2075 stack[-5] // } 2068 5B JUMPDEST 2069 60 PUSH1 0xff 206B 03 SUB 206C 60 PUSH1 0xff 206E 16 AND 206F 60 PUSH1 0x08 2071 84 DUP5 2072 90 SWAP1 2073 1B SHL 2074 17 OR 2075 93 SWAP4 2076 50 POP 2077 61 PUSH2 0x2080 207A 56 *JUMP // Stack delta = -1 // Outputs[1] { @2075 stack[-5] = (stack[-4] << 0x08) | (0xff & 0xff - stack[-1]) } // Block ends with unconditional jump to 0x2080 label_207B: // Incoming jump from 0x205F, if !storage[keccak256(memory[0x00:0x40])] 207B 5B JUMPDEST 207C 61 PUSH2 0x1fca 207F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1fca label_2080: // Incoming jump from 0x1FC9 // Incoming jump from 0x207A // Inputs[3] // { // @2084 stack[-7] // @2084 stack[-4] // @2085 stack[-6] // } 2080 5B JUMPDEST 2081 50 POP 2082 50 POP 2083 50 POP 2084 92 SWAP3 2085 91 SWAP2 2086 50 POP 2087 50 POP 2088 56 *JUMP // Stack delta = -6 // Outputs[1] { @2084 stack[-7] = stack[-4] } // Block ends with unconditional jump to stack[-7] 2089 5B JUMPDEST 208A 60 PUSH1 0x00 208C 60 PUSH1 0x01 208E 60 PUSH1 0x01 2090 60 PUSH1 0xa0 2092 1B SHL 2093 03 SUB 2094 85 DUP6 2095 16 AND 2096 3B EXTCODESIZE 2097 15 ISZERO 2098 61 PUSH2 0x2209 209B 57 *JUMPI 209C 50 POP 209D 60 PUSH1 0x01 209F 83 DUP4 20A0 5B JUMPDEST 20A1 61 PUSH2 0x20aa 20A4 84 DUP5 20A5 86 DUP7 20A6 61 PUSH2 0x2770 20A9 56 *JUMP 20AA 5B JUMPDEST 20AB 81 DUP2 20AC 10 LT 20AD 15 ISZERO 20AE 61 PUSH2 0x2203 20B1 57 *JUMPI 20B2 60 PUSH1 0x40 20B4 51 MLOAD 20B5 63 PUSH4 0x0a85bd01 20BA 60 PUSH1 0xe1 20BC 1B SHL 20BD 81 DUP2 20BE 52 MSTORE 20BF 60 PUSH1 0x01 20C1 60 PUSH1 0x01 20C3 60 PUSH1 0xa0 20C5 1B SHL 20C6 03 SUB 20C7 87 DUP8 20C8 16 AND 20C9 90 SWAP1 20CA 63 PUSH4 0x150b7a02 20CF 90 SWAP1 20D0 61 PUSH2 0x20e3 20D3 90 SWAP1 20D4 33 CALLER 20D5 90 SWAP1 20D6 8B DUP12 20D7 90 SWAP1 20D8 86 DUP7 20D9 90 SWAP1 20DA 89 DUP10 20DB 90 SWAP1 20DC 60 PUSH1 0x04 20DE 01 ADD 20DF 61 PUSH2 0x28f6 20E2 56 *JUMP 20E3 5B JUMPDEST 20E4 60 PUSH1 0x20 20E6 60 PUSH1 0x40 20E8 51 MLOAD 20E9 80 DUP1 20EA 83 DUP4 20EB 03 SUB 20EC 81 DUP2 20ED 60 PUSH1 0x00 20EF 87 DUP8 20F0 5A GAS 20F1 F1 CALL 20F2 92 SWAP3 20F3 50 POP 20F4 50 POP 20F5 50 POP 20F6 80 DUP1 20F7 15 ISZERO 20F8 61 PUSH2 0x211e 20FB 57 *JUMPI 20FC 50 POP 20FD 60 PUSH1 0x40 20FF 80 DUP1 2100 51 MLOAD 2101 60 PUSH1 0x1f 2103 3D RETURNDATASIZE 2104 90 SWAP1 2105 81 DUP2 2106 01 ADD 2107 60 PUSH1 0x1f 2109 19 NOT 210A 16 AND 210B 82 DUP3 210C 01 ADD 210D 90 SWAP1 210E 92 SWAP3 210F 52 MSTORE 2110 61 PUSH2 0x211b 2113 91 SWAP2 2114 81 DUP2 2115 01 ADD 2116 90 SWAP1 2117 61 PUSH2 0x2932 211A 56 *JUMP 211B 5B JUMPDEST 211C 60 PUSH1 0x01 211E 5B JUMPDEST 211F 61 PUSH2 0x21d1 2122 57 *JUMPI 2123 3D RETURNDATASIZE 2124 80 DUP1 2125 80 DUP1 2126 15 ISZERO 2127 61 PUSH2 0x214c 212A 57 *JUMPI 212B 60 PUSH1 0x40 212D 51 MLOAD 212E 91 SWAP2 212F 50 POP 2130 60 PUSH1 0x1f 2132 19 NOT 2133 60 PUSH1 0x3f 2135 3D RETURNDATASIZE 2136 01 ADD 2137 16 AND 2138 82 DUP3 2139 01 ADD 213A 60 PUSH1 0x40 213C 52 MSTORE 213D 3D RETURNDATASIZE 213E 82 DUP3 213F 52 MSTORE 2140 3D RETURNDATASIZE 2141 60 PUSH1 0x00 2143 60 PUSH1 0x20 2145 84 DUP5 2146 01 ADD 2147 3E RETURNDATACOPY 2148 61 PUSH2 0x2151 214B 56 *JUMP 214C 5B JUMPDEST 214D 60 PUSH1 0x60 214F 91 SWAP2 2150 50 POP 2151 5B JUMPDEST 2152 50 POP 2153 80 DUP1 2154 51 MLOAD 2155 60 PUSH1 0x00 2157 03 SUB 2158 61 PUSH2 0x21c9 215B 57 *JUMPI 215C 60 PUSH1 0x40 215E 51 MLOAD 215F 62 PUSH3 0x461bcd 2163 60 PUSH1 0xe5 2165 1B SHL 2166 81 DUP2 2167 52 MSTORE 2168 60 PUSH1 0x20 216A 60 PUSH1 0x04 216C 82 DUP3 216D 01 ADD 216E 52 MSTORE 216F 60 PUSH1 0x35 2171 60 PUSH1 0x24 2173 82 DUP3 2174 01 ADD 2175 52 MSTORE 2176 7F PUSH32 0x4552433732315073693a207472616e7366657220746f206e6f6e204552433732 2197 60 PUSH1 0x44 2199 82 DUP3 219A 01 ADD 219B 52 MSTORE 219C 7F PUSH32 0x31526563656976657220696d706c656d656e7465720000000000000000000000 21BD 60 PUSH1 0x64 21BF 82 DUP3 21C0 01 ADD 21C1 52 MSTORE 21C2 60 PUSH1 0x84 21C4 01 ADD 21C5 61 PUSH2 0x05c4 21C8 56 *JUMP 21C9 5B JUMPDEST 21CA 80 DUP1 21CB 51 MLOAD 21CC 81 DUP2 21CD 60 PUSH1 0x20 21CF 01 ADD 21D0 FD *REVERT 21D1 5B JUMPDEST 21D2 82 DUP3 21D3 80 DUP1 21D4 15 ISZERO 21D5 61 PUSH2 0x21ee 21D8 57 *JUMPI 21D9 50 POP 21DA 60 PUSH1 0x01 21DC 60 PUSH1 0x01 21DE 60 PUSH1 0xe0 21E0 1B SHL 21E1 03 SUB 21E2 19 NOT 21E3 81 DUP2 21E4 16 AND 21E5 63 PUSH4 0x0a85bd01 21EA 60 PUSH1 0xe1 21EC 1B SHL 21ED 14 EQ 21EE 5B JUMPDEST 21EF 92 SWAP3 21F0 50 POP 21F1 50 POP 21F2 80 DUP1 21F3 61 PUSH2 0x21fb 21F6 81 DUP2 21F7 61 PUSH2 0x26ad 21FA 56 *JUMP 21FB 5B JUMPDEST 21FC 91 SWAP2 21FD 50 POP 21FE 50 POP 21FF 61 PUSH2 0x20a0 2202 56 *JUMP 2203 5B JUMPDEST 2204 50 POP 2205 61 PUSH2 0x220d 2208 56 *JUMP 2209 5B JUMPDEST 220A 50 POP 220B 60 PUSH1 0x01 label_220D: // Incoming return from call to 0x2866 at 0x2865 // Inputs[3] // { // @220E stack[-7] // @220E stack[-1] // @220F stack[-6] // } 220D 5B JUMPDEST 220E 95 SWAP6 220F 94 SWAP5 2210 50 POP 2211 50 POP 2212 50 POP 2213 50 POP 2214 50 POP 2215 56 *JUMP // Stack delta = -6 // Outputs[1] { @220E stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] label_2216: // Incoming call from 0x1E6D, returns to 0x1E6E // Inputs[1] { @221A stack[-1] } 2216 5B JUMPDEST 2217 60 PUSH1 0x00 2219 80 DUP1 221A 82 DUP3 221B 11 GT 221C 61 PUSH2 0x2224 221F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2217 stack[0] = 0x00 } // Block ends with conditional jump to 0x2224, if stack[-1] > 0x00 label_2220: // Incoming jump from 0x221F, if not stack[-1] > 0x00 // Inputs[1] { @2223 memory[0x00:0x00] } 2220 60 PUSH1 0x00 2222 80 DUP1 2223 FD *REVERT // Stack delta = +0 // Outputs[1] { @2223 revert(memory[0x00:0x00]); } // Block terminates label_2224: // Incoming jump from 0x221F, if stack[-1] > 0x00 // Inputs[2] // { // @2228 stack[-2] // @225B stack[-3] // } 2224 5B JUMPDEST 2225 50 POP 2226 60 PUSH1 0x80 2228 81 DUP2 2229 90 SWAP1 222A 1C SHR 222B 17 OR 222C 60 PUSH1 0x40 222E 81 DUP2 222F 90 SWAP1 2230 1C SHR 2231 17 OR 2232 60 PUSH1 0x20 2234 81 DUP2 2235 90 SWAP1 2236 1C SHR 2237 17 OR 2238 60 PUSH1 0x10 223A 81 DUP2 223B 90 SWAP1 223C 1C SHR 223D 17 OR 223E 60 PUSH1 0x08 2240 81 DUP2 2241 90 SWAP1 2242 1C SHR 2243 17 OR 2244 60 PUSH1 0x04 2246 81 DUP2 2247 90 SWAP1 2248 1C SHR 2249 17 OR 224A 60 PUSH1 0x02 224C 81 DUP2 224D 90 SWAP1 224E 1C SHR 224F 17 OR 2250 60 PUSH1 0x01 2252 81 DUP2 2253 81 DUP2 2254 1C SHR 2255 90 SWAP1 2256 91 SWAP2 2257 17 OR 2258 81 DUP2 2259 1C SHR 225A 01 ADD 225B 90 SWAP1 225C 56 *JUMP // Stack delta = -2 // Outputs[1] { @225B stack[-3] = (((((((((((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x08) | (((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x04) | (((((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x08) | (((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x02) | (((((((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x08) | (((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x04) | (((((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x08) | (((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2] | (((((((((((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x08) | (((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x04) | (((((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x08) | (((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x02) | (((((((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x08) | (((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x04) | (((((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x08) | (((((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x10) | (((((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x20) | (((stack[-2] >> 0x80) | stack[-2]) >> 0x40) | (stack[-2] >> 0x80) | stack[-2]) >> 0x01)) >> 0x01) + 0x01 } // Block ends with unconditional jump to stack[-3] label_225D: // Incoming call from 0x1FB7, returns to 0x1FB8 // Incoming call from 0x2067, returns to 0x2068 // Inputs[2] // { // @2262 memory[0x40:0x60] // @22A1 stack[-1] // } 225D 5B JUMPDEST 225E 60 PUSH1 0x00 2260 60 PUSH1 0x40 2262 51 MLOAD 2263 80 DUP1 2264 61 PUSH2 0x0120 2267 01 ADD 2268 60 PUSH1 0x40 226A 52 MSTORE 226B 80 DUP1 226C 61 PUSH2 0x0100 226F 81 DUP2 2270 52 MSTORE 2271 60 PUSH1 0x20 2273 01 ADD 2274 61 PUSH2 0x2950 2277 61 PUSH2 0x0100 227A 91 SWAP2 227B 39 CODECOPY 227C 60 PUSH1 0xf8 227E 7E PUSH31 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff 229E 61 PUSH2 0x1e6e 22A1 85 DUP6 22A2 60 PUSH1 0x00 22A4 80 DUP1 22A5 82 DUP3 22A6 11 GT 22A7 61 PUSH2 0x22af 22AA 57 *JUMPI // Stack delta = +7 // Outputs[10] // { // @225E stack[0] = 0x00 // @2262 stack[1] = memory[0x40:0x60] // @226A memory[0x40:0x60] = 0x0120 + memory[0x40:0x60] // @2270 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0100 // @227B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x0100] = code[0x2950:0x2a50] // @227C stack[2] = 0xf8 // @227E stack[3] = 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff // @229E stack[4] = 0x1e6e // @22A1 stack[5] = stack[-1] // @22A2 stack[6] = 0x00 // } // Block ends with conditional call to 0x22af, returns to 0x1E6E, if stack[-1] > 0x00 label_22AB: // Incoming jump from 0x22AA, if not stack[-1] > 0x00 // Inputs[1] { @22AE memory[0x00:0x00] } 22AB 60 PUSH1 0x00 22AD 80 DUP1 22AE FD *REVERT // Stack delta = +0 // Outputs[1] { @22AE revert(memory[0x00:0x00]); } // Block terminates label_22AF: // Incoming call from 0x22AA, returns to 0x1E6E, if stack[-1] > 0x00 // Inputs[2] // { // @22B3 stack[-2] // @22B7 stack[-3] // } 22AF 5B JUMPDEST 22B0 50 POP 22B1 60 PUSH1 0x00 22B3 81 DUP2 22B4 90 SWAP1 22B5 03 SUB 22B6 16 AND 22B7 90 SWAP1 22B8 56 *JUMP // Stack delta = -2 // Outputs[1] { @22B7 stack[-3] = 0x00 - stack[-2] & stack[-2] } // Block ends with unconditional jump to stack[-3] label_22B9: // Incoming call from 0x22EB, returns to 0x22EC // Inputs[1] { @22C3 stack[-1] } 22B9 5B JUMPDEST 22BA 60 PUSH1 0x01 22BC 60 PUSH1 0x01 22BE 60 PUSH1 0xe0 22C0 1B SHL 22C1 03 SUB 22C2 19 NOT 22C3 81 DUP2 22C4 16 AND 22C5 81 DUP2 22C6 14 EQ 22C7 61 PUSH2 0x08d8 22CA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08d8, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_22CB: // Incoming jump from 0x22CA, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @22CE memory[0x00:0x00] } 22CB 60 PUSH1 0x00 22CD 80 DUP1 22CE FD *REVERT // Stack delta = +0 // Outputs[1] { @22CE revert(memory[0x00:0x00]); } // Block terminates label_22CF: // Incoming call from 0x01CB, returns to 0x01CC // Inputs[2] // { // @22D4 stack[-1] // @22D5 stack[-2] // } 22CF 5B JUMPDEST 22D0 60 PUSH1 0x00 22D2 60 PUSH1 0x20 22D4 82 DUP3 22D5 84 DUP5 22D6 03 SUB 22D7 12 SLT 22D8 15 ISZERO 22D9 61 PUSH2 0x22e1 22DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x22e1, if !(stack[-2] - stack[-1] i< 0x20) label_22DD: // Incoming jump from 0x22DC, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22E0 memory[0x00:0x00] } 22DD 60 PUSH1 0x00 22DF 80 DUP1 22E0 FD *REVERT // Stack delta = +0 // Outputs[1] { @22E0 revert(memory[0x00:0x00]); } // Block terminates label_22E1: // Incoming jump from 0x22DC, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @22E2 stack[-2] // @22E3 msg.data[stack[-2]:stack[-2] + 0x20] // } 22E1 5B JUMPDEST 22E2 81 DUP2 22E3 35 CALLDATALOAD 22E4 61 PUSH2 0x22ec 22E7 81 DUP2 22E8 61 PUSH2 0x22b9 22EB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22E3 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @22E4 stack[1] = 0x22ec // @22E7 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x22b9, returns to 0x22EC label_22EC: // Incoming return from call to 0x22B9 at 0x22EB // Incoming return from call to 0x236F at 0x24FF // Incoming return from call to 0x2317 at 0x2355 // Incoming return from call to 0x2518 at 0x2888 // Inputs[3] // { // @22ED stack[-1] // @22ED stack[-5] // @22EE stack[-4] // } 22EC 5B JUMPDEST 22ED 93 SWAP4 22EE 92 SWAP3 22EF 50 POP 22F0 50 POP 22F1 50 POP 22F2 56 *JUMP // Stack delta = -4 // Outputs[1] { @22ED stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_22F3: // Incoming call from 0x232E, returns to 0x232F // Incoming call from 0x2794, returns to 0x2795 // Inputs[1] { @22F7 stack[-3] } 22F3 5B JUMPDEST 22F4 60 PUSH1 0x00 22F6 5B JUMPDEST 22F7 83 DUP4 22F8 81 DUP2 22F9 10 LT 22FA 15 ISZERO 22FB 61 PUSH2 0x230e 22FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22F4 stack[0] = 0x00 } // Block ends with conditional jump to 0x230e, if !(0x00 < stack[-3]) label_22FF: // Incoming jump from 0x22FE, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x22FE, if not !(0x00 < stack[-3]) // Inputs[4] // { // @22FF stack[-2] // @2300 stack[-1] // @2302 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2303 stack[-3] // } 22FF 81 DUP2 2300 81 DUP2 2301 01 ADD 2302 51 MLOAD 2303 83 DUP4 2304 82 DUP3 2305 01 ADD 2306 52 MSTORE 2307 60 PUSH1 0x20 2309 01 ADD 230A 61 PUSH2 0x22f6 230D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2306 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2309 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x22f6 label_230E: // Incoming jump from 0x22FE, if !(stack[-1] < stack[-4]) // Incoming jump from 0x22FE, if !(0x00 < stack[-3]) // Inputs[3] // { // @2313 stack[-4] // @2314 stack[-3] // @2316 stack[-5] // } 230E 5B JUMPDEST 230F 50 POP 2310 50 POP 2311 60 PUSH1 0x00 2313 91 SWAP2 2314 01 ADD 2315 52 MSTORE 2316 56 *JUMP // Stack delta = -5 // Outputs[1] { @2315 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2317: // Incoming call from 0x2355, returns to 0x22EC // Inputs[3] // { // @231A stack[-1] // @231B memory[stack[-1]:stack[-1] + 0x20] // @231D stack[-2] // } 2317 5B JUMPDEST 2318 60 PUSH1 0x00 231A 81 DUP2 231B 51 MLOAD 231C 80 DUP1 231D 84 DUP5 231E 52 MSTORE 231F 61 PUSH2 0x232f 2322 81 DUP2 2323 60 PUSH1 0x20 2325 86 DUP7 2326 01 ADD 2327 60 PUSH1 0x20 2329 86 DUP7 232A 01 ADD 232B 61 PUSH2 0x22f3 232E 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2318 stack[0] = 0x00 // @231B stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @231E memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @231F stack[2] = 0x232f // @2322 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2326 stack[4] = stack[-2] + 0x20 // @232A stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x22f3, returns to 0x232F label_232F: // Incoming return from call to 0x22F3 at 0x232E // Inputs[4] // { // @2332 stack[-1] // @2337 stack[-4] // @2338 stack[-2] // @233E stack[-5] // } 232F 5B JUMPDEST 2330 60 PUSH1 0x1f 2332 01 ADD 2333 60 PUSH1 0x1f 2335 19 NOT 2336 16 AND 2337 92 SWAP3 2338 90 SWAP1 2339 92 SWAP3 233A 01 ADD 233B 60 PUSH1 0x20 233D 01 ADD 233E 92 SWAP3 233F 91 SWAP2 2340 50 POP 2341 50 POP 2342 56 *JUMP // Stack delta = -4 // Outputs[1] { @233E stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2343: // Incoming jump from 0x01FA // Incoming jump from 0x199A // Inputs[2] // { // @2346 stack[-1] // @2351 stack[-2] // } 2343 5B JUMPDEST 2344 60 PUSH1 0x20 2346 81 DUP2 2347 52 MSTORE 2348 60 PUSH1 0x00 234A 61 PUSH2 0x22ec 234D 60 PUSH1 0x20 234F 83 DUP4 2350 01 ADD 2351 84 DUP5 2352 61 PUSH2 0x2317 2355 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2347 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2348 stack[0] = 0x00 // @234A stack[1] = 0x22ec // @2350 stack[2] = stack[-1] + 0x20 // @2351 stack[3] = stack[-2] // } // Block ends with call to 0x2317, returns to 0x22EC label_2356: // Incoming call from 0x0393, returns to 0x0394 // Incoming call from 0x02ED, returns to 0x02EE // Incoming call from 0x02BF, returns to 0x02C0 // Incoming call from 0x0208, returns to 0x0209 // Incoming call from 0x02DA, returns to 0x02DB // Inputs[2] // { // @235B stack[-1] // @235C stack[-2] // } 2356 5B JUMPDEST 2357 60 PUSH1 0x00 2359 60 PUSH1 0x20 235B 82 DUP3 235C 84 DUP5 235D 03 SUB 235E 12 SLT 235F 15 ISZERO 2360 61 PUSH2 0x2368 2363 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2357 stack[0] = 0x00 } // Block ends with conditional jump to 0x2368, if !(stack[-2] - stack[-1] i< 0x20) label_2364: // Incoming jump from 0x2363, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2367 memory[0x00:0x00] } 2364 60 PUSH1 0x00 2366 80 DUP1 2367 FD *REVERT // Stack delta = +0 // Outputs[1] { @2367 revert(memory[0x00:0x00]); } // Block terminates label_2368: // Incoming jump from 0x2363, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @236A stack[-2] // @236A msg.data[stack[-2]:stack[-2] + 0x20] // @236B stack[-4] // @236C stack[-3] // } 2368 5B JUMPDEST 2369 50 POP 236A 35 CALLDATALOAD 236B 91 SWAP2 236C 90 SWAP1 236D 50 POP 236E 56 *JUMP // Stack delta = -3 // Outputs[1] { @236B stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_236F: // Incoming call from 0x23A1, returns to 0x23A2 // Incoming call from 0x24D4, returns to 0x24D5 // Incoming call from 0x2638, returns to 0x2639 // Incoming call from 0x2646, returns to 0x2647 // Incoming call from 0x258A, returns to 0x258B // Incoming call from 0x24C6, returns to 0x24C7 // Incoming call from 0x2541, returns to 0x2542 // Incoming call from 0x257B, returns to 0x257C // Incoming call from 0x24FF, returns to 0x22EC // Inputs[2] // { // @2370 stack[-1] // @2371 msg.data[stack[-1]:stack[-1] + 0x20] // } 236F 5B JUMPDEST 2370 80 DUP1 2371 35 CALLDATALOAD 2372 60 PUSH1 0x01 2374 60 PUSH1 0x01 2376 60 PUSH1 0xa0 2378 1B SHL 2379 03 SUB 237A 81 DUP2 237B 16 AND 237C 81 DUP2 237D 14 EQ 237E 61 PUSH2 0x0e1b 2381 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2371 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0e1b, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_2382: // Incoming jump from 0x2381, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2385 memory[0x00:0x00] } 2382 60 PUSH1 0x00 2384 80 DUP1 2385 FD *REVERT // Stack delta = +0 // Outputs[1] { @2385 revert(memory[0x00:0x00]); } // Block terminates label_2386: // Incoming call from 0x0339, returns to 0x033A // Incoming call from 0x0284, returns to 0x0285 // Incoming call from 0x0233, returns to 0x0234 // Inputs[2] // { // @238C stack[-1] // @238D stack[-2] // } 2386 5B JUMPDEST 2387 60 PUSH1 0x00 2389 80 DUP1 238A 60 PUSH1 0x40 238C 83 DUP4 238D 85 DUP6 238E 03 SUB 238F 12 SLT 2390 15 ISZERO 2391 61 PUSH2 0x2399 2394 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2387 stack[0] = 0x00 // @2389 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2399, if !(stack[-2] - stack[-1] i< 0x40) label_2395: // Incoming jump from 0x2394, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2398 memory[0x00:0x00] } 2395 60 PUSH1 0x00 2397 80 DUP1 2398 FD *REVERT // Stack delta = +0 // Outputs[1] { @2398 revert(memory[0x00:0x00]); } // Block terminates label_2399: // Incoming jump from 0x2394, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @239D stack[-3] } 2399 5B JUMPDEST 239A 61 PUSH2 0x23a2 239D 83 DUP4 239E 61 PUSH2 0x236f 23A1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @239A stack[0] = 0x23a2 // @239D stack[1] = stack[-3] // } // Block ends with call to 0x236f, returns to 0x23A2 label_23A2: // Incoming return from call to 0x236F at 0x23A1 // Inputs[5] // { // @23A3 stack[-1] // @23A3 stack[-6] // @23A6 stack[-4] // @23AA msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @23AB stack[-5] // } 23A2 5B JUMPDEST 23A3 94 SWAP5 23A4 60 PUSH1 0x20 23A6 93 SWAP4 23A7 90 SWAP1 23A8 93 SWAP4 23A9 01 ADD 23AA 35 CALLDATALOAD 23AB 93 SWAP4 23AC 50 POP 23AD 50 POP 23AE 50 POP 23AF 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @23A3 stack[-6] = stack[-1] // @23AB stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_23B0: // Incoming jump from 0x188C // Incoming jump from 0x23EE // Incoming jump from 0x25D4 // Incoming jump from 0x244F // Inputs[1] { @23C5 memory[0x00:0x24] } 23B0 5B JUMPDEST 23B1 63 PUSH4 0x4e487b71 23B6 60 PUSH1 0xe0 23B8 1B SHL 23B9 60 PUSH1 0x00 23BB 52 MSTORE 23BC 60 PUSH1 0x41 23BE 60 PUSH1 0x04 23C0 52 MSTORE 23C1 60 PUSH1 0x24 23C3 60 PUSH1 0x00 23C5 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @23BB memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @23C0 memory[0x04:0x24] = 0x41 // @23C5 revert(memory[0x00:0x24]); // } // Block terminates label_23C6: // Incoming call from 0x2460, returns to 0x2461 // Incoming call from 0x25E6, returns to 0x25E7 // Inputs[2] // { // @23C9 memory[0x40:0x60] // @23CC stack[-1] // } 23C6 5B JUMPDEST 23C7 60 PUSH1 0x40 23C9 51 MLOAD 23CA 60 PUSH1 0x1f 23CC 82 DUP3 23CD 01 ADD 23CE 60 PUSH1 0x1f 23D0 19 NOT 23D1 16 AND 23D2 81 DUP2 23D3 01 ADD 23D4 67 PUSH8 0xffffffffffffffff 23DD 81 DUP2 23DE 11 GT 23DF 82 DUP3 23E0 82 DUP3 23E1 10 LT 23E2 17 OR 23E3 15 ISZERO 23E4 61 PUSH2 0x23ef 23E7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23C9 stack[0] = memory[0x40:0x60] // @23D3 stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x23ef, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_23E8: // Incoming jump from 0x23E7, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 23E8 61 PUSH2 0x23ef 23EB 61 PUSH2 0x23b0 23EE 56 *JUMP // Stack delta = +1 // Outputs[1] { @23E8 stack[0] = 0x23ef } // Block ends with unconditional jump to 0x23b0 label_23EF: // Incoming jump from 0x23E7, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @23F2 stack[-1] // @23F3 stack[-4] // @23F3 stack[-2] // @23F4 stack[-3] // } 23EF 5B JUMPDEST 23F0 60 PUSH1 0x40 23F2 52 MSTORE 23F3 91 SWAP2 23F4 90 SWAP1 23F5 50 POP 23F6 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @23F2 memory[0x40:0x60] = stack[-1] // @23F3 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_23F7: // Incoming call from 0x025E, returns to 0x025F // Inputs[2] // { // @23FD stack[-1] // @23FE stack[-2] // } 23F7 5B JUMPDEST 23F8 60 PUSH1 0x00 23FA 80 DUP1 23FB 60 PUSH1 0x40 23FD 83 DUP4 23FE 85 DUP6 23FF 03 SUB 2400 12 SLT 2401 15 ISZERO 2402 61 PUSH2 0x240a 2405 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23F8 stack[0] = 0x00 // @23FA stack[1] = 0x00 // } // Block ends with conditional jump to 0x240a, if !(stack[-2] - stack[-1] i< 0x40) label_2406: // Incoming jump from 0x2405, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2409 memory[0x00:0x00] } 2406 60 PUSH1 0x00 2408 80 DUP1 2409 FD *REVERT // Stack delta = +0 // Outputs[1] { @2409 revert(memory[0x00:0x00]); } // Block terminates label_240A: // Incoming jump from 0x2405, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @240B stack[-3] // @240C msg.data[stack[-3]:stack[-3] + 0x20] // @240D stack[-2] // @2414 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 240A 5B JUMPDEST 240B 82 DUP3 240C 35 CALLDATALOAD 240D 91 SWAP2 240E 50 POP 240F 60 PUSH1 0x20 2411 80 DUP1 2412 84 DUP5 2413 01 ADD 2414 35 CALLDATALOAD 2415 67 PUSH8 0xffffffffffffffff 241E 80 DUP1 241F 82 DUP3 2420 11 GT 2421 15 ISZERO 2422 61 PUSH2 0x242a 2425 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @240D stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @240F stack[0] = 0x20 // @2414 stack[1] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2415 stack[2] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x242a, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) label_2426: // Incoming jump from 0x2425, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2429 memory[0x00:0x00] } 2426 60 PUSH1 0x00 2428 80 DUP1 2429 FD *REVERT // Stack delta = +0 // Outputs[1] { @2429 revert(memory[0x00:0x00]); } // Block terminates label_242A: // Incoming jump from 0x2425, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @242B stack[-2] // @242C stack[-6] // @2430 stack[-7] // } 242A 5B JUMPDEST 242B 81 DUP2 242C 86 DUP7 242D 01 ADD 242E 91 SWAP2 242F 50 POP 2430 86 DUP7 2431 60 PUSH1 0x1f 2433 83 DUP4 2434 01 ADD 2435 12 SLT 2436 61 PUSH2 0x243e 2439 57 *JUMPI // Stack delta = +0 // Outputs[1] { @242E stack[-2] = stack[-6] + stack[-2] } // Block ends with conditional jump to 0x243e, if stack[-6] + stack[-2] + 0x1f i< stack[-7] label_243A: // Incoming jump from 0x2439, if not stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[1] { @243D memory[0x00:0x00] } 243A 60 PUSH1 0x00 243C 80 DUP1 243D FD *REVERT // Stack delta = +0 // Outputs[1] { @243D revert(memory[0x00:0x00]); } // Block terminates label_243E: // Incoming jump from 0x2439, if stack[-6] + stack[-2] + 0x1f i< stack[-7] // Inputs[3] // { // @243F stack[-2] // @2440 msg.data[stack[-2]:stack[-2] + 0x20] // @2441 stack[-1] // } 243E 5B JUMPDEST 243F 81 DUP2 2440 35 CALLDATALOAD 2441 81 DUP2 2442 81 DUP2 2443 11 GT 2444 15 ISZERO 2445 61 PUSH2 0x2450 2448 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2440 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2450, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_2449: // Incoming jump from 0x2448, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 2449 61 PUSH2 0x2450 244C 61 PUSH2 0x23b0 244F 56 *JUMP // Stack delta = +1 // Outputs[1] { @2449 stack[0] = 0x2450 } // Block ends with unconditional jump to 0x23b0 label_2450: // Incoming jump from 0x2448, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @2451 stack[-1] // @2455 stack[-2] // @245A stack[-4] // } 2450 5B JUMPDEST 2451 80 DUP1 2452 60 PUSH1 0x05 2454 1B SHL 2455 91 SWAP2 2456 50 POP 2457 61 PUSH2 0x2461 245A 84 DUP5 245B 83 DUP4 245C 01 ADD 245D 61 PUSH2 0x23c6 2460 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2455 stack[-2] = stack[-1] << 0x05 // @2457 stack[0] = 0x2461 // @245C stack[1] = (stack[-1] << 0x05) + stack[-4] // } // Block ends with call to 0x23c6, returns to 0x2461 label_2461: // Incoming return from call to 0x23C6 at 0x2460 // Inputs[6] // { // @2462 stack[-2] // @2463 stack[-1] // @2465 stack[-3] // @2466 stack[-4] // @2468 stack[-5] // @246F stack[-9] // } 2461 5B JUMPDEST 2462 81 DUP2 2463 81 DUP2 2464 52 MSTORE 2465 91 SWAP2 2466 83 DUP4 2467 01 ADD 2468 84 DUP5 2469 01 ADD 246A 91 SWAP2 246B 84 DUP5 246C 81 DUP2 246D 01 ADD 246E 90 SWAP1 246F 89 DUP10 2470 84 DUP5 2471 11 GT 2472 15 ISZERO 2473 61 PUSH2 0x247b 2476 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2464 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @246A stack[-3] = stack[-5] + stack[-4] + stack[-3] // @246E stack[-1] = stack[-1] + stack[-5] // @246E stack[0] = stack[-1] // } // Block ends with conditional jump to 0x247b, if !(stack[-5] + stack[-4] + stack[-3] > stack[-9]) label_2477: // Incoming jump from 0x2476, if not !(stack[-5] + stack[-4] + stack[-3] > stack[-9]) // Inputs[1] { @247A memory[0x00:0x00] } 2477 60 PUSH1 0x00 2479 80 DUP1 247A FD *REVERT // Stack delta = +0 // Outputs[1] { @247A revert(memory[0x00:0x00]); } // Block terminates label_247B: // Incoming jump from 0x2476, if !(stack[-5] + stack[-4] + stack[-3] > stack[-9]) // Inputs[4] // { // @247C stack[-5] // @247C stack[-1] // @247D stack[-6] // @2481 stack[-4] // } 247B 5B JUMPDEST 247C 93 SWAP4 247D 85 DUP6 247E 01 ADD 247F 93 SWAP4 2480 5B JUMPDEST 2481 83 DUP4 2482 85 DUP6 2483 10 LT 2484 15 ISZERO 2485 61 PUSH2 0x2499 2488 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @247F stack[-5] = stack[-6] + stack[-5] // @247F stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x2499, if !(stack[-6] + stack[-5] < stack[-4]) label_2489: // Incoming jump from 0x2488, if not !(stack[-6] + stack[-5] < stack[-4]) // Incoming jump from 0x2488, if not !(stack[-5] < stack[-4]) // Inputs[5] // { // @2489 stack[-5] // @248A msg.data[stack[-5]:stack[-5] + 0x20] // @248B stack[-2] // @248D stack[-1] // @248E stack[-6] // } 2489 84 DUP5 248A 35 CALLDATALOAD 248B 82 DUP3 248C 52 MSTORE 248D 93 SWAP4 248E 85 DUP6 248F 01 ADD 2490 93 SWAP4 2491 90 SWAP1 2492 85 DUP6 2493 01 ADD 2494 90 SWAP1 2495 61 PUSH2 0x2480 2498 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @248C memory[stack[-2]:stack[-2] + 0x20] = msg.data[stack[-5]:stack[-5] + 0x20] // @2490 stack[-5] = stack[-6] + stack[-5] // @2494 stack[-1] = stack[-1] // @2494 stack[-2] = stack[-6] + stack[-2] // } // Block ends with unconditional jump to 0x2480 label_2499: // Incoming jump from 0x2488, if !(stack[-6] + stack[-5] < stack[-4]) // Incoming jump from 0x2488, if !(stack[-5] < stack[-4]) // Inputs[6] // { // @249A stack[-1] // @249B stack[-7] // @24A3 stack[-10] // @24A5 stack[-8] // @24A5 stack[-11] // @24A6 stack[-9] // } 2499 5B JUMPDEST 249A 80 DUP1 249B 96 SWAP7 249C 50 POP 249D 50 POP 249E 50 POP 249F 50 POP 24A0 50 POP 24A1 50 POP 24A2 50 POP 24A3 92 SWAP3 24A4 50 POP 24A5 92 SWAP3 24A6 90 SWAP1 24A7 50 POP 24A8 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @24A3 stack[-10] = stack[-1] // @24A5 stack[-11] = stack[-8] // } // Block ends with unconditional jump to stack[-11] label_24A9: // Incoming call from 0x02AC, returns to 0x02AD // Incoming call from 0x0271, returns to 0x0272 // Inputs[2] // { // @24B1 stack[-1] // @24B2 stack[-2] // } 24A9 5B JUMPDEST 24AA 60 PUSH1 0x00 24AC 80 DUP1 24AD 60 PUSH1 0x00 24AF 60 PUSH1 0x60 24B1 84 DUP5 24B2 86 DUP7 24B3 03 SUB 24B4 12 SLT 24B5 15 ISZERO 24B6 61 PUSH2 0x24be 24B9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @24AA stack[0] = 0x00 // @24AC stack[1] = 0x00 // @24AD stack[2] = 0x00 // } // Block ends with conditional jump to 0x24be, if !(stack[-2] - stack[-1] i< 0x60) label_24BA: // Incoming jump from 0x24B9, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @24BD memory[0x00:0x00] } 24BA 60 PUSH1 0x00 24BC 80 DUP1 24BD FD *REVERT // Stack delta = +0 // Outputs[1] { @24BD revert(memory[0x00:0x00]); } // Block terminates label_24BE: // Incoming jump from 0x24B9, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @24C2 stack[-4] } 24BE 5B JUMPDEST 24BF 61 PUSH2 0x24c7 24C2 84 DUP5 24C3 61 PUSH2 0x236f 24C6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24BF stack[0] = 0x24c7 // @24C2 stack[1] = stack[-4] // } // Block ends with call to 0x236f, returns to 0x24C7 label_24C7: // Incoming return from call to 0x236F at 0x24C6 // Inputs[3] // { // @24C8 stack[-4] // @24C8 stack[-1] // @24CF stack[-5] // } 24C7 5B JUMPDEST 24C8 92 SWAP3 24C9 50 POP 24CA 61 PUSH2 0x24d5 24CD 60 PUSH1 0x20 24CF 85 DUP6 24D0 01 ADD 24D1 61 PUSH2 0x236f 24D4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @24C8 stack[-4] = stack[-1] // @24CA stack[-1] = 0x24d5 // @24D0 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x236f, returns to 0x24D5 label_24D5: // Incoming return from call to 0x236F at 0x24D4 // Inputs[8] // { // @24D6 stack[-1] // @24D6 stack[-3] // @24DA stack[-5] // @24DC msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @24DD stack[-2] // @24E1 stack[-6] // @24E3 stack[-7] // @24E3 stack[-4] // } 24D5 5B JUMPDEST 24D6 91 SWAP2 24D7 50 POP 24D8 60 PUSH1 0x40 24DA 84 DUP5 24DB 01 ADD 24DC 35 CALLDATALOAD 24DD 90 SWAP1 24DE 50 POP 24DF 92 SWAP3 24E0 50 POP 24E1 92 SWAP3 24E2 50 POP 24E3 92 SWAP3 24E4 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @24DF stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @24E1 stack[-6] = stack[-1] // @24E3 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_24E5: // Incoming call from 0x030B, returns to 0x030C // Incoming call from 0x03E2, returns to 0x03E3 // Inputs[2] // { // @24EA stack[-1] // @24EB stack[-2] // } 24E5 5B JUMPDEST 24E6 60 PUSH1 0x00 24E8 60 PUSH1 0x20 24EA 82 DUP3 24EB 84 DUP5 24EC 03 SUB 24ED 12 SLT 24EE 15 ISZERO 24EF 61 PUSH2 0x24f7 24F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24E6 stack[0] = 0x00 } // Block ends with conditional jump to 0x24f7, if !(stack[-2] - stack[-1] i< 0x20) label_24F3: // Incoming jump from 0x24F2, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @24F6 memory[0x00:0x00] } 24F3 60 PUSH1 0x00 24F5 80 DUP1 24F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @24F6 revert(memory[0x00:0x00]); } // Block terminates label_24F7: // Incoming jump from 0x24F2, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @24FB stack[-2] } 24F7 5B JUMPDEST 24F8 61 PUSH2 0x22ec 24FB 82 DUP3 24FC 61 PUSH2 0x236f 24FF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24F8 stack[0] = 0x22ec // @24FB stack[1] = stack[-2] // } // Block ends with call to 0x236f, returns to 0x22EC label_2500: // Incoming call from 0x0326, returns to 0x0327 // Inputs[2] // { // @2505 stack[-1] // @2506 stack[-2] // } 2500 5B JUMPDEST 2501 60 PUSH1 0x00 2503 60 PUSH1 0x80 2505 82 DUP3 2506 84 DUP5 2507 03 SUB 2508 12 SLT 2509 15 ISZERO 250A 61 PUSH2 0x2512 250D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2501 stack[0] = 0x00 } // Block ends with conditional jump to 0x2512, if !(stack[-2] - stack[-1] i< 0x80) label_250E: // Incoming jump from 0x250D, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2511 memory[0x00:0x00] } 250E 60 PUSH1 0x00 2510 80 DUP1 2511 FD *REVERT // Stack delta = +0 // Outputs[1] { @2511 revert(memory[0x00:0x00]); } // Block terminates label_2512: // Incoming jump from 0x266E, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x250D, if !(stack[-2] - stack[-1] i< 0x80) // Incoming jump from 0x266E, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @2514 stack[-2] // @2514 stack[-4] // @2515 stack[-3] // } 2512 5B JUMPDEST 2513 50 POP 2514 91 SWAP2 2515 90 SWAP1 2516 50 POP 2517 56 *JUMP // Stack delta = -3 // Outputs[1] { @2514 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2518: // Incoming call from 0x2551, returns to 0x2552 // Incoming call from 0x2888, returns to 0x22EC // Inputs[1] { @2519 stack[-1] } 2518 5B JUMPDEST 2519 80 DUP1 251A 15 ISZERO 251B 15 ISZERO 251C 81 DUP2 251D 14 EQ 251E 61 PUSH2 0x08d8 2521 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08d8, if stack[-1] == !!stack[-1] label_2522: // Incoming jump from 0x2521, if not stack[-1] == !!stack[-1] // Inputs[1] { @2525 memory[0x00:0x00] } 2522 60 PUSH1 0x00 2524 80 DUP1 2525 FD *REVERT // Stack delta = +0 // Outputs[1] { @2525 revert(memory[0x00:0x00]); } // Block terminates label_2526: // Incoming call from 0x0365, returns to 0x0366 // Inputs[2] // { // @252C stack[-1] // @252D stack[-2] // } 2526 5B JUMPDEST 2527 60 PUSH1 0x00 2529 80 DUP1 252A 60 PUSH1 0x40 252C 83 DUP4 252D 85 DUP6 252E 03 SUB 252F 12 SLT 2530 15 ISZERO 2531 61 PUSH2 0x2539 2534 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2527 stack[0] = 0x00 // @2529 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2539, if !(stack[-2] - stack[-1] i< 0x40) label_2535: // Incoming jump from 0x2534, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2538 memory[0x00:0x00] } 2535 60 PUSH1 0x00 2537 80 DUP1 2538 FD *REVERT // Stack delta = +0 // Outputs[1] { @2538 revert(memory[0x00:0x00]); } // Block terminates label_2539: // Incoming jump from 0x2534, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @253D stack[-3] } 2539 5B JUMPDEST 253A 61 PUSH2 0x2542 253D 83 DUP4 253E 61 PUSH2 0x236f 2541 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @253A stack[0] = 0x2542 // @253D stack[1] = stack[-3] // } // Block ends with call to 0x236f, returns to 0x2542 label_2542: // Incoming return from call to 0x236F at 0x2541 // Inputs[4] // { // @2543 stack[-3] // @2543 stack[-1] // @2547 stack[-4] // @2549 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 2542 5B JUMPDEST 2543 91 SWAP2 2544 50 POP 2545 60 PUSH1 0x20 2547 83 DUP4 2548 01 ADD 2549 35 CALLDATALOAD 254A 61 PUSH2 0x2552 254D 81 DUP2 254E 61 PUSH2 0x2518 2551 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2543 stack[-3] = stack[-1] // @2549 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @254A stack[0] = 0x2552 // @254D stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x2518, returns to 0x2552 label_2552: // Incoming return from call to 0x2518 at 0x2551 // Inputs[6] // { // @2553 stack[-1] // @2554 stack[-2] // @2557 stack[-5] // @2559 stack[-3] // @2559 stack[-6] // @255A stack[-4] // } 2552 5B JUMPDEST 2553 80 DUP1 2554 91 SWAP2 2555 50 POP 2556 50 POP 2557 92 SWAP3 2558 50 POP 2559 92 SWAP3 255A 90 SWAP1 255B 50 POP 255C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2557 stack[-5] = stack[-1] // @2559 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_255D: // Incoming call from 0x0380, returns to 0x0381 // Inputs[2] // { // @2566 stack[-1] // @2567 stack[-2] // } 255D 5B JUMPDEST 255E 60 PUSH1 0x00 2560 80 DUP1 2561 60 PUSH1 0x00 2563 80 DUP1 2564 60 PUSH1 0x80 2566 85 DUP6 2567 87 DUP8 2568 03 SUB 2569 12 SLT 256A 15 ISZERO 256B 61 PUSH2 0x2573 256E 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @255E stack[0] = 0x00 // @2560 stack[1] = 0x00 // @2561 stack[2] = 0x00 // @2563 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2573, if !(stack[-2] - stack[-1] i< 0x80) label_256F: // Incoming jump from 0x256E, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2572 memory[0x00:0x00] } 256F 60 PUSH1 0x00 2571 80 DUP1 2572 FD *REVERT // Stack delta = +0 // Outputs[1] { @2572 revert(memory[0x00:0x00]); } // Block terminates label_2573: // Incoming jump from 0x256E, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2577 stack[-5] } 2573 5B JUMPDEST 2574 61 PUSH2 0x257c 2577 85 DUP6 2578 61 PUSH2 0x236f 257B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2574 stack[0] = 0x257c // @2577 stack[1] = stack[-5] // } // Block ends with call to 0x236f, returns to 0x257C label_257C: // Incoming return from call to 0x236F at 0x257B // Inputs[3] // { // @257D stack[-1] // @257D stack[-5] // @2585 stack[-6] // } 257C 5B JUMPDEST 257D 93 SWAP4 257E 50 POP 257F 60 PUSH1 0x20 2581 61 PUSH2 0x258b 2584 81 DUP2 2585 87 DUP8 2586 01 ADD 2587 61 PUSH2 0x236f 258A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @257D stack[-5] = stack[-1] // @257F stack[-1] = 0x20 // @2581 stack[0] = 0x258b // @2586 stack[1] = stack[-6] + 0x20 // } // Block ends with call to 0x236f, returns to 0x258B label_258B: // Incoming return from call to 0x236F at 0x258A // Inputs[6] // { // @258C stack[-1] // @258C stack[-5] // @2590 stack[-7] // @2592 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2593 stack[-4] // @2599 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // } 258B 5B JUMPDEST 258C 93 SWAP4 258D 50 POP 258E 60 PUSH1 0x40 2590 86 DUP7 2591 01 ADD 2592 35 CALLDATALOAD 2593 92 SWAP3 2594 50 POP 2595 60 PUSH1 0x60 2597 86 DUP7 2598 01 ADD 2599 35 CALLDATALOAD 259A 67 PUSH8 0xffffffffffffffff 25A3 80 DUP1 25A4 82 DUP3 25A5 11 GT 25A6 15 ISZERO 25A7 61 PUSH2 0x25af 25AA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @258C stack[-5] = stack[-1] // @2593 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @2599 stack[-1] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @259A stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x25af, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) label_25AB: // Incoming jump from 0x25AA, if not !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @25AE memory[0x00:0x00] } 25AB 60 PUSH1 0x00 25AD 80 DUP1 25AE FD *REVERT // Stack delta = +0 // Outputs[1] { @25AE revert(memory[0x00:0x00]); } // Block terminates label_25AF: // Incoming jump from 0x25AA, if !(msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @25B0 stack[-2] // @25B1 stack[-8] // @25B5 stack[-9] // } 25AF 5B JUMPDEST 25B0 81 DUP2 25B1 88 DUP9 25B2 01 ADD 25B3 91 SWAP2 25B4 50 POP 25B5 88 DUP9 25B6 60 PUSH1 0x1f 25B8 83 DUP4 25B9 01 ADD 25BA 12 SLT 25BB 61 PUSH2 0x25c3 25BE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @25B3 stack[-2] = stack[-8] + stack[-2] } // Block ends with conditional jump to 0x25c3, if stack[-8] + stack[-2] + 0x1f i< stack[-9] label_25BF: // Incoming jump from 0x25BE, if not stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[1] { @25C2 memory[0x00:0x00] } 25BF 60 PUSH1 0x00 25C1 80 DUP1 25C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @25C2 revert(memory[0x00:0x00]); } // Block terminates label_25C3: // Incoming jump from 0x25BE, if stack[-8] + stack[-2] + 0x1f i< stack[-9] // Inputs[3] // { // @25C4 stack[-2] // @25C5 msg.data[stack[-2]:stack[-2] + 0x20] // @25C6 stack[-1] // } 25C3 5B JUMPDEST 25C4 81 DUP2 25C5 35 CALLDATALOAD 25C6 81 DUP2 25C7 81 DUP2 25C8 11 GT 25C9 15 ISZERO 25CA 61 PUSH2 0x25d5 25CD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25C5 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x25d5, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_25CE: // Incoming jump from 0x25CD, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 25CE 61 PUSH2 0x25d5 25D1 61 PUSH2 0x23b0 25D4 56 *JUMP // Stack delta = +1 // Outputs[1] { @25CE stack[0] = 0x25d5 } // Block ends with unconditional jump to 0x23b0 label_25D5: // Incoming jump from 0x25CD, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @25DB stack[-1] // @25E1 stack[-4] // } 25D5 5B JUMPDEST 25D6 61 PUSH2 0x25e7 25D9 60 PUSH1 0x1f 25DB 82 DUP3 25DC 01 ADD 25DD 60 PUSH1 0x1f 25DF 19 NOT 25E0 16 AND 25E1 85 DUP6 25E2 01 ADD 25E3 61 PUSH2 0x23c6 25E6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @25D6 stack[0] = 0x25e7 // @25E2 stack[1] = stack[-4] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with call to 0x23c6, returns to 0x25E7 label_25E7: // Incoming return from call to 0x23C6 at 0x25E6 // Inputs[6] // { // @25E8 stack[-3] // @25E8 stack[-1] // @25EA stack[-2] // @25ED stack[-11] // @25EE stack[-5] // @25F0 stack[-4] // } 25E7 5B JUMPDEST 25E8 91 SWAP2 25E9 50 POP 25EA 80 DUP1 25EB 82 DUP3 25EC 52 MSTORE 25ED 89 DUP10 25EE 84 DUP5 25EF 82 DUP3 25F0 85 DUP6 25F1 01 ADD 25F2 01 ADD 25F3 11 GT 25F4 15 ISZERO 25F5 61 PUSH2 0x25fd 25F8 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @25E8 stack[-3] = stack[-1] // @25EC memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // } // Block ends with conditional jump to 0x25fd, if !(stack[-4] + stack[-2] + stack[-5] > stack[-11]) label_25F9: // Incoming jump from 0x25F8, if not !(stack[-4] + stack[-2] + stack[-5] > stack[-11]) // Inputs[1] { @25FC memory[0x00:0x00] } 25F9 60 PUSH1 0x00 25FB 80 DUP1 25FC FD *REVERT // Stack delta = +0 // Outputs[1] { @25FC revert(memory[0x00:0x00]); } // Block terminates label_25FD: // Incoming jump from 0x25F8, if !(stack[-4] + stack[-2] + stack[-5] > stack[-11]) // Inputs[12] // { // @25FE stack[-1] // @25FF stack[-4] // @2600 stack[-3] // @2603 stack[-2] // @2605 msg.data[stack[-3] + stack[-4]:stack[-3] + stack[-4] + stack[-1]] // @2610 stack[-5] // @2615 stack[-8] // @2616 stack[-11] // @2617 stack[-7] // @2618 stack[-10] // @261A stack[-6] // @261A stack[-9] // } 25FD 5B JUMPDEST 25FE 80 DUP1 25FF 84 DUP5 2600 84 DUP5 2601 01 ADD 2602 85 DUP6 2603 84 DUP5 2604 01 ADD 2605 37 CALLDATACOPY 2606 60 PUSH1 0x00 2608 84 DUP5 2609 82 DUP3 260A 84 DUP5 260B 01 ADD 260C 01 ADD 260D 52 MSTORE 260E 50 POP 260F 80 DUP1 2610 93 SWAP4 2611 50 POP 2612 50 POP 2613 50 POP 2614 50 POP 2615 92 SWAP3 2616 95 SWAP6 2617 91 SWAP2 2618 94 SWAP5 2619 50 POP 261A 92 SWAP3 261B 50 POP 261C 56 *JUMP // Stack delta = -7 // Outputs[6] // { // @2605 memory[stack[-2] + stack[-4]:stack[-2] + stack[-4] + stack[-1]] = msg.data[stack[-3] + stack[-4]:stack[-3] + stack[-4] + stack[-1]] // @260D memory[stack[-2] + stack[-1] + stack[-4]:stack[-2] + stack[-1] + stack[-4] + 0x20] = 0x00 // @2615 stack[-8] = stack[-2] // @2616 stack[-11] = stack[-8] // @2618 stack[-10] = stack[-7] // @261A stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-11] label_261D: // Incoming call from 0x03A6, returns to 0x03A7 // Inputs[2] // { // @2623 stack[-1] // @2624 stack[-2] // } 261D 5B JUMPDEST 261E 60 PUSH1 0x00 2620 80 DUP1 2621 60 PUSH1 0x40 2623 83 DUP4 2624 85 DUP6 2625 03 SUB 2626 12 SLT 2627 15 ISZERO 2628 61 PUSH2 0x2630 262B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @261E stack[0] = 0x00 // @2620 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2630, if !(stack[-2] - stack[-1] i< 0x40) label_262C: // Incoming jump from 0x262B, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @262F memory[0x00:0x00] } 262C 60 PUSH1 0x00 262E 80 DUP1 262F FD *REVERT // Stack delta = +0 // Outputs[1] { @262F revert(memory[0x00:0x00]); } // Block terminates label_2630: // Incoming jump from 0x262B, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2634 stack[-3] } 2630 5B JUMPDEST 2631 61 PUSH2 0x2639 2634 83 DUP4 2635 61 PUSH2 0x236f 2638 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2631 stack[0] = 0x2639 // @2634 stack[1] = stack[-3] // } // Block ends with call to 0x236f, returns to 0x2639 label_2639: // Incoming return from call to 0x236F at 0x2638 // Inputs[3] // { // @263A stack[-3] // @263A stack[-1] // @2641 stack[-4] // } 2639 5B JUMPDEST 263A 91 SWAP2 263B 50 POP 263C 61 PUSH2 0x2647 263F 60 PUSH1 0x20 2641 84 DUP5 2642 01 ADD 2643 61 PUSH2 0x236f 2646 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @263A stack[-3] = stack[-1] // @263C stack[-1] = 0x2647 // @2642 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x236f, returns to 0x2647 label_2647: // Incoming return from call to 0x236F at 0x2646 // Inputs[6] // { // @2648 stack[-2] // @2648 stack[-1] // @264A stack[-5] // @264C stack[-3] // @264C stack[-6] // @264D stack[-4] // } 2647 5B JUMPDEST 2648 90 SWAP1 2649 50 POP 264A 92 SWAP3 264B 50 POP 264C 92 SWAP3 264D 90 SWAP1 264E 50 POP 264F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @264A stack[-5] = stack[-1] // @264C stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_2650: // Incoming call from 0x04F3, returns to 0x04F4 // Incoming call from 0x0D14, returns to 0x0D15 // Incoming call from 0x04C7, returns to 0x04C8 // Incoming call from 0x0B94, returns to 0x04C8 // Incoming call from 0x0D40, returns to 0x0D41 // Inputs[1] { @2653 stack[-1] } 2650 5B JUMPDEST 2651 60 PUSH1 0x01 2653 81 DUP2 2654 81 DUP2 2655 1C SHR 2656 90 SWAP1 2657 82 DUP3 2658 16 AND 2659 80 DUP1 265A 61 PUSH2 0x2664 265D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2656 stack[0] = stack[-1] >> 0x01 // @2658 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2664, if stack[-1] & 0x01 label_265E: // Incoming jump from 0x265D, if not stack[-1] & 0x01 // Inputs[2] // { // @2660 stack[-2] // @2669 stack[-1] // } 265E 60 PUSH1 0x7f 2660 82 DUP3 2661 16 AND 2662 91 SWAP2 2663 50 POP 2664 5B JUMPDEST 2665 60 PUSH1 0x20 2667 82 DUP3 2668 10 LT 2669 81 DUP2 266A 03 SUB 266B 61 PUSH2 0x2512 266E 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2662 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2512, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_266F: // Incoming jump from 0x266E, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x266E, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @2683 memory[0x00:0x24] } 266F 63 PUSH4 0x4e487b71 2674 60 PUSH1 0xe0 2676 1B SHL 2677 60 PUSH1 0x00 2679 52 MSTORE 267A 60 PUSH1 0x22 267C 60 PUSH1 0x04 267E 52 MSTORE 267F 60 PUSH1 0x24 2681 60 PUSH1 0x00 2683 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2679 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @267E memory[0x04:0x24] = 0x22 // @2683 revert(memory[0x00:0x24]); // } // Block terminates label_2684: // Incoming jump from 0x26AC // Incoming jump from 0x2782 // Incoming jump from 0x26BE // Inputs[1] { @2699 memory[0x00:0x24] } 2684 5B JUMPDEST 2685 63 PUSH4 0x4e487b71 268A 60 PUSH1 0xe0 268C 1B SHL 268D 60 PUSH1 0x00 268F 52 MSTORE 2690 60 PUSH1 0x11 2692 60 PUSH1 0x04 2694 52 MSTORE 2695 60 PUSH1 0x24 2697 60 PUSH1 0x00 2699 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @268F memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2694 memory[0x04:0x24] = 0x11 // @2699 revert(memory[0x00:0x24]); // } // Block terminates label_269A: // Incoming call from 0x0E0D, returns to 0x0E0E // Incoming call from 0x18CB, returns to 0x18CC // Incoming call from 0x0DB4, returns to 0x0DB5 // Incoming call from 0x0DAA, returns to 0x0DAB // Incoming call from 0x0618, returns to 0x0619 // Inputs[2] // { // @269B stack[-2] // @269C stack[-1] // } 269A 5B JUMPDEST 269B 81 DUP2 269C 81 DUP2 269D 03 SUB 269E 81 DUP2 269F 81 DUP2 26A0 11 GT 26A1 15 ISZERO 26A2 61 PUSH2 0x04b3 26A5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @269D stack[0] = stack[-1] - stack[-2] } // Block ends with conditional jump to 0x04b3, if !(stack[-1] - stack[-2] > stack[-1]) label_26A6: // Incoming jump from 0x26A5, if not !(stack[-1] - stack[-2] > stack[-1]) 26A6 61 PUSH2 0x04b3 26A9 61 PUSH2 0x2684 26AC 56 *JUMP // Stack delta = +1 // Outputs[1] { @26A6 stack[0] = 0x04b3 } // Block ends with unconditional jump to 0x2684 label_26AD: // Incoming call from 0x098C, returns to 0x098D // Incoming call from 0x156E, returns to 0x156F // Incoming call from 0x0754, returns to 0x0755 // Incoming call from 0x0746, returns to 0x0747 // Incoming call from 0x099A, returns to 0x099B // Incoming call from 0x1133, returns to 0x1134 // Incoming call from 0x185B, returns to 0x185C // Incoming call from 0x0A8D, returns to 0x0A8E // Inputs[1] { @26B2 stack[-1] } 26AD 5B JUMPDEST 26AE 60 PUSH1 0x00 26B0 60 PUSH1 0x01 26B2 82 DUP3 26B3 01 ADD 26B4 61 PUSH2 0x26bf 26B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26AE stack[0] = 0x00 } // Block ends with conditional jump to 0x26bf, if stack[-1] + 0x01 label_26B8: // Incoming jump from 0x26B7, if not stack[-1] + 0x01 26B8 61 PUSH2 0x26bf 26BB 61 PUSH2 0x2684 26BE 56 *JUMP // Stack delta = +1 // Outputs[1] { @26B8 stack[0] = 0x26bf } // Block ends with unconditional jump to 0x2684 label_26BF: // Incoming jump from 0x26B7, if stack[-1] + 0x01 // Inputs[2] // { // @26C3 stack[-2] // @26C4 stack[-3] // } 26BF 5B JUMPDEST 26C0 50 POP 26C1 60 PUSH1 0x01 26C3 01 ADD 26C4 90 SWAP1 26C5 56 *JUMP // Stack delta = -2 // Outputs[1] { @26C4 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_26C6: // Incoming call from 0x0AC4, returns to 0x05FD // Inputs[4] // { // @26C7 stack[-2] // @26C8 msg.data[stack[-2]:stack[-2] + 0x20] // @26C9 stack[-1] // @26D3 msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // } 26C6 5B JUMPDEST 26C7 81 DUP2 26C8 35 CALLDATALOAD 26C9 81 DUP2 26CA 55 SSTORE 26CB 60 PUSH1 0x01 26CD 81 DUP2 26CE 01 ADD 26CF 60 PUSH1 0x20 26D1 83 DUP4 26D2 01 ADD 26D3 35 CALLDATALOAD 26D4 67 PUSH8 0xffffffffffffffff 26DD 81 DUP2 26DE 16 AND 26DF 80 DUP1 26E0 82 DUP3 26E1 14 EQ 26E2 61 PUSH2 0x26ea 26E5 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @26CA storage[stack[-1]] = msg.data[stack[-2]:stack[-2] + 0x20] // @26CE stack[0] = stack[-1] + 0x01 // @26D3 stack[1] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @26DE stack[2] = msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xffffffffffffffff // } // Block ends with conditional jump to 0x26ea, if msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] == msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xffffffffffffffff label_26E6: // Incoming jump from 0x26E5, if not msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] == msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xffffffffffffffff // Inputs[1] { @26E9 memory[0x00:0x00] } 26E6 60 PUSH1 0x00 26E8 80 DUP1 26E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @26E9 revert(memory[0x00:0x00]); } // Block terminates label_26EA: // Incoming jump from 0x26E5, if msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] == msg.data[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xffffffffffffffff // Inputs[5] // { // @26EB stack[-3] // @26EC storage[stack[-3]] // @26ED stack[-2] // @26F1 stack[-5] // @26F3 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 26EA 5B JUMPDEST 26EB 82 DUP3 26EC 54 SLOAD 26ED 91 SWAP2 26EE 50 POP 26EF 60 PUSH1 0x40 26F1 85 DUP6 26F2 01 ADD 26F3 35 CALLDATALOAD 26F4 61 PUSH2 0xffff 26F7 81 DUP2 26F8 16 AND 26F9 81 DUP2 26FA 14 EQ 26FB 61 PUSH2 0x2703 26FE 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @26ED stack[-2] = storage[stack[-3]] // @26F3 stack[0] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x2703, if msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffff label_26FF: // Incoming jump from 0x26FE, if not msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffff // Inputs[1] { @2702 memory[0x00:0x00] } 26FF 60 PUSH1 0x00 2701 80 DUP1 2702 FD *REVERT // Stack delta = +0 // Outputs[1] { @2702 revert(memory[0x00:0x00]); } // Block terminates label_2703: // Incoming jump from 0x26FE, if msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] == msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] & 0xffff // Inputs[2] // { // @2706 stack[-6] // @2708 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2703 5B JUMPDEST 2704 60 PUSH1 0x60 2706 86 DUP7 2707 01 ADD 2708 35 CALLDATALOAD 2709 63 PUSH4 0xffffffff 270E 81 DUP2 270F 16 AND 2710 81 DUP2 2711 14 EQ 2712 61 PUSH2 0x271a 2715 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2708 stack[0] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] } // Block ends with conditional jump to 0x271a, if msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] == msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] & 0xffffffff label_2716: // Incoming jump from 0x2715, if not msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] == msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] & 0xffffffff // Inputs[1] { @2719 memory[0x00:0x00] } 2716 60 PUSH1 0x00 2718 80 DUP1 2719 FD *REVERT // Stack delta = +0 // Outputs[1] { @2719 revert(memory[0x00:0x00]); } // Block terminates label_271A: // Incoming jump from 0x2715, if msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] == msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] & 0xffffffff // Inputs[6] // { // @272A stack[-1] // @273F stack[-3] // @2751 stack[-4] // @275F stack[-2] // @2766 stack[-5] // @276F stack[-8] // } 271A 5B JUMPDEST 271B 6D PUSH14 0xffffffff00000000000000000000 272A 81 DUP2 272B 60 PUSH1 0x50 272D 1B SHL 272E 16 AND 272F 6D PUSH14 0xffffffff00000000000000000000 273E 19 NOT 273F 84 DUP5 2740 16 AND 2741 6D PUSH14 0xffffffffffffffffffffffffffff 2750 19 NOT 2751 86 DUP7 2752 16 AND 2753 17 OR 2754 69 PUSH10 0xffff0000000000000000 275F 84 DUP5 2760 60 PUSH1 0x40 2762 1B SHL 2763 16 AND 2764 17 OR 2765 17 OR 2766 85 DUP6 2767 55 SSTORE 2768 50 POP 2769 50 POP 276A 50 POP 276B 50 POP 276C 50 POP 276D 50 POP 276E 50 POP 276F 56 *JUMP // Stack delta = -8 // Outputs[1] { @2767 storage[stack[-5]] = ((stack[-2] << 0x40) & 0xffff0000000000000000) | (stack[-4] & ~0xffffffffffffffffffffffffffff) | (stack[-3] & ~0xffffffff00000000000000000000) | ((stack[-1] << 0x50) & 0xffffffff00000000000000000000) } // Block ends with unconditional jump to stack[-8] label_2770: // Incoming call from 0x1125, returns to 0x1126 // Incoming call from 0x10F6, returns to 0x10F7 // Incoming call from 0x14CF, returns to 0x14D0 // Incoming call from 0x1525, returns to 0x1526 // Incoming call from 0x1525, returns to 0x1526 // Incoming call from 0x0B2D, returns to 0x0B2E // Incoming call from 0x18E3, returns to 0x18E4 // Inputs[2] // { // @2771 stack[-1] // @2772 stack[-2] // } 2770 5B JUMPDEST 2771 80 DUP1 2772 82 DUP3 2773 01 ADD 2774 80 DUP1 2775 82 DUP3 2776 11 GT 2777 15 ISZERO 2778 61 PUSH2 0x04b3 277B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2773 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x04b3, if !(stack[-1] > stack[-2] + stack[-1]) label_277C: // Incoming jump from 0x277B, if not !(stack[-1] > stack[-2] + stack[-1]) 277C 61 PUSH2 0x04b3 277F 61 PUSH2 0x2684 2782 56 *JUMP // Stack delta = +1 // Outputs[1] { @277C stack[0] = 0x04b3 } // Block ends with unconditional jump to 0x2684 label_2783: // Incoming jump from 0x286B // Inputs[3] // { // @2786 stack[-1] // @2787 memory[stack[-1]:stack[-1] + 0x20] // @278C stack[-2] // } 2783 5B JUMPDEST 2784 60 PUSH1 0x00 2786 81 DUP2 2787 51 MLOAD 2788 61 PUSH2 0x2795 278B 81 DUP2 278C 85 DUP6 278D 60 PUSH1 0x20 278F 86 DUP7 2790 01 ADD 2791 61 PUSH2 0x22f3 2794 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2784 stack[0] = 0x00 // @2787 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2788 stack[2] = 0x2795 // @278B stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @278C stack[4] = stack[-2] // @2790 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x22f3, returns to 0x2795 label_2795: // Incoming return from call to 0x22F3 at 0x2794 // Inputs[4] // { // @2796 stack[-4] // @2796 stack[-1] // @2797 stack[-2] // @279A stack[-5] // } 2795 5B JUMPDEST 2796 92 SWAP3 2797 90 SWAP1 2798 92 SWAP3 2799 01 ADD 279A 92 SWAP3 279B 91 SWAP2 279C 50 POP 279D 50 POP 279E 56 *JUMP // Stack delta = -4 // Outputs[1] { @279A stack[-5] = stack[-1] + stack[-4] } // Block ends with unconditional jump to stack[-5] label_279F: // Incoming call from 0x0DD7, returns to 0x0DD8 // Inputs[2] // { // @27A3 stack[-3] // @27A4 storage[stack[-3]] // } 279F 5B JUMPDEST 27A0 60 PUSH1 0x00 27A2 80 DUP1 27A3 84 DUP5 27A4 54 SLOAD 27A5 81 DUP2 27A6 60 PUSH1 0x01 27A8 82 DUP3 27A9 81 DUP2 27AA 1C SHR 27AB 91 SWAP2 27AC 50 POP 27AD 80 DUP1 27AE 83 DUP4 27AF 16 AND 27B0 80 DUP1 27B1 61 PUSH2 0x27bb 27B4 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @27A0 stack[0] = 0x00 // @27A2 stack[1] = 0x00 // @27A4 stack[2] = storage[stack[-3]] // @27A6 stack[4] = 0x01 // @27AB stack[3] = storage[stack[-3]] >> 0x01 // @27AF stack[5] = storage[stack[-3]] & 0x01 // } // Block ends with conditional jump to 0x27bb, if storage[stack[-3]] & 0x01 label_27B5: // Incoming jump from 0x27B4, if not storage[stack[-3]] & 0x01 // Inputs[2] // { // @27B7 stack[-3] // @27C1 stack[-1] // } 27B5 60 PUSH1 0x7f 27B7 83 DUP4 27B8 16 AND 27B9 92 SWAP3 27BA 50 POP 27BB 5B JUMPDEST 27BC 60 PUSH1 0x20 27BE 80 DUP1 27BF 84 DUP5 27C0 10 LT 27C1 82 DUP3 27C2 03 SUB 27C3 61 PUSH2 0x27da 27C6 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @27B9 stack[-3] = stack[-3] & 0x7f // @27BC stack[0] = 0x20 // } // Block ends with conditional jump to 0x27da, if stack[-1] - (stack[-3] & 0x7f < 0x20) label_27C7: // Incoming jump from 0x27C6, if not stack[-1] - (stack[-3] < 0x20) // Incoming jump from 0x27C6, if not stack[-1] - (stack[-3] & 0x7f < 0x20) // Inputs[2] // { // @27CF stack[-6] // @27D9 memory[stack[-6]:stack[-6] + 0x24] // } 27C7 63 PUSH4 0x4e487b71 27CC 60 PUSH1 0xe0 27CE 1B SHL 27CF 86 DUP7 27D0 52 MSTORE 27D1 60 PUSH1 0x22 27D3 60 PUSH1 0x04 27D5 52 MSTORE 27D6 60 PUSH1 0x24 27D8 86 DUP7 27D9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @27D0 memory[stack[-6]:stack[-6] + 0x20] = 0x4e487b71 << 0xe0 // @27D5 memory[0x04:0x24] = 0x22 // @27D9 revert(memory[stack[-6]:stack[-6] + 0x24]); // } // Block terminates label_27DA: // Incoming jump from 0x27C6, if stack[-1] - (stack[-3] < 0x20) // Incoming jump from 0x27C6, if stack[-1] - (stack[-3] & 0x7f < 0x20) // Inputs[1] { @27DB stack[-2] } 27DA 5B JUMPDEST 27DB 81 DUP2 27DC 80 DUP1 27DD 15 ISZERO 27DE 61 PUSH2 0x27ee 27E1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27DB stack[0] = stack[-2] } // Block ends with conditional jump to 0x27ee, if !stack[-2] label_27E2: // Incoming jump from 0x27E1, if not !stack[-2] // Inputs[1] { @27E4 stack[-1] } 27E2 60 PUSH1 0x01 27E4 81 DUP2 27E5 14 EQ 27E6 61 PUSH2 0x2803 27E9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2803, if stack[-1] == 0x01 label_27EA: // Incoming jump from 0x27E9, if not stack[-1] == 0x01 27EA 61 PUSH2 0x2830 27ED 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2830 label_27EE: // Incoming jump from 0x27E1, if !stack[-2] // Inputs[4] // { // @27F2 stack[-6] // @27F4 stack[-9] // @27F6 stack[-5] // @27FD stack[-7] // } 27EE 5B JUMPDEST 27EF 60 PUSH1 0xff 27F1 19 NOT 27F2 86 DUP7 27F3 16 AND 27F4 89 DUP10 27F5 52 MSTORE 27F6 84 DUP5 27F7 15 ISZERO 27F8 15 ISZERO 27F9 85 DUP6 27FA 02 MUL 27FB 89 DUP10 27FC 01 ADD 27FD 96 SWAP7 27FE 50 POP 27FF 61 PUSH2 0x2830 2802 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @27F5 memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @27FD stack[-7] = stack[-9] + stack[-5] * !!stack[-5] // } // Block ends with unconditional jump to 0x2830 label_2803: // Incoming jump from 0x27E9, if stack[-1] == 0x01 // Inputs[3] // { // @2806 stack[-11] // @280C memory[0x00:0x20] // @2810 stack[-5] // } 2803 5B JUMPDEST 2804 60 PUSH1 0x00 2806 8B DUP12 2807 81 DUP2 2808 52 MSTORE 2809 60 PUSH1 0x20 280B 90 SWAP1 280C 20 SHA3 280D 60 PUSH1 0x00 280F 5B JUMPDEST 2810 86 DUP7 2811 81 DUP2 2812 10 LT 2813 15 ISZERO 2814 61 PUSH2 0x2828 2817 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @2808 memory[0x00:0x20] = stack[-11] // @280C stack[0] = keccak256(memory[0x00:0x20]) // @280D stack[1] = 0x00 // } // Block ends with conditional jump to 0x2828, if !(0x00 < stack[-5]) label_2818: // Incoming jump from 0x2817, if not !(0x00 < stack[-5]) // Incoming jump from 0x2817, if not !(stack[-1] < stack[-7]) // Inputs[6] // { // @2818 stack[-2] // @2819 storage[stack[-2]] // @281A stack[-11] // @281B stack[-1] // @281F stack[-6] // @2822 stack[-4] // } 2818 81 DUP2 2819 54 SLOAD 281A 8B DUP12 281B 82 DUP3 281C 01 ADD 281D 52 MSTORE 281E 90 SWAP1 281F 85 DUP6 2820 01 ADD 2821 90 SWAP1 2822 83 DUP4 2823 01 ADD 2824 61 PUSH2 0x280f 2827 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @281D memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @2821 stack[-2] = stack[-6] + stack[-2] // @2823 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x280f label_2828: // Incoming jump from 0x2817, if !(0x00 < stack[-5]) // Incoming jump from 0x2817, if !(stack[-1] < stack[-7]) // Inputs[3] // { // @282B stack[-7] // @282C stack[-11] // @282E stack[-9] // } 2828 5B JUMPDEST 2829 50 POP 282A 50 POP 282B 84 DUP5 282C 89 DUP10 282D 01 ADD 282E 96 SWAP7 282F 50 POP // Stack delta = -2 // Outputs[1] { @282E stack[-9] = stack[-11] + stack[-7] } // Block continues label_2830: // Incoming jump from 0x282F // Incoming jump from 0x27ED // Incoming jump from 0x2802 // Inputs[1] { @283D stack[-7] } 2830 5B JUMPDEST 2831 50 POP 2832 50 POP 2833 50 POP 2834 50 POP 2835 50 POP 2836 50 POP 2837 61 PUSH2 0x220d 283A 61 PUSH2 0x2866 283D 82 DUP3 283E 7F PUSH32 0x2f00000000000000000000000000000000000000000000000000000000000000 285F 81 DUP2 2860 52 MSTORE 2861 60 PUSH1 0x01 2863 01 ADD 2864 90 SWAP1 2865 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2837 stack[-6] = 0x220d // @2860 memory[stack[-7]:stack[-7] + 0x20] = 0x2f00000000000000000000000000000000000000000000000000000000000000 // @2864 stack[-5] = 0x01 + stack[-7] // } // Block ends with call to 0x2866, returns to 0x220D label_2866: // Incoming call from 0x2865, returns to 0x220D // Inputs[1] { @2867 stack[-6] } 2866 5B JUMPDEST 2867 85 DUP6 2868 61 PUSH2 0x2783 286B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2867 stack[0] = stack[-6] } // Block ends with unconditional jump to 0x2783 label_286C: // Incoming jump from 0x0F8D // Inputs[2] // { // @2871 stack[-1] // @2872 stack[-2] // } 286C 5B JUMPDEST 286D 60 PUSH1 0x00 286F 60 PUSH1 0x20 2871 82 DUP3 2872 84 DUP5 2873 03 SUB 2874 12 SLT 2875 15 ISZERO 2876 61 PUSH2 0x287e 2879 57 *JUMPI // Stack delta = +1 // Outputs[1] { @286D stack[0] = 0x00 } // Block ends with conditional jump to 0x287e, if !(stack[-2] - stack[-1] i< 0x20) label_287A: // Incoming jump from 0x2879, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @287D memory[0x00:0x00] } 287A 60 PUSH1 0x00 287C 80 DUP1 287D FD *REVERT // Stack delta = +0 // Outputs[1] { @287D revert(memory[0x00:0x00]); } // Block terminates label_287E: // Incoming jump from 0x2879, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @287F stack[-2] // @2880 memory[stack[-2]:stack[-2] + 0x20] // } 287E 5B JUMPDEST 287F 81 DUP2 2880 51 MLOAD 2881 61 PUSH2 0x22ec 2884 81 DUP2 2885 61 PUSH2 0x2518 2888 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2880 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2881 stack[1] = 0x22ec // @2884 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2518, returns to 0x22EC label_2889: // Incoming jump from 0x18F8 // Incoming jump from 0x1153 // Incoming jump from 0x1E80 // Inputs[1] { @289E memory[0x00:0x24] } 2889 5B JUMPDEST 288A 63 PUSH4 0x4e487b71 288F 60 PUSH1 0xe0 2891 1B SHL 2892 60 PUSH1 0x00 2894 52 MSTORE 2895 60 PUSH1 0x32 2897 60 PUSH1 0x04 2899 52 MSTORE 289A 60 PUSH1 0x24 289C 60 PUSH1 0x00 289E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2894 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2899 memory[0x04:0x24] = 0x32 // @289E revert(memory[0x00:0x24]); // } // Block terminates label_289F: // Incoming call from 0x172F, returns to 0x1730 // Inputs[2] // { // @28A4 stack[-1] // @28A5 stack[-2] // } 289F 5B JUMPDEST 28A0 60 PUSH1 0x00 28A2 60 PUSH1 0x20 28A4 82 DUP3 28A5 84 DUP5 28A6 03 SUB 28A7 12 SLT 28A8 15 ISZERO 28A9 61 PUSH2 0x28b1 28AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28A0 stack[0] = 0x00 } // Block ends with conditional jump to 0x28b1, if !(stack[-2] - stack[-1] i< 0x20) label_28AD: // Incoming jump from 0x28AC, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @28B0 memory[0x00:0x00] } 28AD 60 PUSH1 0x00 28AF 80 DUP1 28B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @28B0 revert(memory[0x00:0x00]); } // Block terminates label_28B1: // Incoming jump from 0x28AC, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @28B3 memory[stack[-2]:stack[-2] + 0x20] // @28B3 stack[-2] // @28B4 stack[-4] // @28B5 stack[-3] // } 28B1 5B JUMPDEST 28B2 50 POP 28B3 51 MLOAD 28B4 91 SWAP2 28B5 90 SWAP1 28B6 50 POP 28B7 56 *JUMP // Stack delta = -3 // Outputs[1] { @28B4 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_28B8: // Incoming jump from 0x28DC // Incoming jump from 0x28F0 // Inputs[1] { @28CD memory[0x00:0x24] } 28B8 5B JUMPDEST 28B9 63 PUSH4 0x4e487b71 28BE 60 PUSH1 0xe0 28C0 1B SHL 28C1 60 PUSH1 0x00 28C3 52 MSTORE 28C4 60 PUSH1 0x12 28C6 60 PUSH1 0x04 28C8 52 MSTORE 28C9 60 PUSH1 0x24 28CB 60 PUSH1 0x00 28CD FD *REVERT // Stack delta = +0 // Outputs[3] // { // @28C3 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @28C8 memory[0x04:0x24] = 0x12 // @28CD revert(memory[0x00:0x24]); // } // Block terminates label_28CE: // Incoming call from 0x186A, returns to 0x186B // Incoming call from 0x1932, returns to 0x1933 // Inputs[1] { @28D1 stack[-2] } 28CE 5B JUMPDEST 28CF 60 PUSH1 0x00 28D1 82 DUP3 28D2 61 PUSH2 0x28dd 28D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28CF stack[0] = 0x00 } // Block ends with conditional jump to 0x28dd, if stack[-2] label_28D6: // Incoming jump from 0x28D5, if not stack[-2] 28D6 61 PUSH2 0x28dd 28D9 61 PUSH2 0x28b8 28DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @28D6 stack[0] = 0x28dd } // Block ends with unconditional jump to 0x28b8 label_28DD: // Incoming jump from 0x28D5, if stack[-2] // Inputs[3] // { // @28DF stack[-2] // @28DF stack[-3] // @28E0 stack[-4] // } 28DD 5B JUMPDEST 28DE 50 POP 28DF 04 DIV 28E0 90 SWAP1 28E1 56 *JUMP // Stack delta = -3 // Outputs[1] { @28E0 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_28E2: // Incoming call from 0x18D8, returns to 0x18D9 // Inputs[1] { @28E5 stack[-2] } 28E2 5B JUMPDEST 28E3 60 PUSH1 0x00 28E5 82 DUP3 28E6 61 PUSH2 0x28f1 28E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @28E3 stack[0] = 0x00 } // Block ends with conditional jump to 0x28f1, if stack[-2] label_28EA: // Incoming jump from 0x28E9, if not stack[-2] 28EA 61 PUSH2 0x28f1 28ED 61 PUSH2 0x28b8 28F0 56 *JUMP // Stack delta = +1 // Outputs[1] { @28EA stack[0] = 0x28f1 } // Block ends with unconditional jump to 0x28b8 label_28F1: // Incoming jump from 0x28E9, if stack[-2] // Inputs[3] // { // @28F3 stack[-3] // @28F3 stack[-2] // @28F4 stack[-4] // } 28F1 5B JUMPDEST 28F2 50 POP 28F3 06 MOD 28F4 90 SWAP1 28F5 56 *JUMP // Stack delta = -3 // Outputs[1] { @28F4 stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] 28F6 5B JUMPDEST 28F7 60 PUSH1 0x00 28F9 60 PUSH1 0x01 28FB 60 PUSH1 0x01 28FD 60 PUSH1 0xa0 28FF 1B SHL 2900 03 SUB 2901 80 DUP1 2902 87 DUP8 2903 16 AND 2904 83 DUP4 2905 52 MSTORE 2906 80 DUP1 2907 86 DUP7 2908 16 AND 2909 60 PUSH1 0x20 290B 84 DUP5 290C 01 ADD 290D 52 MSTORE 290E 50 POP 290F 83 DUP4 2910 60 PUSH1 0x40 2912 83 DUP4 2913 01 ADD 2914 52 MSTORE 2915 60 PUSH1 0x80 2917 60 PUSH1 0x60 2919 83 DUP4 291A 01 ADD 291B 52 MSTORE 291C 61 PUSH2 0x2928 291F 60 PUSH1 0x80 2921 83 DUP4 2922 01 ADD 2923 84 DUP5 2924 61 PUSH2 0x2317 2927 56 *JUMP 2928 5B JUMPDEST 2929 96 SWAP7 292A 95 SWAP6 292B 50 POP 292C 50 POP 292D 50 POP 292E 50 POP 292F 50 POP 2930 50 POP 2931 56 *JUMP 2932 5B JUMPDEST 2933 60 PUSH1 0x00 2935 60 PUSH1 0x20 2937 82 DUP3 2938 84 DUP5 2939 03 SUB 293A 12 SLT 293B 15 ISZERO 293C 61 PUSH2 0x2944 293F 57 *JUMPI 2940 60 PUSH1 0x00 2942 80 DUP1 2943 FD *REVERT 2944 5B JUMPDEST 2945 81 DUP2 2946 51 MLOAD 2947 61 PUSH2 0x22ec 294A 81 DUP2 294B 61 PUSH2 0x22b9 294E 56 *JUMP 294F FE *ASSERT 2950 00 *STOP 2951 01 ADD 2952 02 MUL 2953 09 MULMOD 2954 03 SUB 2955 11 GT 2956 0A EXP 2957 19 NOT 2958 04 DIV 2959 21 21 295A 12 SLT 295B 29 29 295C 0B SIGNEXTEND 295D 31 BALANCE 295E 1A BYTE 295F 39 CODECOPY 2960 05 SDIV 2961 41 COINBASE 2962 22 22 2963 45 GASLIMIT 2964 13 SGT 2965 4D 4D 2966 2A 2A 2967 55 SSTORE 2968 0C 0C 2969 5D 5D 296A 32 ORIGIN 296B 65 PUSH6 0x1b6d3a750626 2972 42 TIMESTAMP 2973 62 PUSH3 0x237d46 2977 85 DUP6 2978 14 EQ 2979 80 DUP1 297A 4E 4E 297B 8D DUP14 297C 2B 2B 297D 95 SWAP6 297E 56 *JUMP 297F 9D SWAP14 2980 0D 0D 2981 49 49 2982 5E 5E 2983 A5 A5 2984 33 CALLER 2985 A9 A9 2986 66 PUSH7 0xb11c886eb93bc1 298E 76 PUSH23 0xc9071727374353637324837e9b47af86c7155181ad4fd1 29A6 8E DUP15 29A7 D3 D3 29A8 2C 2C 29A9 90 SWAP1 29AA 96 SWAP7 29AB DB DB 29AC 57 *JUMPI 29AD D5 D5 29AE 9E SWAP15 29AF E3 E3 29B0 0E 0E 29B1 2E 2E 29B2 4A 4A 29B3 6A PUSH11 0x5f92a6be3498aae067ddb2 29BF EB EB 29C0 1D SAR 29C1 59 MSIZE 29C2 89 DUP10 29C3 B5 B5 29C4 6F PUSH16 0xd7baf33ca0c2ee77e5caf7ff08101820 29D5 28 28 29D6 30 ADDRESS 29D7 38 CODESIZE 29D8 40 BLOCKHASH 29D9 44 DIFFICULTY 29DA 4C 4C 29DB 54 SLOAD 29DC 5C 5C 29DD 64 PUSH5 0x6c7425617c 29E3 84 DUP5 29E4 7F PUSH32 0x8c949c48a4a8b087b8c0c816365272829aaec650acd0d28fdad4e22d6991bd97 2A05 DF DF 2A06 DC DC 2A07 EA EA 2A08 58 PC 2A09 B4 B4 2A0A D6 D6 2A0B F2 CALLCODE 2A0C 9F SWAP16 2A0D ED ED 2A0E E4 E4 2A0F F6 F6 2A10 FE *ASSERT 2A11 0F 0F 2A12 1F 1F 2A13 2F 2F 2A14 3F EXTCODEHASH 2A15 4B 4B 2A16 5B JUMPDEST 2A17 6B PUSH12 0x607b8b93a3a7b7bf357199c5 2A24 AB AB 2A25 CF CF 2A26 D9 D9 2A27 E1 E1 2A28 68 PUSH9 0xbcdee9b3f1ecf5fd1e 2A32 3E RETURNDATACOPY 2A33 5A GAS 2A34 7A PUSH27 0x8aa2b670c4ced8bbe8f0f4fc3d79a1c3cde7effb78cce6facbf9f8 2A50 A2 LOG2 2A51 64 PUSH5 0x6970667358 2A57 22 22 2A58 12 SLT 2A59 20 SHA3 2A5A 42 TIMESTAMP 2A5B 2A 2A 2A5C 8E DUP15 2A5D 84 DUP5 2A5E 5A GAS 2A5F 43 NUMBER 2A60 1B SHL 2A61 D9 D9 2A62 91 SWAP2 2A63 B5 B5 2A64 0A EXP 2A65 0C 0C 2A66 D9 D9 2A67 0B SIGNEXTEND 2A68 BB BB 2A69 29 29 2A6A B6 B6 2A6B D4 D4 2A6C 6D PUSH14 0x645635ee704a0513242e04685764 2A7B 73 PUSH20 0x6f6c63430008110033