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 0x02ad 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x02ad, if msg.data.length < 0x04 label_001A: // Incoming jump from 0x0019, if not msg.data.length < 0x04 // Inputs[1] { @001C msg.data[0x00:0x20] } 001A 60 PUSH1 0x00 001C 35 CALLDATALOAD 001D 60 PUSH1 0xe0 001F 1C SHR 0020 80 DUP1 0021 63 PUSH4 0x70a08231 0026 11 GT 0027 61 PUSH2 0x017b 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x017b, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xa217fddf 0031 11 GT 0032 61 PUSH2 0x00d8 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d8, if 0xa217fddf > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xa217fddf > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xd4a6a2fd 003C 11 GT 003D 61 PUSH2 0x008c 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008c, if 0xd4a6a2fd > stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xd4a6a2fd > stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe985e9c5 0047 11 GT 0048 61 PUSH2 0x0071 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xe985e9c5 > stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe985e9c5 > stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe985e9c5 0052 14 EQ 0053 61 PUSH2 0x05d9 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d9, if 0xe985e9c5 == stack[-1] label_0057: // Incoming jump from 0x0056, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0057 stack[-1] } 0057 80 DUP1 0058 63 PUSH4 0xf2fde38b 005D 14 EQ 005E 61 PUSH2 0x0615 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0615, if 0xf2fde38b == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xffe630b5 0068 14 EQ 0069 61 PUSH2 0x0628 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0628, if 0xffe630b5 == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xffe630b5 == 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 0x004B, if 0xe985e9c5 > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0xd4a6a2fd 0078 14 EQ 0079 61 PUSH2 0x05b9 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b9, if 0xd4a6a2fd == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0xd4a6a2fd == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0xd547741f 0083 14 EQ 0084 61 PUSH2 0x05c6 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05c6, if 0xd547741f == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0xd547741f == stack[-1] // Inputs[1] { @008B memory[0x00:0x00] } 0088 60 PUSH1 0x00 008A 80 DUP1 008B FD *REVERT // Stack delta = +0 // Outputs[1] { @008B revert(memory[0x00:0x00]); } // Block terminates label_008C: // Incoming jump from 0x0040, if 0xd4a6a2fd > stack[-1] // Inputs[1] { @008D stack[-1] } 008C 5B JUMPDEST 008D 80 DUP1 008E 63 PUSH4 0xaa1b103f 0093 11 GT 0094 61 PUSH2 0x00bd 0097 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bd, if 0xaa1b103f > stack[-1] label_0098: // Incoming jump from 0x0097, if not 0xaa1b103f > stack[-1] // Inputs[1] { @0098 stack[-1] } 0098 80 DUP1 0099 63 PUSH4 0xaa1b103f 009E 14 EQ 009F 61 PUSH2 0x058b 00A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058b, if 0xaa1b103f == stack[-1] label_00A3: // Incoming jump from 0x00A2, if not 0xaa1b103f == stack[-1] // Inputs[1] { @00A3 stack[-1] } 00A3 80 DUP1 00A4 63 PUSH4 0xb88d4fde 00A9 14 EQ 00AA 61 PUSH2 0x0593 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0593, if 0xb88d4fde == stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0xc87b56dd 00B4 14 EQ 00B5 61 PUSH2 0x05a6 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a6, if 0xc87b56dd == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0xc87b56dd == stack[-1] // Inputs[1] { @00BC memory[0x00:0x00] } 00B9 60 PUSH1 0x00 00BB 80 DUP1 00BC FD *REVERT // Stack delta = +0 // Outputs[1] { @00BC revert(memory[0x00:0x00]); } // Block terminates label_00BD: // Incoming jump from 0x0097, if 0xaa1b103f > stack[-1] // Inputs[1] { @00BE stack[-1] } 00BD 5B JUMPDEST 00BE 80 DUP1 00BF 63 PUSH4 0xa217fddf 00C4 14 EQ 00C5 61 PUSH2 0x0570 00C8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0570, if 0xa217fddf == stack[-1] label_00C9: // Incoming jump from 0x00C8, if not 0xa217fddf == stack[-1] // Inputs[1] { @00C9 stack[-1] } 00C9 80 DUP1 00CA 63 PUSH4 0xa22cb465 00CF 14 EQ 00D0 61 PUSH2 0x0578 00D3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0578, if 0xa22cb465 == stack[-1] label_00D4: // Incoming jump from 0x00D3, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00D7 memory[0x00:0x00] } 00D4 60 PUSH1 0x00 00D6 80 DUP1 00D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D7 revert(memory[0x00:0x00]); } // Block terminates label_00D8: // Incoming jump from 0x0035, if 0xa217fddf > stack[-1] // Inputs[1] { @00D9 stack[-1] } 00D8 5B JUMPDEST 00D9 80 DUP1 00DA 63 PUSH4 0x90515e24 00DF 11 GT 00E0 61 PUSH2 0x012f 00E3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x012f, if 0x90515e24 > stack[-1] label_00E4: // Incoming jump from 0x00E3, if not 0x90515e24 > stack[-1] // Inputs[1] { @00E4 stack[-1] } 00E4 80 DUP1 00E5 63 PUSH4 0x94b059ab 00EA 11 GT 00EB 61 PUSH2 0x0114 00EE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0114, if 0x94b059ab > stack[-1] label_00EF: // Incoming jump from 0x00EE, if not 0x94b059ab > stack[-1] // Inputs[1] { @00EF stack[-1] } 00EF 80 DUP1 00F0 63 PUSH4 0x94b059ab 00F5 14 EQ 00F6 61 PUSH2 0x052e 00F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052e, if 0x94b059ab == stack[-1] label_00FA: // Incoming jump from 0x00F9, if not 0x94b059ab == stack[-1] // Inputs[1] { @00FA stack[-1] } 00FA 80 DUP1 00FB 63 PUSH4 0x95d89b41 0100 14 EQ 0101 61 PUSH2 0x0555 0104 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0555, if 0x95d89b41 == stack[-1] label_0105: // Incoming jump from 0x0104, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0105 stack[-1] } 0105 80 DUP1 0106 63 PUSH4 0x9e34070f 010B 14 EQ 010C 61 PUSH2 0x055d 010F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x055d, if 0x9e34070f == stack[-1] label_0110: // Incoming jump from 0x010F, if not 0x9e34070f == stack[-1] // Inputs[1] { @0113 memory[0x00:0x00] } 0110 60 PUSH1 0x00 0112 80 DUP1 0113 FD *REVERT // Stack delta = +0 // Outputs[1] { @0113 revert(memory[0x00:0x00]); } // Block terminates label_0114: // Incoming jump from 0x00EE, if 0x94b059ab > stack[-1] // Inputs[1] { @0115 stack[-1] } 0114 5B JUMPDEST 0115 80 DUP1 0116 63 PUSH4 0x90515e24 011B 14 EQ 011C 61 PUSH2 0x04ce 011F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ce, if 0x90515e24 == stack[-1] label_0120: // Incoming jump from 0x011F, if not 0x90515e24 == stack[-1] // Inputs[1] { @0120 stack[-1] } 0120 80 DUP1 0121 63 PUSH4 0x91d14854 0126 14 EQ 0127 61 PUSH2 0x04f5 012A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f5, if 0x91d14854 == stack[-1] label_012B: // Incoming jump from 0x012A, if not 0x91d14854 == stack[-1] // Inputs[1] { @012E memory[0x00:0x00] } 012B 60 PUSH1 0x00 012D 80 DUP1 012E FD *REVERT // Stack delta = +0 // Outputs[1] { @012E revert(memory[0x00:0x00]); } // Block terminates label_012F: // Incoming jump from 0x00E3, if 0x90515e24 > stack[-1] // Inputs[1] { @0130 stack[-1] } 012F 5B JUMPDEST 0130 80 DUP1 0131 63 PUSH4 0x73417b09 0136 11 GT 0137 61 PUSH2 0x0160 013A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0160, if 0x73417b09 > stack[-1] label_013B: // Incoming jump from 0x013A, if not 0x73417b09 > stack[-1] // Inputs[1] { @013B stack[-1] } 013B 80 DUP1 013C 63 PUSH4 0x73417b09 0141 14 EQ 0142 61 PUSH2 0x0497 0145 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0497, if 0x73417b09 == stack[-1] label_0146: // Incoming jump from 0x0145, if not 0x73417b09 == stack[-1] // Inputs[1] { @0146 stack[-1] } 0146 80 DUP1 0147 63 PUSH4 0x8a616bc0 014C 14 EQ 014D 61 PUSH2 0x04aa 0150 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04aa, if 0x8a616bc0 == stack[-1] label_0151: // Incoming jump from 0x0150, if not 0x8a616bc0 == stack[-1] // Inputs[1] { @0151 stack[-1] } 0151 80 DUP1 0152 63 PUSH4 0x8da5cb5b 0157 14 EQ 0158 61 PUSH2 0x04bd 015B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04bd, if 0x8da5cb5b == stack[-1] label_015C: // Incoming jump from 0x015B, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @015F memory[0x00:0x00] } 015C 60 PUSH1 0x00 015E 80 DUP1 015F FD *REVERT // Stack delta = +0 // Outputs[1] { @015F revert(memory[0x00:0x00]); } // Block terminates label_0160: // Incoming jump from 0x013A, if 0x73417b09 > stack[-1] // Inputs[1] { @0161 stack[-1] } 0160 5B JUMPDEST 0161 80 DUP1 0162 63 PUSH4 0x70a08231 0167 14 EQ 0168 61 PUSH2 0x047c 016B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047c, if 0x70a08231 == stack[-1] label_016C: // Incoming jump from 0x016B, if not 0x70a08231 == stack[-1] // Inputs[1] { @016C stack[-1] } 016C 80 DUP1 016D 63 PUSH4 0x715018a6 0172 14 EQ 0173 61 PUSH2 0x048f 0176 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048f, if 0x715018a6 == stack[-1] label_0177: // Incoming jump from 0x0176, if not 0x715018a6 == stack[-1] // Inputs[1] { @017A memory[0x00:0x00] } 0177 60 PUSH1 0x00 0179 80 DUP1 017A FD *REVERT // Stack delta = +0 // Outputs[1] { @017A revert(memory[0x00:0x00]); } // Block terminates label_017B: // Incoming jump from 0x002A, if 0x70a08231 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @017C stack[-1] } 017B 5B JUMPDEST 017C 80 DUP1 017D 63 PUSH4 0x2a55205a 0182 11 GT 0183 61 PUSH2 0x0229 0186 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0229, if 0x2a55205a > stack[-1] label_0187: // Incoming jump from 0x0186, if not 0x2a55205a > stack[-1] // Inputs[1] { @0187 stack[-1] } 0187 80 DUP1 0188 63 PUSH4 0x42966c68 018D 11 GT 018E 61 PUSH2 0x01dd 0191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01dd, if 0x42966c68 > stack[-1] label_0192: // Incoming jump from 0x0191, if not 0x42966c68 > stack[-1] // Inputs[1] { @0192 stack[-1] } 0192 80 DUP1 0193 63 PUSH4 0x55f804b3 0198 11 GT 0199 61 PUSH2 0x01c2 019C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c2, if 0x55f804b3 > stack[-1] label_019D: // Incoming jump from 0x019C, if not 0x55f804b3 > stack[-1] // Inputs[1] { @019D stack[-1] } 019D 80 DUP1 019E 63 PUSH4 0x55f804b3 01A3 14 EQ 01A4 61 PUSH2 0x0443 01A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0443, if 0x55f804b3 == stack[-1] label_01A8: // Incoming jump from 0x01A7, if not 0x55f804b3 == stack[-1] // Inputs[1] { @01A8 stack[-1] } 01A8 80 DUP1 01A9 63 PUSH4 0x5944c753 01AE 14 EQ 01AF 61 PUSH2 0x0456 01B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0456, if 0x5944c753 == stack[-1] label_01B3: // Incoming jump from 0x01B2, if not 0x5944c753 == stack[-1] // Inputs[1] { @01B3 stack[-1] } 01B3 80 DUP1 01B4 63 PUSH4 0x6352211e 01B9 14 EQ 01BA 61 PUSH2 0x0469 01BD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0469, if 0x6352211e == stack[-1] label_01BE: // Incoming jump from 0x01BD, if not 0x6352211e == stack[-1] // Inputs[1] { @01C1 memory[0x00:0x00] } 01BE 60 PUSH1 0x00 01C0 80 DUP1 01C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C1 revert(memory[0x00:0x00]); } // Block terminates label_01C2: // Incoming jump from 0x019C, if 0x55f804b3 > stack[-1] // Inputs[1] { @01C3 stack[-1] } 01C2 5B JUMPDEST 01C3 80 DUP1 01C4 63 PUSH4 0x42966c68 01C9 14 EQ 01CA 61 PUSH2 0x0428 01CD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0428, if 0x42966c68 == stack[-1] label_01CE: // Incoming jump from 0x01CD, if not 0x42966c68 == stack[-1] // Inputs[1] { @01CE stack[-1] } 01CE 80 DUP1 01CF 63 PUSH4 0x4e71d92d 01D4 14 EQ 01D5 61 PUSH2 0x043b 01D8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x043b, if 0x4e71d92d == stack[-1] label_01D9: // Incoming jump from 0x01D8, if not 0x4e71d92d == stack[-1] // Inputs[1] { @01DC memory[0x00:0x00] } 01D9 60 PUSH1 0x00 01DB 80 DUP1 01DC FD *REVERT // Stack delta = +0 // Outputs[1] { @01DC revert(memory[0x00:0x00]); } // Block terminates label_01DD: // Incoming jump from 0x0191, if 0x42966c68 > stack[-1] // Inputs[1] { @01DE stack[-1] } 01DD 5B JUMPDEST 01DE 80 DUP1 01DF 63 PUSH4 0x2f2ff15d 01E4 11 GT 01E5 61 PUSH2 0x020e 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020e, if 0x2f2ff15d > stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x2f2ff15d > stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x2f2ff15d 01EF 14 EQ 01F0 61 PUSH2 0x03ef 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03ef, if 0x2f2ff15d == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x2f2ff15d == stack[-1] // Inputs[1] { @01F4 stack[-1] } 01F4 80 DUP1 01F5 63 PUSH4 0x36568abe 01FA 14 EQ 01FB 61 PUSH2 0x0402 01FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0402, if 0x36568abe == stack[-1] label_01FF: // Incoming jump from 0x01FE, if not 0x36568abe == stack[-1] // Inputs[1] { @01FF stack[-1] } 01FF 80 DUP1 0200 63 PUSH4 0x42842e0e 0205 14 EQ 0206 61 PUSH2 0x0415 0209 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0415, if 0x42842e0e == stack[-1] label_020A: // Incoming jump from 0x0209, if not 0x42842e0e == stack[-1] // Inputs[1] { @020D memory[0x00:0x00] } 020A 60 PUSH1 0x00 020C 80 DUP1 020D FD *REVERT // Stack delta = +0 // Outputs[1] { @020D revert(memory[0x00:0x00]); } // Block terminates label_020E: // Incoming jump from 0x01E8, if 0x2f2ff15d > stack[-1] // Inputs[1] { @020F stack[-1] } 020E 5B JUMPDEST 020F 80 DUP1 0210 63 PUSH4 0x2a55205a 0215 14 EQ 0216 61 PUSH2 0x0396 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0396, if 0x2a55205a == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x2a55205a == stack[-1] // Inputs[1] { @021A stack[-1] } 021A 80 DUP1 021B 63 PUSH4 0x2e126f48 0220 14 EQ 0221 61 PUSH2 0x03c8 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c8, if 0x2e126f48 == stack[-1] label_0225: // Incoming jump from 0x0224, if not 0x2e126f48 == stack[-1] // Inputs[1] { @0228 memory[0x00:0x00] } 0225 60 PUSH1 0x00 0227 80 DUP1 0228 FD *REVERT // Stack delta = +0 // Outputs[1] { @0228 revert(memory[0x00:0x00]); } // Block terminates label_0229: // Incoming jump from 0x0186, if 0x2a55205a > stack[-1] // Inputs[1] { @022A stack[-1] } 0229 5B JUMPDEST 022A 80 DUP1 022B 63 PUSH4 0x095ea7b3 0230 11 GT 0231 61 PUSH2 0x0280 0234 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0280, if 0x095ea7b3 > stack[-1] label_0235: // Incoming jump from 0x0234, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @0235 stack[-1] } 0235 80 DUP1 0236 63 PUSH4 0x18160ddd 023B 11 GT 023C 61 PUSH2 0x0265 023F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0265, if 0x18160ddd > stack[-1] label_0240: // Incoming jump from 0x023F, if not 0x18160ddd > stack[-1] // Inputs[1] { @0240 stack[-1] } 0240 80 DUP1 0241 63 PUSH4 0x18160ddd 0246 14 EQ 0247 61 PUSH2 0x034a 024A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034a, if 0x18160ddd == stack[-1] label_024B: // Incoming jump from 0x024A, if not 0x18160ddd == stack[-1] // Inputs[1] { @024B stack[-1] } 024B 80 DUP1 024C 63 PUSH4 0x23b872dd 0251 14 EQ 0252 61 PUSH2 0x0360 0255 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0360, if 0x23b872dd == stack[-1] label_0256: // Incoming jump from 0x0255, if not 0x23b872dd == stack[-1] // Inputs[1] { @0256 stack[-1] } 0256 80 DUP1 0257 63 PUSH4 0x248a9ca3 025C 14 EQ 025D 61 PUSH2 0x0373 0260 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0373, if 0x248a9ca3 == stack[-1] label_0261: // Incoming jump from 0x0260, if not 0x248a9ca3 == stack[-1] // Inputs[1] { @0264 memory[0x00:0x00] } 0261 60 PUSH1 0x00 0263 80 DUP1 0264 FD *REVERT // Stack delta = +0 // Outputs[1] { @0264 revert(memory[0x00:0x00]); } // Block terminates label_0265: // Incoming jump from 0x023F, if 0x18160ddd > stack[-1] // Inputs[1] { @0266 stack[-1] } 0265 5B JUMPDEST 0266 80 DUP1 0267 63 PUSH4 0x095ea7b3 026C 14 EQ 026D 61 PUSH2 0x032f 0270 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x032f, if 0x095ea7b3 == stack[-1] label_0271: // Incoming jump from 0x0270, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0271 stack[-1] } 0271 80 DUP1 0272 63 PUSH4 0x0f7309e8 0277 14 EQ 0278 61 PUSH2 0x0342 027B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0342, if 0x0f7309e8 == stack[-1] label_027C: // Incoming jump from 0x027B, if not 0x0f7309e8 == stack[-1] // Inputs[1] { @027F memory[0x00:0x00] } 027C 60 PUSH1 0x00 027E 80 DUP1 027F FD *REVERT // Stack delta = +0 // Outputs[1] { @027F revert(memory[0x00:0x00]); } // Block terminates label_0280: // Incoming jump from 0x0234, if 0x095ea7b3 > stack[-1] // Inputs[1] { @0281 stack[-1] } 0280 5B JUMPDEST 0281 80 DUP1 0282 63 PUSH4 0x01ffc9a7 0287 14 EQ 0288 61 PUSH2 0x02b2 028B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b2, if 0x01ffc9a7 == stack[-1] label_028C: // Incoming jump from 0x028B, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @028C stack[-1] } 028C 80 DUP1 028D 63 PUSH4 0x04634d8d 0292 14 EQ 0293 61 PUSH2 0x02da 0296 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02da, if 0x04634d8d == stack[-1] label_0297: // Incoming jump from 0x0296, if not 0x04634d8d == stack[-1] // Inputs[1] { @0297 stack[-1] } 0297 80 DUP1 0298 63 PUSH4 0x06fdde03 029D 14 EQ 029E 61 PUSH2 0x02ef 02A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ef, if 0x06fdde03 == stack[-1] label_02A2: // Incoming jump from 0x02A1, if not 0x06fdde03 == stack[-1] // Inputs[1] { @02A2 stack[-1] } 02A2 80 DUP1 02A3 63 PUSH4 0x081812fc 02A8 14 EQ 02A9 61 PUSH2 0x0304 02AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0304, if 0x081812fc == stack[-1] label_02AD: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x02AC, if not 0x081812fc == stack[-1] // Inputs[1] { @02B1 memory[0x00:0x00] } 02AD 5B JUMPDEST 02AE 60 PUSH1 0x00 02B0 80 DUP1 02B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B1 revert(memory[0x00:0x00]); } // Block terminates label_02B2: // Incoming jump from 0x028B, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @02B9 msg.data.length } 02B2 5B JUMPDEST 02B3 61 PUSH2 0x02c5 02B6 61 PUSH2 0x02c0 02B9 36 CALLDATASIZE 02BA 60 PUSH1 0x04 02BC 61 PUSH2 0x27e9 02BF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02B3 stack[0] = 0x02c5 // @02B6 stack[1] = 0x02c0 // @02B9 stack[2] = msg.data.length // @02BA stack[3] = 0x04 // } // Block ends with call to 0x27e9, returns to 0x02C0 label_02C0: // Incoming return from call to 0x27E9 at 0x02BF 02C0 5B JUMPDEST 02C1 61 PUSH2 0x063b 02C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x063b label_02C5: // Incoming return from call to 0x056B at 0x056A // Incoming jump from 0x05C5 // Incoming return from call to 0x0503 at 0x0502 // Inputs[4] // { // @02C8 memory[0x40:0x60] // @02C9 stack[-1] // @02D4 memory[0x40:0x60] // @02D9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02C5 5B JUMPDEST 02C6 60 PUSH1 0x40 02C8 51 MLOAD 02C9 90 SWAP1 02CA 15 ISZERO 02CB 15 ISZERO 02CC 81 DUP2 02CD 52 MSTORE 02CE 60 PUSH1 0x20 02D0 01 ADD 02D1 5B JUMPDEST 02D2 60 PUSH1 0x40 02D4 51 MLOAD 02D5 80 DUP1 02D6 91 SWAP2 02D7 03 SUB 02D8 90 SWAP1 02D9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02CD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @02D9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02DA: // Incoming jump from 0x0296, if 0x04634d8d == stack[-1] // Inputs[1] { @02E1 msg.data.length } 02DA 5B JUMPDEST 02DB 61 PUSH2 0x02ed 02DE 61 PUSH2 0x02e8 02E1 36 CALLDATASIZE 02E2 60 PUSH1 0x04 02E4 61 PUSH2 0x2768 02E7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DB stack[0] = 0x02ed // @02DE stack[1] = 0x02e8 // @02E1 stack[2] = msg.data.length // @02E2 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2768 02E8 5B JUMPDEST 02E9 61 PUSH2 0x064c 02EC 56 *JUMP label_02ED: // Incoming return from call to 0x0F13 at 0x0496 // Incoming return from call to 0x05A1 at 0x05A0 // Incoming return from call to 0x0436 at 0x0435 // Incoming return from call to 0x033D at 0x033C 02ED 5B JUMPDEST 02EE 00 *STOP // Stack delta = +0 // Outputs[1] { @02EE stop(); } // Block terminates label_02EF: // Incoming jump from 0x02A1, if 0x06fdde03 == stack[-1] 02EF 5B JUMPDEST 02F0 61 PUSH2 0x02f7 02F3 61 PUSH2 0x0685 02F6 56 *JUMP // Stack delta = +1 // Outputs[1] { @02F0 stack[0] = 0x02f7 } // Block ends with call to 0x0685, returns to 0x02F7 label_02F7: // Incoming return from call to 0x0FF3 at 0x055C // Incoming return from call to 0x0828 at 0x0349 // Incoming return from call to 0x0685 at 0x02F6 // Inputs[2] // { // @02FA memory[0x40:0x60] // @02FE stack[-1] // } 02F7 5B JUMPDEST 02F8 60 PUSH1 0x40 02FA 51 MLOAD 02FB 61 PUSH2 0x02d1 02FE 91 SWAP2 02FF 90 SWAP1 0300 61 PUSH2 0x29fb 0303 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @02FE stack[-1] = 0x02d1 // @02FF stack[1] = memory[0x40:0x60] // @02FF stack[0] = stack[-1] // } // Block ends with call to 0x29fb, returns to 0x02D1 label_0304: // Incoming jump from 0x02AC, if 0x081812fc == stack[-1] // Inputs[1] { @030B msg.data.length } 0304 5B JUMPDEST 0305 61 PUSH2 0x0317 0308 61 PUSH2 0x0312 030B 36 CALLDATASIZE 030C 60 PUSH1 0x04 030E 61 PUSH2 0x27ad 0311 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0305 stack[0] = 0x0317 // @0308 stack[1] = 0x0312 // @030B stack[2] = msg.data.length // @030C stack[3] = 0x04 // } // Block ends with call to 0x27ad, returns to 0x0312 label_0312: // Incoming return from call to 0x27AD at 0x0311 0312 5B JUMPDEST 0313 61 PUSH2 0x0717 0316 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0717 label_0317: // Incoming return from call to 0x0477 at 0x0476 // Incoming jump from 0x04F4 // Incoming return from call to 0x0312 at 0x0311 // Incoming jump from 0x04CD // Incoming jump from 0x03EE // Inputs[2] // { // @031A memory[0x40:0x60] // @0324 stack[-1] // } 0317 5B JUMPDEST 0318 60 PUSH1 0x40 031A 51 MLOAD 031B 60 PUSH1 0x01 031D 60 PUSH1 0x01 031F 60 PUSH1 0xa0 0321 1B SHL 0322 03 SUB 0323 90 SWAP1 0324 91 SWAP2 0325 16 AND 0326 81 DUP2 0327 52 MSTORE 0328 60 PUSH1 0x20 032A 01 ADD 032B 61 PUSH2 0x02d1 032E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0327 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @032A stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02d1 label_032F: // Incoming jump from 0x0270, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0336 msg.data.length } 032F 5B JUMPDEST 0330 61 PUSH2 0x02ed 0333 61 PUSH2 0x033d 0336 36 CALLDATASIZE 0337 60 PUSH1 0x04 0339 61 PUSH2 0x273e 033C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0330 stack[0] = 0x02ed // @0333 stack[1] = 0x033d // @0336 stack[2] = msg.data.length // @0337 stack[3] = 0x04 // } // Block ends with call to 0x273e, returns to 0x033D label_033D: // Incoming return from call to 0x273E at 0x033C 033D 5B JUMPDEST 033E 61 PUSH2 0x0774 0341 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0774 label_0342: // Incoming jump from 0x027B, if 0x0f7309e8 == stack[-1] 0342 5B JUMPDEST 0343 61 PUSH2 0x02f7 0346 61 PUSH2 0x0828 0349 56 *JUMP // Stack delta = +1 // Outputs[1] { @0343 stack[0] = 0x02f7 } // Block ends with call to 0x0828, returns to 0x02F7 label_034A: // Incoming jump from 0x024A, if 0x18160ddd == stack[-1] // Inputs[2] // { // @034D storage[0x01] // @0350 storage[0x00] // } 034A 5B JUMPDEST 034B 60 PUSH1 0x01 034D 54 SLOAD 034E 60 PUSH1 0x00 0350 54 SLOAD 0351 03 SUB // Stack delta = +1 // Outputs[1] { @0351 stack[0] = storage[0x00] - storage[0x01] } // Block continues label_0352: // Incoming return from call to 0x0381 at 0x0380 // Incoming jump from 0x0351 // Incoming jump from 0x0577 // Incoming return from call to 0x048A at 0x0489 // Incoming jump from 0x0554 // Inputs[2] // { // @0355 memory[0x40:0x60] // @0356 stack[-1] // } 0352 5B JUMPDEST 0353 60 PUSH1 0x40 0355 51 MLOAD 0356 90 SWAP1 0357 81 DUP2 0358 52 MSTORE 0359 60 PUSH1 0x20 035B 01 ADD 035C 61 PUSH2 0x02d1 035F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0358 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @035B stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02d1 label_0360: // Incoming jump from 0x0255, if 0x23b872dd == stack[-1] // Inputs[1] { @0367 msg.data.length } 0360 5B JUMPDEST 0361 61 PUSH2 0x02ed 0364 61 PUSH2 0x036e 0367 36 CALLDATASIZE 0368 60 PUSH1 0x04 036A 61 PUSH2 0x265c 036D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0361 stack[0] = 0x02ed // @0364 stack[1] = 0x036e // @0367 stack[2] = msg.data.length // @0368 stack[3] = 0x04 // } // Block ends with call to 0x265c, returns to 0x036E label_036E: // Incoming return from call to 0x265C at 0x036D 036E 5B JUMPDEST 036F 61 PUSH2 0x08b6 0372 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08b6 label_0373: // Incoming jump from 0x0260, if 0x248a9ca3 == stack[-1] // Inputs[1] { @037A msg.data.length } 0373 5B JUMPDEST 0374 61 PUSH2 0x0352 0377 61 PUSH2 0x0381 037A 36 CALLDATASIZE 037B 60 PUSH1 0x04 037D 61 PUSH2 0x27ad 0380 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0374 stack[0] = 0x0352 // @0377 stack[1] = 0x0381 // @037A stack[2] = msg.data.length // @037B stack[3] = 0x04 // } // Block ends with call to 0x27ad, returns to 0x0381 label_0381: // Incoming return from call to 0x27AD at 0x0380 // Inputs[4] // { // @0384 stack[-1] // @038F memory[0x00:0x40] // @0393 storage[0x01 + keccak256(memory[0x00:0x40])] // @0394 stack[-2] // } 0381 5B JUMPDEST 0382 60 PUSH1 0x00 0384 90 SWAP1 0385 81 DUP2 0386 52 MSTORE 0387 60 PUSH1 0x0b 0389 60 PUSH1 0x20 038B 52 MSTORE 038C 60 PUSH1 0x40 038E 90 SWAP1 038F 20 SHA3 0390 60 PUSH1 0x01 0392 01 ADD 0393 54 SLOAD 0394 90 SWAP1 0395 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0386 memory[0x00:0x20] = stack[-1] // @038B memory[0x20:0x40] = 0x0b // @0394 stack[-2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_0396: // Incoming jump from 0x0219, if 0x2a55205a == stack[-1] // Inputs[1] { @039D msg.data.length } 0396 5B JUMPDEST 0397 61 PUSH2 0x03a9 039A 61 PUSH2 0x03a4 039D 36 CALLDATASIZE 039E 60 PUSH1 0x04 03A0 61 PUSH2 0x28c1 03A3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0397 stack[0] = 0x03a9 // @039A stack[1] = 0x03a4 // @039D stack[2] = msg.data.length // @039E stack[3] = 0x04 // } // Block ends with call to 0x28c1, returns to 0x03A4 label_03A4: // Incoming return from call to 0x28C1 at 0x03A3 03A4 5B JUMPDEST 03A5 61 PUSH2 0x08c1 03A8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08c1 label_03A9: // Incoming return from call to 0x03A4 at 0x03A3 // Inputs[3] // { // @03AD memory[0x40:0x60] // @03B7 stack[-2] // @03BF stack[-1] // } 03A9 5B JUMPDEST 03AA 60 PUSH1 0x40 03AC 80 DUP1 03AD 51 MLOAD 03AE 60 PUSH1 0x01 03B0 60 PUSH1 0x01 03B2 60 PUSH1 0xa0 03B4 1B SHL 03B5 03 SUB 03B6 90 SWAP1 03B7 93 SWAP4 03B8 16 AND 03B9 83 DUP4 03BA 52 MSTORE 03BB 60 PUSH1 0x20 03BD 83 DUP4 03BE 01 ADD 03BF 91 SWAP2 03C0 90 SWAP1 03C1 91 SWAP2 03C2 52 MSTORE 03C3 01 ADD 03C4 61 PUSH2 0x02d1 03C7 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @03BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @03C2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @03C3 stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x02d1 label_03C8: // Incoming jump from 0x0224, if 0x2e126f48 == stack[-1] 03C8 5B JUMPDEST 03C9 61 PUSH2 0x0317 03CC 7F PUSH32 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8 03ED 81 DUP2 03EE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @03C9 stack[0] = 0x0317 // @03CC stack[1] = 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8 // } // Block ends with unconditional jump to 0x0317 label_03EF: // Incoming jump from 0x01F3, if 0x2f2ff15d == stack[-1] // Inputs[1] { @03F6 msg.data.length } 03EF 5B JUMPDEST 03F0 61 PUSH2 0x02ed 03F3 61 PUSH2 0x03fd 03F6 36 CALLDATASIZE 03F7 60 PUSH1 0x04 03F9 61 PUSH2 0x27c6 03FC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03F0 stack[0] = 0x02ed // @03F3 stack[1] = 0x03fd // @03F6 stack[2] = msg.data.length // @03F7 stack[3] = 0x04 // } // Block ends with call to 0x27c6, returns to 0x03FD label_03FD: // Incoming return from call to 0x27C6 at 0x03FC 03FD 5B JUMPDEST 03FE 61 PUSH2 0x097c 0401 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x097c label_0402: // Incoming jump from 0x01FE, if 0x36568abe == stack[-1] // Inputs[1] { @0409 msg.data.length } 0402 5B JUMPDEST 0403 61 PUSH2 0x02ed 0406 61 PUSH2 0x0410 0409 36 CALLDATASIZE 040A 60 PUSH1 0x04 040C 61 PUSH2 0x27c6 040F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0403 stack[0] = 0x02ed // @0406 stack[1] = 0x0410 // @0409 stack[2] = msg.data.length // @040A stack[3] = 0x04 // } // Block ends with call to 0x27c6, returns to 0x0410 label_0410: // Incoming return from call to 0x27C6 at 0x040F 0410 5B JUMPDEST 0411 61 PUSH2 0x09a1 0414 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x09a1 label_0415: // Incoming jump from 0x0209, if 0x42842e0e == stack[-1] // Inputs[1] { @041C msg.data.length } 0415 5B JUMPDEST 0416 61 PUSH2 0x02ed 0419 61 PUSH2 0x0423 041C 36 CALLDATASIZE 041D 60 PUSH1 0x04 041F 61 PUSH2 0x265c 0422 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0416 stack[0] = 0x02ed // @0419 stack[1] = 0x0423 // @041C stack[2] = msg.data.length // @041D stack[3] = 0x04 // } // Block ends with call to 0x265c, returns to 0x0423 label_0423: // Incoming return from call to 0x265C at 0x0422 0423 5B JUMPDEST 0424 61 PUSH2 0x0a32 0427 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a32 label_0428: // Incoming jump from 0x01CD, if 0x42966c68 == stack[-1] // Inputs[1] { @042F msg.data.length } 0428 5B JUMPDEST 0429 61 PUSH2 0x02ed 042C 61 PUSH2 0x0436 042F 36 CALLDATASIZE 0430 60 PUSH1 0x04 0432 61 PUSH2 0x27ad 0435 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0429 stack[0] = 0x02ed // @042C stack[1] = 0x0436 // @042F stack[2] = msg.data.length // @0430 stack[3] = 0x04 // } // Block ends with call to 0x27ad, returns to 0x0436 label_0436: // Incoming return from call to 0x27AD at 0x0435 0436 5B JUMPDEST 0437 61 PUSH2 0x0a4d 043A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a4d label_043B: // Incoming jump from 0x01D8, if 0x4e71d92d == stack[-1] 043B 5B JUMPDEST 043C 61 PUSH2 0x02ed 043F 61 PUSH2 0x0a6c 0442 56 *JUMP // Stack delta = +1 // Outputs[1] { @043C stack[0] = 0x02ed } // Block ends with unconditional jump to 0x0a6c label_0443: // Incoming jump from 0x01A7, if 0x55f804b3 == stack[-1] // Inputs[1] { @044A msg.data.length } 0443 5B JUMPDEST 0444 61 PUSH2 0x02ed 0447 61 PUSH2 0x0451 044A 36 CALLDATASIZE 044B 60 PUSH1 0x04 044D 61 PUSH2 0x2823 0450 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0444 stack[0] = 0x02ed // @0447 stack[1] = 0x0451 // @044A stack[2] = msg.data.length // @044B stack[3] = 0x04 // } // Block ends with call to 0x2823, returns to 0x0451 label_0451: // Incoming return from call to 0x2823 at 0x0450 0451 5B JUMPDEST 0452 61 PUSH2 0x0e21 0455 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e21 label_0456: // Incoming jump from 0x01B2, if 0x5944c753 == stack[-1] // Inputs[1] { @045D msg.data.length } 0456 5B JUMPDEST 0457 61 PUSH2 0x02ed 045A 61 PUSH2 0x0464 045D 36 CALLDATASIZE 045E 60 PUSH1 0x04 0460 61 PUSH2 0x2885 0463 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0457 stack[0] = 0x02ed // @045A stack[1] = 0x0464 // @045D stack[2] = msg.data.length // @045E stack[3] = 0x04 // } // Block ends with call to 0x2885, returns to 0x0464 label_0464: // Incoming return from call to 0x2885 at 0x0463 0464 5B JUMPDEST 0465 61 PUSH2 0x0e5e 0468 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e5e label_0469: // Incoming jump from 0x01BD, if 0x6352211e == stack[-1] // Inputs[1] { @0470 msg.data.length } 0469 5B JUMPDEST 046A 61 PUSH2 0x0317 046D 61 PUSH2 0x0477 0470 36 CALLDATASIZE 0471 60 PUSH1 0x04 0473 61 PUSH2 0x27ad 0476 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @046A stack[0] = 0x0317 // @046D stack[1] = 0x0477 // @0470 stack[2] = msg.data.length // @0471 stack[3] = 0x04 // } // Block ends with call to 0x27ad, returns to 0x0477 label_0477: // Incoming return from call to 0x27AD at 0x0476 0477 5B JUMPDEST 0478 61 PUSH2 0x0e99 047B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e99 label_047C: // Incoming jump from 0x016B, if 0x70a08231 == stack[-1] // Inputs[1] { @0483 msg.data.length } 047C 5B JUMPDEST 047D 61 PUSH2 0x0352 0480 61 PUSH2 0x048a 0483 36 CALLDATASIZE 0484 60 PUSH1 0x04 0486 61 PUSH2 0x260e 0489 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @047D stack[0] = 0x0352 // @0480 stack[1] = 0x048a // @0483 stack[2] = msg.data.length // @0484 stack[3] = 0x04 // } // Block ends with call to 0x260e, returns to 0x048A label_048A: // Incoming return from call to 0x260E at 0x0489 048A 5B JUMPDEST 048B 61 PUSH2 0x0eab 048E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eab label_048F: // Incoming jump from 0x0176, if 0x715018a6 == stack[-1] 048F 5B JUMPDEST 0490 61 PUSH2 0x02ed 0493 61 PUSH2 0x0f13 0496 56 *JUMP // Stack delta = +1 // Outputs[1] { @0490 stack[0] = 0x02ed } // Block ends with call to 0x0f13, returns to 0x02ED label_0497: // Incoming jump from 0x0145, if 0x73417b09 == stack[-1] // Inputs[1] { @049E msg.data.length } 0497 5B JUMPDEST 0498 61 PUSH2 0x02ed 049B 61 PUSH2 0x04a5 049E 36 CALLDATASIZE 049F 60 PUSH1 0x04 04A1 61 PUSH2 0x2792 04A4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0498 stack[0] = 0x02ed // @049B stack[1] = 0x04a5 // @049E stack[2] = msg.data.length // @049F stack[3] = 0x04 // } // Block ends with call to 0x2792, returns to 0x04A5 label_04A5: // Incoming return from call to 0x2792 at 0x04A4 04A5 5B JUMPDEST 04A6 61 PUSH2 0x0f79 04A9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f79 label_04AA: // Incoming jump from 0x0150, if 0x8a616bc0 == stack[-1] // Inputs[1] { @04B1 msg.data.length } 04AA 5B JUMPDEST 04AB 61 PUSH2 0x02ed 04AE 61 PUSH2 0x04b8 04B1 36 CALLDATASIZE 04B2 60 PUSH1 0x04 04B4 61 PUSH2 0x27ad 04B7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04AB stack[0] = 0x02ed // @04AE stack[1] = 0x04b8 // @04B1 stack[2] = msg.data.length // @04B2 stack[3] = 0x04 // } // Block ends with call to 0x27ad, returns to 0x04B8 label_04B8: // Incoming return from call to 0x27AD at 0x04B7 04B8 5B JUMPDEST 04B9 61 PUSH2 0x0fb7 04BC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fb7 label_04BD: // Incoming jump from 0x015B, if 0x8da5cb5b == stack[-1] // Inputs[1] { @04C0 storage[0x0c] } 04BD 5B JUMPDEST 04BE 60 PUSH1 0x0c 04C0 54 SLOAD 04C1 60 PUSH1 0x01 04C3 60 PUSH1 0x01 04C5 60 PUSH1 0xa0 04C7 1B SHL 04C8 03 SUB 04C9 16 AND 04CA 61 PUSH2 0x0317 04CD 56 *JUMP // Stack delta = +1 // Outputs[1] { @04C9 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0c] } // Block ends with unconditional jump to 0x0317 label_04CE: // Incoming jump from 0x011F, if 0x90515e24 == stack[-1] 04CE 5B JUMPDEST 04CF 61 PUSH2 0x0317 04D2 7F PUSH32 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e 04F3 81 DUP2 04F4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @04CF stack[0] = 0x0317 // @04D2 stack[1] = 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e // } // Block ends with unconditional jump to 0x0317 label_04F5: // Incoming jump from 0x012A, if 0x91d14854 == stack[-1] // Inputs[1] { @04FC msg.data.length } 04F5 5B JUMPDEST 04F6 61 PUSH2 0x02c5 04F9 61 PUSH2 0x0503 04FC 36 CALLDATASIZE 04FD 60 PUSH1 0x04 04FF 61 PUSH2 0x27c6 0502 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @04F6 stack[0] = 0x02c5 // @04F9 stack[1] = 0x0503 // @04FC stack[2] = msg.data.length // @04FD stack[3] = 0x04 // } // Block ends with call to 0x27c6, returns to 0x0503 label_0503: // Incoming return from call to 0x27C6 at 0x0502 // Inputs[6] // { // @0506 stack[-2] // @0514 memory[0x00:0x40] // @051D stack[-1] // @0527 memory[0x00:0x40] // @0528 storage[keccak256(memory[0x00:0x40])] // @052C stack[-3] // } 0503 5B JUMPDEST 0504 60 PUSH1 0x00 0506 91 SWAP2 0507 82 DUP3 0508 52 MSTORE 0509 60 PUSH1 0x0b 050B 60 PUSH1 0x20 050D 90 SWAP1 050E 81 DUP2 050F 52 MSTORE 0510 60 PUSH1 0x40 0512 80 DUP1 0513 84 DUP5 0514 20 SHA3 0515 60 PUSH1 0x01 0517 60 PUSH1 0x01 0519 60 PUSH1 0xa0 051B 1B SHL 051C 03 SUB 051D 93 SWAP4 051E 90 SWAP1 051F 93 SWAP4 0520 16 AND 0521 84 DUP5 0522 52 MSTORE 0523 91 SWAP2 0524 90 SWAP1 0525 52 MSTORE 0526 90 SWAP1 0527 20 SHA3 0528 54 SLOAD 0529 60 PUSH1 0xff 052B 16 AND 052C 90 SWAP1 052D 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0508 memory[0x00:0x20] = stack[-2] // @050F memory[0x20:0x40] = 0x0b // @0522 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0525 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @052C stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_052E: // Incoming jump from 0x00F9, if 0x94b059ab == stack[-1] 052E 5B JUMPDEST 052F 61 PUSH2 0x0352 0532 7F PUSH32 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b 0553 81 DUP2 0554 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @052F stack[0] = 0x0352 // @0532 stack[1] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // } // Block ends with unconditional jump to 0x0352 label_0555: // Incoming jump from 0x0104, if 0x95d89b41 == stack[-1] 0555 5B JUMPDEST 0556 61 PUSH2 0x02f7 0559 61 PUSH2 0x0ff3 055C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0556 stack[0] = 0x02f7 } // Block ends with call to 0x0ff3, returns to 0x02F7 label_055D: // Incoming jump from 0x010F, if 0x9e34070f == stack[-1] // Inputs[1] { @0564 msg.data.length } 055D 5B JUMPDEST 055E 61 PUSH2 0x02c5 0561 61 PUSH2 0x056b 0564 36 CALLDATASIZE 0565 60 PUSH1 0x04 0567 61 PUSH2 0x27ad 056A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @055E stack[0] = 0x02c5 // @0561 stack[1] = 0x056b // @0564 stack[2] = msg.data.length // @0565 stack[3] = 0x04 // } // Block ends with call to 0x27ad, returns to 0x056B label_056B: // Incoming return from call to 0x27AD at 0x056A 056B 5B JUMPDEST 056C 61 PUSH2 0x1002 056F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1002 label_0570: // Incoming jump from 0x00C8, if 0xa217fddf == stack[-1] 0570 5B JUMPDEST 0571 61 PUSH2 0x0352 0574 60 PUSH1 0x00 0576 81 DUP2 0577 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0571 stack[0] = 0x0352 // @0574 stack[1] = 0x00 // } // Block ends with unconditional jump to 0x0352 label_0578: // Incoming jump from 0x00D3, if 0xa22cb465 == stack[-1] // Inputs[1] { @057F msg.data.length } 0578 5B JUMPDEST 0579 61 PUSH2 0x02ed 057C 61 PUSH2 0x0586 057F 36 CALLDATASIZE 0580 60 PUSH1 0x04 0582 61 PUSH2 0x2714 0585 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0579 stack[0] = 0x02ed // @057C stack[1] = 0x0586 // @057F stack[2] = msg.data.length // @0580 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2714 0586 5B JUMPDEST 0587 61 PUSH2 0x104d 058A 56 *JUMP label_058B: // Incoming jump from 0x00A2, if 0xaa1b103f == stack[-1] 058B 5B JUMPDEST 058C 61 PUSH2 0x02ed 058F 61 PUSH2 0x10fc 0592 56 *JUMP // Stack delta = +1 // Outputs[1] { @058C stack[0] = 0x02ed } // Block ends with unconditional jump to 0x10fc label_0593: // Incoming jump from 0x00AD, if 0xb88d4fde == stack[-1] // Inputs[1] { @059A msg.data.length } 0593 5B JUMPDEST 0594 61 PUSH2 0x02ed 0597 61 PUSH2 0x05a1 059A 36 CALLDATASIZE 059B 60 PUSH1 0x04 059D 61 PUSH2 0x2698 05A0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0594 stack[0] = 0x02ed // @0597 stack[1] = 0x05a1 // @059A stack[2] = msg.data.length // @059B stack[3] = 0x04 // } // Block ends with call to 0x2698, returns to 0x05A1 label_05A1: // Incoming return from call to 0x2698 at 0x05A0 05A1 5B JUMPDEST 05A2 61 PUSH2 0x1130 05A5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1130 label_05A6: // Incoming jump from 0x00B8, if 0xc87b56dd == stack[-1] // Inputs[1] { @05AD msg.data.length } 05A6 5B JUMPDEST 05A7 61 PUSH2 0x02f7 05AA 61 PUSH2 0x05b4 05AD 36 CALLDATASIZE 05AE 60 PUSH1 0x04 05B0 61 PUSH2 0x27ad 05B3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05A7 stack[0] = 0x02f7 // @05AA stack[1] = 0x05b4 // @05AD stack[2] = msg.data.length // @05AE stack[3] = 0x04 // } // Block ends with call to 0x27ad, returns to 0x05B4 label_05B4: // Incoming return from call to 0x27AD at 0x05B3 05B4 5B JUMPDEST 05B5 61 PUSH2 0x1174 05B8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1174 label_05B9: // Incoming jump from 0x007C, if 0xd4a6a2fd == stack[-1] // Inputs[1] { @05BC storage[0x37] } 05B9 5B JUMPDEST 05BA 60 PUSH1 0x37 05BC 54 SLOAD 05BD 61 PUSH2 0x02c5 05C0 90 SWAP1 05C1 60 PUSH1 0xff 05C3 16 AND 05C4 81 DUP2 05C5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @05C0 stack[0] = 0x02c5 // @05C3 stack[1] = 0xff & storage[0x37] // } // Block ends with unconditional jump to 0x02c5 label_05C6: // Incoming jump from 0x0087, if 0xd547741f == stack[-1] // Inputs[1] { @05CD msg.data.length } 05C6 5B JUMPDEST 05C7 61 PUSH2 0x02ed 05CA 61 PUSH2 0x05d4 05CD 36 CALLDATASIZE 05CE 60 PUSH1 0x04 05D0 61 PUSH2 0x27c6 05D3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05C7 stack[0] = 0x02ed // @05CA stack[1] = 0x05d4 // @05CD stack[2] = msg.data.length // @05CE stack[3] = 0x04 // } // Block ends with call to 0x27c6, returns to 0x05D4 label_05D4: // Incoming return from call to 0x27C6 at 0x05D3 05D4 5B JUMPDEST 05D5 61 PUSH2 0x1212 05D8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1212 label_05D9: // Incoming jump from 0x0056, if 0xe985e9c5 == stack[-1] // Inputs[1] { @05E0 msg.data.length } 05D9 5B JUMPDEST 05DA 61 PUSH2 0x02c5 05DD 61 PUSH2 0x05e7 05E0 36 CALLDATASIZE 05E1 60 PUSH1 0x04 05E3 61 PUSH2 0x2629 05E6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05DA stack[0] = 0x02c5 // @05DD stack[1] = 0x05e7 // @05E0 stack[2] = msg.data.length // @05E1 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x2629 label_05E7: // Incoming call from 0x18B0, returns to 0x18B1 // Incoming call from 0x07E6, returns to 0x07E7 // Incoming call from 0x15AF, returns to 0x15B0 // Inputs[6] // { // @05F0 stack[-2] // @0603 memory[0x00:0x40] // @0604 stack[-1] // @060E memory[0x00:0x40] // @060F storage[keccak256(memory[0x00:0x40])] // @0613 stack[-3] // } 05E7 5B JUMPDEST 05E8 60 PUSH1 0x01 05EA 60 PUSH1 0x01 05EC 60 PUSH1 0xa0 05EE 1B SHL 05EF 03 SUB 05F0 91 SWAP2 05F1 82 DUP3 05F2 16 AND 05F3 60 PUSH1 0x00 05F5 90 SWAP1 05F6 81 DUP2 05F7 52 MSTORE 05F8 60 PUSH1 0x07 05FA 60 PUSH1 0x20 05FC 90 SWAP1 05FD 81 DUP2 05FE 52 MSTORE 05FF 60 PUSH1 0x40 0601 80 DUP1 0602 83 DUP4 0603 20 SHA3 0604 93 SWAP4 0605 90 SWAP1 0606 94 SWAP5 0607 16 AND 0608 82 DUP3 0609 52 MSTORE 060A 91 SWAP2 060B 90 SWAP1 060C 91 SWAP2 060D 52 MSTORE 060E 20 SHA3 060F 54 SLOAD 0610 60 PUSH1 0xff 0612 16 AND 0613 90 SWAP1 0614 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @05F7 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @05FE memory[0x20:0x40] = 0x07 // @0609 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @060D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0613 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0615: // Incoming jump from 0x0061, if 0xf2fde38b == stack[-1] // Inputs[1] { @061C msg.data.length } 0615 5B JUMPDEST 0616 61 PUSH2 0x02ed 0619 61 PUSH2 0x0623 061C 36 CALLDATASIZE 061D 60 PUSH1 0x04 061F 61 PUSH2 0x260e 0622 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0616 stack[0] = 0x02ed // @0619 stack[1] = 0x0623 // @061C stack[2] = msg.data.length // @061D stack[3] = 0x04 // } // Block ends with call to 0x260e, returns to 0x0623 label_0623: // Incoming return from call to 0x260E at 0x0622 0623 5B JUMPDEST 0624 61 PUSH2 0x1237 0627 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1237 label_0628: // Incoming jump from 0x006C, if 0xffe630b5 == stack[-1] // Inputs[1] { @062F msg.data.length } 0628 5B JUMPDEST 0629 61 PUSH2 0x02ed 062C 61 PUSH2 0x0636 062F 36 CALLDATASIZE 0630 60 PUSH1 0x04 0632 61 PUSH2 0x2823 0635 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0629 stack[0] = 0x02ed // @062C stack[1] = 0x0636 // @062F stack[2] = msg.data.length // @0630 stack[3] = 0x04 // } // Block ends with call to 0x2823, returns to 0x0636 label_0636: // Incoming return from call to 0x2823 at 0x0635 0636 5B JUMPDEST 0637 61 PUSH2 0x1316 063A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1316 label_063B: // Incoming jump from 0x02C4 // Inputs[1] { @0641 stack[-1] } 063B 5B JUMPDEST 063C 60 PUSH1 0x00 063E 61 PUSH2 0x0646 0641 82 DUP3 0642 61 PUSH2 0x1353 0645 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @063C stack[0] = 0x00 // @063E stack[1] = 0x0646 // @0641 stack[2] = stack[-1] // } // Block ends with call to 0x1353, returns to 0x0646 label_0646: // Incoming return from call to 0x1F92 at 0x1390 // Incoming jump from 0x1FC6, if 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1353 at 0x0645 // Incoming jump from 0x14AE, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x1387, if 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x2257 at 0x1FCF // Incoming jump from 0x22F1 // Incoming jump from 0x22BF, if stack[-1] // Incoming jump from 0x22BF, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[3] // { // @0647 stack[-4] // @0647 stack[-1] // @0648 stack[-3] // } 0646 5B JUMPDEST 0647 92 SWAP3 0648 91 SWAP2 0649 50 POP 064A 50 POP 064B 56 *JUMP // Stack delta = -3 // Outputs[1] { @0647 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] 064C 5B JUMPDEST 064D 7F PUSH32 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b 066E 61 PUSH2 0x0676 0671 81 DUP2 0672 61 PUSH2 0x1391 0675 56 *JUMP 0676 5B JUMPDEST 0677 61 PUSH2 0x0680 067A 83 DUP4 067B 83 DUP4 067C 61 PUSH2 0x139b 067F 56 *JUMP label_0680: // Incoming return from call to 0x14CD at 0x0827 // Incoming return from call to 0x1130 at 0x0A4C // Incoming return from call to 0x1536 at 0x08C0 // Inputs[1] { @0684 stack[-4] } 0680 5B JUMPDEST 0681 50 POP 0682 50 POP 0683 50 POP 0684 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0685: // Incoming call from 0x02F6, returns to 0x02F7 // Inputs[1] { @068B storage[0x02] } 0685 5B JUMPDEST 0686 60 PUSH1 0x60 0688 60 PUSH1 0x02 068A 80 DUP1 068B 54 SLOAD 068C 61 PUSH2 0x0694 068F 90 SWAP1 0690 61 PUSH2 0x2ab3 0693 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0686 stack[0] = 0x60 // @0688 stack[1] = 0x02 // @068F stack[2] = 0x0694 // @068F stack[3] = storage[0x02] // } // Block ends with call to 0x2ab3, returns to 0x0694 label_0694: // Incoming return from call to 0x2AB3 at 0x1E93 // Incoming return from call to 0x2AB3 at 0x0693 // Incoming return from call to 0x2AB3 at 0x1001 // Inputs[4] // { // @0695 stack[-1] // @06A4 memory[0x40:0x60] // @06AC stack[-2] // @06B7 storage[stack[-2]] // } 0694 5B JUMPDEST 0695 80 DUP1 0696 60 PUSH1 0x1f 0698 01 ADD 0699 60 PUSH1 0x20 069B 80 DUP1 069C 91 SWAP2 069D 04 DIV 069E 02 MUL 069F 60 PUSH1 0x20 06A1 01 ADD 06A2 60 PUSH1 0x40 06A4 51 MLOAD 06A5 90 SWAP1 06A6 81 DUP2 06A7 01 ADD 06A8 60 PUSH1 0x40 06AA 52 MSTORE 06AB 80 DUP1 06AC 92 SWAP3 06AD 91 SWAP2 06AE 90 SWAP1 06AF 81 DUP2 06B0 81 DUP2 06B1 52 MSTORE 06B2 60 PUSH1 0x20 06B4 01 ADD 06B5 82 DUP3 06B6 80 DUP1 06B7 54 SLOAD 06B8 61 PUSH2 0x06c0 06BB 90 SWAP1 06BC 61 PUSH2 0x2ab3 06BF 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @06AA memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @06AC stack[-2] = memory[0x40:0x60] // @06AD stack[-1] = stack[-2] // @06AE stack[0] = stack[-1] // @06B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @06B4 stack[1] = 0x20 + memory[0x40:0x60] // @06B5 stack[2] = stack[-2] // @06BB stack[4] = storage[stack[-2]] // @06BB stack[3] = 0x06c0 // } // Block ends with call to 0x2ab3, returns to 0x06C0 label_06C0: // Incoming return from call to 0x2AB3 at 0x06BF // Inputs[1] { @06C1 stack[-1] } 06C0 5B JUMPDEST 06C1 80 DUP1 06C2 15 ISZERO 06C3 61 PUSH2 0x070d 06C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x070d, if !stack[-1] label_06C7: // Incoming jump from 0x06C6, if not !stack[-1] // Inputs[1] { @06C7 stack[-1] } 06C7 80 DUP1 06C8 60 PUSH1 0x1f 06CA 10 LT 06CB 61 PUSH2 0x06e2 06CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06e2, if 0x1f < stack[-1] label_06CF: // Incoming jump from 0x06CE, if not 0x1f < stack[-1] // Inputs[4] // { // @06D3 stack[-2] // @06D4 storage[stack[-2]] // @06D7 stack[-3] // @06D9 stack[-1] // } 06CF 61 PUSH2 0x0100 06D2 80 DUP1 06D3 83 DUP4 06D4 54 SLOAD 06D5 04 DIV 06D6 02 MUL 06D7 83 DUP4 06D8 52 MSTORE 06D9 91 SWAP2 06DA 60 PUSH1 0x20 06DC 01 ADD 06DD 91 SWAP2 06DE 61 PUSH2 0x070d 06E1 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @06D8 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @06DD stack[-1] = stack[-1] // @06DD stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x070d label_06E2: // Incoming jump from 0x06CE, if 0x1f < stack[-1] // Inputs[5] // { // @06E3 stack[-3] // @06E4 stack[-1] // @06E6 stack[-2] // @06EE memory[0x00:0x20] // @06F2 storage[keccak256(memory[0x00:0x20])] // } 06E2 5B JUMPDEST 06E3 82 DUP3 06E4 01 ADD 06E5 91 SWAP2 06E6 90 SWAP1 06E7 60 PUSH1 0x00 06E9 52 MSTORE 06EA 60 PUSH1 0x20 06EC 60 PUSH1 0x00 06EE 20 SHA3 06EF 90 SWAP1 06F0 5B JUMPDEST 06F1 81 DUP2 06F2 54 SLOAD 06F3 81 DUP2 06F4 52 MSTORE 06F5 90 SWAP1 06F6 60 PUSH1 0x01 06F8 01 ADD 06F9 90 SWAP1 06FA 60 PUSH1 0x20 06FC 01 ADD 06FD 80 DUP1 06FE 83 DUP4 06FF 11 GT 0700 61 PUSH2 0x06f0 0703 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @06E5 stack[-3] = stack[-3] + stack[-1] // @06E9 memory[0x00:0x20] = stack[-2] // @06F4 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06F9 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06FC stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06f0, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0704: // Incoming jump from 0x0703, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0703, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0704 stack[-3] // @0705 stack[-1] // } 0704 82 DUP3 0705 90 SWAP1 0706 03 SUB 0707 60 PUSH1 0x1f 0709 16 AND 070A 82 DUP3 070B 01 ADD 070C 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @070C stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @070C stack[-1] = stack[-3] // } // Block continues label_070D: // Incoming jump from 0x070C // Incoming jump from 0x06E1 // Incoming jump from 0x06C6, if !stack[-1] // Inputs[3] // { // @0713 stack[-7] // @0713 stack[-6] // @0715 stack[-8] // } 070D 5B JUMPDEST 070E 50 POP 070F 50 POP 0710 50 POP 0711 50 POP 0712 50 POP 0713 90 SWAP1 0714 50 POP 0715 90 SWAP1 0716 56 *JUMP // Stack delta = -7 // Outputs[1] { @0715 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_0717: // Incoming call from 0x15BF, returns to 0x15C0 // Incoming jump from 0x0316 // Incoming call from 0x18C0, returns to 0x18C1 // Inputs[1] { @071D stack[-1] } 0717 5B JUMPDEST 0718 60 PUSH1 0x00 071A 61 PUSH2 0x0722 071D 82 DUP3 071E 61 PUSH2 0x14a2 0721 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0718 stack[0] = 0x00 // @071A stack[1] = 0x0722 // @071D stack[2] = stack[-1] // } // Block ends with call to 0x14a2, returns to 0x0722 label_0722: // Incoming return from call to 0x14A2 at 0x0721 // Inputs[1] { @0726 stack[-1] } 0722 5B JUMPDEST 0723 61 PUSH2 0x0758 0726 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0758, if stack[-1] label_0727: // Incoming jump from 0x0726, if not stack[-1] // Inputs[3] // { // @0729 memory[0x40:0x60] // @0752 memory[0x40:0x60] // @0757 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0727 60 PUSH1 0x40 0729 51 MLOAD 072A 7F PUSH32 0xcf4700e400000000000000000000000000000000000000000000000000000000 074B 81 DUP2 074C 52 MSTORE 074D 60 PUSH1 0x04 074F 01 ADD 0750 60 PUSH1 0x40 0752 51 MLOAD 0753 80 DUP1 0754 91 SWAP2 0755 03 SUB 0756 90 SWAP1 0757 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @074C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcf4700e400000000000000000000000000000000000000000000000000000000 // @0757 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0758: // Incoming jump from 0x0726, if stack[-1] // Inputs[4] // { // @075C stack[-2] // @0767 memory[0x00:0x40] // @0768 storage[keccak256(memory[0x00:0x40])] // @0772 stack[-3] // } 0758 5B JUMPDEST 0759 50 POP 075A 60 PUSH1 0x00 075C 90 SWAP1 075D 81 DUP2 075E 52 MSTORE 075F 60 PUSH1 0x06 0761 60 PUSH1 0x20 0763 52 MSTORE 0764 60 PUSH1 0x40 0766 90 SWAP1 0767 20 SHA3 0768 54 SLOAD 0769 60 PUSH1 0x01 076B 60 PUSH1 0x01 076D 60 PUSH1 0xa0 076F 1B SHL 0770 03 SUB 0771 16 AND 0772 90 SWAP1 0773 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @075E memory[0x00:0x20] = stack[-2] // @0763 memory[0x20:0x40] = 0x06 // @0772 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0774: // Incoming jump from 0x0341 // Inputs[1] { @077A stack[-1] } 0774 5B JUMPDEST 0775 60 PUSH1 0x00 0777 61 PUSH2 0x077f 077A 82 DUP3 077B 61 PUSH2 0x0e99 077E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0775 stack[0] = 0x00 // @0777 stack[1] = 0x077f // @077A stack[2] = stack[-1] // } // Block ends with call to 0x0e99, returns to 0x077F label_077F: // Incoming return from call to 0x0E99 at 0x077E // Inputs[3] // { // @0780 stack[-2] // @0780 stack[-1] // @078C stack[-4] // } 077F 5B JUMPDEST 0780 90 SWAP1 0781 50 POP 0782 80 DUP1 0783 60 PUSH1 0x01 0785 60 PUSH1 0x01 0787 60 PUSH1 0xa0 0789 1B SHL 078A 03 SUB 078B 16 AND 078C 83 DUP4 078D 60 PUSH1 0x01 078F 60 PUSH1 0x01 0791 60 PUSH1 0xa0 0793 1B SHL 0794 03 SUB 0795 16 AND 0796 14 EQ 0797 15 ISZERO 0798 61 PUSH2 0x07cd 079B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0780 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x07cd, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_079C: // Incoming jump from 0x079B, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[3] // { // @079E memory[0x40:0x60] // @07C7 memory[0x40:0x60] // @07CC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 079C 60 PUSH1 0x40 079E 51 MLOAD 079F 7F PUSH32 0x943f7b8c00000000000000000000000000000000000000000000000000000000 07C0 81 DUP2 07C1 52 MSTORE 07C2 60 PUSH1 0x04 07C4 01 ADD 07C5 60 PUSH1 0x40 07C7 51 MLOAD 07C8 80 DUP1 07C9 91 SWAP2 07CA 03 SUB 07CB 90 SWAP1 07CC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @07C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x943f7b8c00000000000000000000000000000000000000000000000000000000 // @07CC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_07CD: // Incoming jump from 0x079B, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[2] // { // @07CE msg.sender // @07D7 stack[-1] // } 07CD 5B JUMPDEST 07CE 33 CALLER 07CF 60 PUSH1 0x01 07D1 60 PUSH1 0x01 07D3 60 PUSH1 0xa0 07D5 1B SHL 07D6 03 SUB 07D7 82 DUP3 07D8 16 AND 07D9 14 EQ 07DA 61 PUSH2 0x081d 07DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x081d, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_07DE: // Incoming jump from 0x07DD, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @07E1 stack[-1] // @07E2 msg.sender // } 07DE 61 PUSH2 0x07e7 07E1 81 DUP2 07E2 33 CALLER 07E3 61 PUSH2 0x05e7 07E6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07DE stack[0] = 0x07e7 // @07E1 stack[1] = stack[-1] // @07E2 stack[2] = msg.sender // } // Block ends with call to 0x05e7, returns to 0x07E7 label_07E7: // Incoming return from call to 0x05E7 at 0x07E6 // Inputs[1] { @07EB stack[-1] } 07E7 5B JUMPDEST 07E8 61 PUSH2 0x081d 07EB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x081d, if stack[-1] label_07EC: // Incoming jump from 0x07EB, if not stack[-1] // Inputs[3] // { // @07EE memory[0x40:0x60] // @0817 memory[0x40:0x60] // @081C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07EC 60 PUSH1 0x40 07EE 51 MLOAD 07EF 7F PUSH32 0xcfb3b94200000000000000000000000000000000000000000000000000000000 0810 81 DUP2 0811 52 MSTORE 0812 60 PUSH1 0x04 0814 01 ADD 0815 60 PUSH1 0x40 0817 51 MLOAD 0818 80 DUP1 0819 91 SWAP2 081A 03 SUB 081B 90 SWAP1 081C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0811 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcfb3b94200000000000000000000000000000000000000000000000000000000 // @081C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_081D: // Incoming jump from 0x07DD, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming jump from 0x07EB, if stack[-1] // Inputs[3] // { // @0821 stack[-3] // @0822 stack[-2] // @0823 stack[-1] // } 081D 5B JUMPDEST 081E 61 PUSH2 0x0680 0821 83 DUP4 0822 83 DUP4 0823 83 DUP4 0824 61 PUSH2 0x14cd 0827 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @081E stack[0] = 0x0680 // @0821 stack[1] = stack[-3] // @0822 stack[2] = stack[-2] // @0823 stack[3] = stack[-1] // } // Block ends with call to 0x14cd, returns to 0x0680 label_0828: // Incoming call from 0x0349, returns to 0x02F7 // Inputs[1] { @082C storage[0x35] } 0828 5B JUMPDEST 0829 60 PUSH1 0x35 082B 80 DUP1 082C 54 SLOAD 082D 61 PUSH2 0x0835 0830 90 SWAP1 0831 61 PUSH2 0x2ab3 0834 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0829 stack[0] = 0x35 // @0830 stack[1] = 0x0835 // @0830 stack[2] = storage[0x35] // } // Block ends with call to 0x2ab3, returns to 0x0835 label_0835: // Incoming return from call to 0x2AB3 at 0x0834 // Inputs[4] // { // @0836 stack[-1] // @0845 memory[0x40:0x60] // @084D stack[-2] // @0858 storage[stack[-2]] // } 0835 5B JUMPDEST 0836 80 DUP1 0837 60 PUSH1 0x1f 0839 01 ADD 083A 60 PUSH1 0x20 083C 80 DUP1 083D 91 SWAP2 083E 04 DIV 083F 02 MUL 0840 60 PUSH1 0x20 0842 01 ADD 0843 60 PUSH1 0x40 0845 51 MLOAD 0846 90 SWAP1 0847 81 DUP2 0848 01 ADD 0849 60 PUSH1 0x40 084B 52 MSTORE 084C 80 DUP1 084D 92 SWAP3 084E 91 SWAP2 084F 90 SWAP1 0850 81 DUP2 0851 81 DUP2 0852 52 MSTORE 0853 60 PUSH1 0x20 0855 01 ADD 0856 82 DUP3 0857 80 DUP1 0858 54 SLOAD 0859 61 PUSH2 0x0861 085C 90 SWAP1 085D 61 PUSH2 0x2ab3 0860 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @084B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @084D stack[-2] = memory[0x40:0x60] // @084E stack[-1] = stack[-2] // @084F stack[0] = stack[-1] // @0852 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0855 stack[1] = 0x20 + memory[0x40:0x60] // @0856 stack[2] = stack[-2] // @085C stack[4] = storage[stack[-2]] // @085C stack[3] = 0x0861 // } // Block ends with call to 0x2ab3, returns to 0x0861 label_0861: // Incoming return from call to 0x2AB3 at 0x0860 // Inputs[1] { @0862 stack[-1] } 0861 5B JUMPDEST 0862 80 DUP1 0863 15 ISZERO 0864 61 PUSH2 0x08ae 0867 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08ae, if !stack[-1] label_0868: // Incoming jump from 0x0867, if not !stack[-1] // Inputs[1] { @0868 stack[-1] } 0868 80 DUP1 0869 60 PUSH1 0x1f 086B 10 LT 086C 61 PUSH2 0x0883 086F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0883, if 0x1f < stack[-1] label_0870: // Incoming jump from 0x086F, if not 0x1f < stack[-1] // Inputs[4] // { // @0874 stack[-2] // @0875 storage[stack[-2]] // @0878 stack[-3] // @087A stack[-1] // } 0870 61 PUSH2 0x0100 0873 80 DUP1 0874 83 DUP4 0875 54 SLOAD 0876 04 DIV 0877 02 MUL 0878 83 DUP4 0879 52 MSTORE 087A 91 SWAP2 087B 60 PUSH1 0x20 087D 01 ADD 087E 91 SWAP2 087F 61 PUSH2 0x08ae 0882 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0879 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @087E stack[-1] = stack[-1] // @087E stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x08ae label_0883: // Incoming jump from 0x086F, if 0x1f < stack[-1] // Inputs[5] // { // @0884 stack[-3] // @0885 stack[-1] // @0887 stack[-2] // @088F memory[0x00:0x20] // @0893 storage[keccak256(memory[0x00:0x20])] // } 0883 5B JUMPDEST 0884 82 DUP3 0885 01 ADD 0886 91 SWAP2 0887 90 SWAP1 0888 60 PUSH1 0x00 088A 52 MSTORE 088B 60 PUSH1 0x20 088D 60 PUSH1 0x00 088F 20 SHA3 0890 90 SWAP1 0891 5B JUMPDEST 0892 81 DUP2 0893 54 SLOAD 0894 81 DUP2 0895 52 MSTORE 0896 90 SWAP1 0897 60 PUSH1 0x01 0899 01 ADD 089A 90 SWAP1 089B 60 PUSH1 0x20 089D 01 ADD 089E 80 DUP1 089F 83 DUP4 08A0 11 GT 08A1 61 PUSH2 0x0891 08A4 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @0886 stack[-3] = stack[-3] + stack[-1] // @088A memory[0x00:0x20] = stack[-2] // @0895 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @089A stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @089D stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0891, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_08A5: // Incoming jump from 0x08A4, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x08A4, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @08A5 stack[-3] // @08A6 stack[-1] // } 08A5 82 DUP3 08A6 90 SWAP1 08A7 03 SUB 08A8 60 PUSH1 0x1f 08AA 16 AND 08AB 82 DUP3 08AC 01 ADD 08AD 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @08AD stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @08AD stack[-1] = stack[-3] // } // Block continues label_08AE: // Incoming jump from 0x0867, if !stack[-1] // Incoming jump from 0x0882 // Incoming jump from 0x08AD // Inputs[1] { @08B4 stack[-7] } 08AE 5B JUMPDEST 08AF 50 POP 08B0 50 POP 08B1 50 POP 08B2 50 POP 08B3 50 POP 08B4 81 DUP2 08B5 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_08B6: // Incoming jump from 0x0372 // Inputs[3] // { // @08BA stack[-3] // @08BB stack[-2] // @08BC stack[-1] // } 08B6 5B JUMPDEST 08B7 61 PUSH2 0x0680 08BA 83 DUP4 08BB 83 DUP4 08BC 83 DUP4 08BD 61 PUSH2 0x1536 08C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08B7 stack[0] = 0x0680 // @08BA stack[1] = stack[-3] // @08BB stack[2] = stack[-2] // @08BC stack[3] = stack[-1] // } // Block ends with call to 0x1536, returns to 0x0680 label_08C1: // Incoming jump from 0x03A8 // Inputs[4] // { // @08C4 stack[-2] // @08D2 memory[0x00:0x40] // @08D4 memory[0x40:0x60] // @08DB storage[keccak256(memory[0x00:0x40])] // } 08C1 5B JUMPDEST 08C2 60 PUSH1 0x00 08C4 82 DUP3 08C5 81 DUP2 08C6 52 MSTORE 08C7 60 PUSH1 0x09 08C9 60 PUSH1 0x20 08CB 90 SWAP1 08CC 81 DUP2 08CD 52 MSTORE 08CE 60 PUSH1 0x40 08D0 80 DUP1 08D1 83 DUP4 08D2 20 SHA3 08D3 81 DUP2 08D4 51 MLOAD 08D5 80 DUP1 08D6 83 DUP4 08D7 01 ADD 08D8 90 SWAP1 08D9 92 SWAP3 08DA 52 MSTORE 08DB 54 SLOAD 08DC 60 PUSH1 0x01 08DE 60 PUSH1 0x01 08E0 60 PUSH1 0xa0 08E2 1B SHL 08E3 03 SUB 08E4 81 DUP2 08E5 16 AND 08E6 80 DUP1 08E7 83 DUP4 08E8 52 MSTORE 08E9 60 PUSH1 0x01 08EB 60 PUSH1 0xa0 08ED 1B SHL 08EE 90 SWAP1 08EF 91 SWAP2 08F0 04 DIV 08F1 6B PUSH12 0xffffffffffffffffffffffff 08FE 16 AND 08FF 92 SWAP3 0900 82 DUP3 0901 01 ADD 0902 92 SWAP3 0903 90 SWAP1 0904 92 SWAP3 0905 52 MSTORE 0906 82 DUP3 0907 91 SWAP2 0908 61 PUSH2 0x0940 090B 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @08C2 stack[0] = 0x00 // @08C6 memory[0x00:0x20] = stack[-2] // @08CD memory[0x20:0x40] = 0x09 // @08D9 stack[2] = memory[0x40:0x60] // @08DA memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @08E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0905 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0907 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0940, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_090C: // Incoming jump from 0x090B, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0910 memory[0x40:0x60] // @0919 storage[0x08] // @0945 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @095F stack[-4] // } 090C 50 POP 090D 60 PUSH1 0x40 090F 80 DUP1 0910 51 MLOAD 0911 80 DUP1 0912 82 DUP3 0913 01 ADD 0914 90 SWAP1 0915 91 SWAP2 0916 52 MSTORE 0917 60 PUSH1 0x08 0919 54 SLOAD 091A 60 PUSH1 0x01 091C 60 PUSH1 0x01 091E 60 PUSH1 0xa0 0920 1B SHL 0921 03 SUB 0922 81 DUP2 0923 16 AND 0924 82 DUP3 0925 52 MSTORE 0926 60 PUSH1 0x01 0928 60 PUSH1 0xa0 092A 1B SHL 092B 90 SWAP1 092C 04 DIV 092D 6B PUSH12 0xffffffffffffffffffffffff 093A 16 AND 093B 60 PUSH1 0x20 093D 82 DUP3 093E 01 ADD 093F 52 MSTORE 0940 5B JUMPDEST 0941 60 PUSH1 0x20 0943 81 DUP2 0944 01 ADD 0945 51 MLOAD 0946 60 PUSH1 0x00 0948 90 SWAP1 0949 61 PUSH2 0x2710 094C 90 SWAP1 094D 61 PUSH2 0x0964 0950 90 SWAP1 0951 6B PUSH12 0xffffffffffffffffffffffff 095E 16 AND 095F 87 DUP8 0960 61 PUSH2 0x2a3a 0963 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0915 stack[-1] = memory[0x40:0x60] // @0916 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0925 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x08] & (0x01 << 0xa0) - 0x01 // @093F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffff & storage[0x08] / (0x01 << 0xa0) // @0948 stack[0] = 0x00 // @094C stack[1] = 0x2710 // @0950 stack[2] = 0x0964 // @095E stack[3] = 0xffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @095F stack[4] = stack[-4] // } // Block ends with call to 0x2a3a, returns to 0x0964 label_0964: // Incoming return from call to 0x2A3A at 0x0963 // Incoming return from call to 0x2A3A at 0x0963 // Inputs[2] // { // @0968 stack[-2] // @0969 stack[-1] // } 0964 5B JUMPDEST 0965 61 PUSH2 0x096e 0968 91 SWAP2 0969 90 SWAP1 096A 61 PUSH2 0x2a26 096D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0968 stack[-2] = 0x096e // @0969 stack[-1] = stack[-2] // @0969 stack[0] = stack[-1] // } // Block ends with call to 0x2a26, returns to 0x096E label_096E: // Incoming return from call to 0x2A26 at 0x096D // Inputs[7] // { // @096F stack[-3] // @096F stack[-1] // @0970 memory[stack[-3]:stack[-3] + 0x20] // @0971 stack[-8] // @0973 stack[-7] // @0975 stack[-2] // @0976 stack[-6] // } 096E 5B JUMPDEST 096F 91 SWAP2 0970 51 MLOAD 0971 96 SWAP7 0972 91 SWAP2 0973 95 SWAP6 0974 50 POP 0975 90 SWAP1 0976 93 SWAP4 0977 50 POP 0978 50 POP 0979 50 POP 097A 50 POP 097B 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0971 stack[-8] = memory[stack[-3]:stack[-3] + 0x20] // @0973 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_097C: // Incoming jump from 0x0401 // Inputs[3] // { // @097F stack[-2] // @098A memory[0x00:0x40] // @098E storage[0x01 + keccak256(memory[0x00:0x40])] // } 097C 5B JUMPDEST 097D 60 PUSH1 0x00 097F 82 DUP3 0980 81 DUP2 0981 52 MSTORE 0982 60 PUSH1 0x0b 0984 60 PUSH1 0x20 0986 52 MSTORE 0987 60 PUSH1 0x40 0989 90 SWAP1 098A 20 SHA3 098B 60 PUSH1 0x01 098D 01 ADD 098E 54 SLOAD 098F 61 PUSH2 0x0997 0992 81 DUP2 0993 61 PUSH2 0x1391 0996 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0981 memory[0x00:0x20] = stack[-2] // @0986 memory[0x20:0x40] = 0x0b // @098E stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @098F stack[1] = 0x0997 // @0992 stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x1391 0997 5B JUMPDEST 0998 61 PUSH2 0x0680 099B 83 DUP4 099C 83 DUP4 099D 61 PUSH2 0x1758 09A0 56 *JUMP label_09A1: // Incoming jump from 0x0414 // Inputs[2] // { // @09AA stack[-1] // @09AC msg.sender // } 09A1 5B JUMPDEST 09A2 60 PUSH1 0x01 09A4 60 PUSH1 0x01 09A6 60 PUSH1 0xa0 09A8 1B SHL 09A9 03 SUB 09AA 81 DUP2 09AB 16 AND 09AC 33 CALLER 09AD 14 EQ 09AE 61 PUSH2 0x0a24 09B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a24, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 label_09B2: // Incoming jump from 0x09B1, if not msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @09B4 memory[0x40:0x60] } 09B2 60 PUSH1 0x40 09B4 51 MLOAD 09B5 62 PUSH3 0x461bcd 09B9 60 PUSH1 0xe5 09BB 1B SHL 09BC 81 DUP2 09BD 52 MSTORE 09BE 60 PUSH1 0x20 09C0 60 PUSH1 0x04 09C2 82 DUP3 09C3 01 ADD 09C4 52 MSTORE 09C5 60 PUSH1 0x2f 09C7 60 PUSH1 0x24 09C9 82 DUP3 09CA 01 ADD 09CB 52 MSTORE 09CC 7F PUSH32 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 09ED 60 PUSH1 0x44 09EF 82 DUP3 09F0 01 ADD 09F1 52 MSTORE 09F2 7F PUSH32 0x20726f6c657320666f722073656c660000000000000000000000000000000000 0A13 60 PUSH1 0x64 0A15 82 DUP3 0A16 01 ADD 0A17 52 MSTORE 0A18 60 PUSH1 0x84 0A1A 01 ADD // Stack delta = +1 // Outputs[6] // { // @09BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09C4 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09CB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2f // @09F1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e6365 // @0A17 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x20726f6c657320666f722073656c660000000000000000000000000000000000 // @0A1A stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0A1B: // Incoming jump from 0x0B15 // Incoming jump from 0x0A1A // Incoming return from call to 0x29FB at 0x204F // Incoming jump from 0x0ABE // Incoming jump from 0x24B6 // Incoming jump from 0x0F6C // Incoming jump from 0x1290 // Incoming jump from 0x130C // Inputs[3] // { // @0A1E memory[0x40:0x60] // @0A20 stack[-1] // @0A23 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0A1B 5B JUMPDEST 0A1C 60 PUSH1 0x40 0A1E 51 MLOAD 0A1F 80 DUP1 0A20 91 SWAP2 0A21 03 SUB 0A22 90 SWAP1 0A23 FD *REVERT // Stack delta = -1 // Outputs[1] { @0A23 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0A24: // Incoming jump from 0x09B1, if msg.sender == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0A28 stack[-2] // @0A29 stack[-1] // } 0A24 5B JUMPDEST 0A25 61 PUSH2 0x0a2e 0A28 82 DUP3 0A29 82 DUP3 0A2A 61 PUSH2 0x17fa 0A2D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A25 stack[0] = 0x0a2e // @0A28 stack[1] = stack[-2] // @0A29 stack[2] = stack[-1] // } // Block ends with call to 0x17fa, returns to 0x0A2E label_0A2E: // Incoming jump from 0x1825, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Incoming jump from 0x1FFA, if 0xff & storage[keccak256(memory[0x00:0x40])] // Incoming return from call to 0x17FA at 0x0A2D // Inputs[1] { @0A31 stack[-3] } 0A2E 5B JUMPDEST 0A2F 50 POP 0A30 50 POP 0A31 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0A32: // Incoming jump from 0x0427 // Inputs[4] // { // @0A36 stack[-3] // @0A37 stack[-2] // @0A38 stack[-1] // @0A3B memory[0x40:0x60] // } 0A32 5B JUMPDEST 0A33 61 PUSH2 0x0680 0A36 83 DUP4 0A37 83 DUP4 0A38 83 DUP4 0A39 60 PUSH1 0x40 0A3B 51 MLOAD 0A3C 80 DUP1 0A3D 60 PUSH1 0x20 0A3F 01 ADD 0A40 60 PUSH1 0x40 0A42 52 MSTORE 0A43 80 DUP1 0A44 60 PUSH1 0x00 0A46 81 DUP2 0A47 52 MSTORE 0A48 50 POP 0A49 61 PUSH2 0x1130 0A4C 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0A33 stack[0] = 0x0680 // @0A36 stack[1] = stack[-3] // @0A37 stack[2] = stack[-2] // @0A38 stack[3] = stack[-1] // @0A3B stack[4] = memory[0x40:0x60] // @0A42 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0A47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x1130, returns to 0x0680 label_0A4D: // Incoming jump from 0x043A // Inputs[1] { @0A51 stack[-1] } 0A4D 5B JUMPDEST 0A4E 61 PUSH2 0x0a58 0A51 81 DUP2 0A52 60 PUSH1 0x01 0A54 61 PUSH2 0x187d 0A57 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A4E stack[0] = 0x0a58 // @0A51 stack[1] = stack[-1] // @0A52 stack[2] = 0x01 // } // Block ends with call to 0x187d, returns to 0x0A58 label_0A58: // Incoming return from call to 0x187D at 0x0A57 // Inputs[3] // { // @0A5B stack[-1] // @0A66 memory[0x00:0x40] // @0A68 stack[-2] // } 0A58 5B JUMPDEST 0A59 60 PUSH1 0x00 0A5B 90 SWAP1 0A5C 81 DUP2 0A5D 52 MSTORE 0A5E 60 PUSH1 0x09 0A60 60 PUSH1 0x20 0A62 52 MSTORE 0A63 60 PUSH1 0x40 0A65 81 DUP2 0A66 20 SHA3 0A67 55 SSTORE 0A68 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0A5D memory[0x00:0x20] = stack[-1] // @0A62 memory[0x20:0x40] = 0x09 // @0A67 storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-2] label_0A69: // Incoming return from call to 0x1FD0 at 0x139A // Incoming return from call to 0x1D2E at 0x1315 // Incoming jump from 0x2B86, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0A6B stack[-2] } 0A69 5B JUMPDEST 0A6A 50 POP 0A6B 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A6C: // Incoming jump from 0x0442 // Inputs[1] { @0A71 storage[0x0a] } 0A6C 5B JUMPDEST 0A6D 60 PUSH1 0x02 0A6F 60 PUSH1 0x0a 0A71 54 SLOAD 0A72 14 EQ 0A73 15 ISZERO 0A74 61 PUSH2 0x0abf 0A77 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0abf, if !(storage[0x0a] == 0x02) label_0A78: // Incoming jump from 0x0A77, if not !(storage[0x0a] == 0x02) // Inputs[1] { @0A7A memory[0x40:0x60] } 0A78 60 PUSH1 0x40 0A7A 51 MLOAD 0A7B 62 PUSH3 0x461bcd 0A7F 60 PUSH1 0xe5 0A81 1B SHL 0A82 81 DUP2 0A83 52 MSTORE 0A84 60 PUSH1 0x20 0A86 60 PUSH1 0x04 0A88 82 DUP3 0A89 01 ADD 0A8A 52 MSTORE 0A8B 60 PUSH1 0x1f 0A8D 60 PUSH1 0x24 0A8F 82 DUP3 0A90 01 ADD 0A91 52 MSTORE 0A92 7F PUSH32 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 0AB3 60 PUSH1 0x44 0AB5 82 DUP3 0AB6 01 ADD 0AB7 52 MSTORE 0AB8 60 PUSH1 0x64 0ABA 01 ADD 0ABB 61 PUSH2 0x0a1b 0ABE 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0A83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A8A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A91 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @0AB7 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5265656e7472616e637947756172643a207265656e7472616e742063616c6c00 // @0ABA stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1b label_0ABF: // Incoming jump from 0x0A77, if !(storage[0x0a] == 0x02) // Inputs[1] { @0AC7 storage[0x37] } 0ABF 5B JUMPDEST 0AC0 60 PUSH1 0x02 0AC2 60 PUSH1 0x0a 0AC4 55 SSTORE 0AC5 60 PUSH1 0x37 0AC7 54 SLOAD 0AC8 60 PUSH1 0xff 0ACA 16 AND 0ACB 61 PUSH2 0x0b16 0ACE 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0AC4 storage[0x0a] = 0x02 } // Block ends with conditional jump to 0x0b16, if 0xff & storage[0x37] label_0ACF: // Incoming jump from 0x0ACE, if not 0xff & storage[0x37] // Inputs[1] { @0AD1 memory[0x40:0x60] } 0ACF 60 PUSH1 0x40 0AD1 51 MLOAD 0AD2 62 PUSH3 0x461bcd 0AD6 60 PUSH1 0xe5 0AD8 1B SHL 0AD9 81 DUP2 0ADA 52 MSTORE 0ADB 60 PUSH1 0x20 0ADD 60 PUSH1 0x04 0ADF 82 DUP3 0AE0 01 ADD 0AE1 52 MSTORE 0AE2 60 PUSH1 0x14 0AE4 60 PUSH1 0x24 0AE6 82 DUP3 0AE7 01 ADD 0AE8 52 MSTORE 0AE9 7F PUSH32 0x436c61696d206973206e6f74206163746976652e000000000000000000000000 0B0A 60 PUSH1 0x44 0B0C 82 DUP3 0B0D 01 ADD 0B0E 52 MSTORE 0B0F 60 PUSH1 0x64 0B11 01 ADD 0B12 61 PUSH2 0x0a1b 0B15 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0ADA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AE1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AE8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @0B0E memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x436c61696d206973206e6f74206163746976652e000000000000000000000000 // @0B11 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1b label_0B16: // Incoming jump from 0x0ACE, if 0xff & storage[0x37] // Inputs[4] // { // @0B1D memory[0x40:0x60] // @0B28 msg.sender // @0B66 memory[0x40:0x60] // @0B6D address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // } 0B16 5B JUMPDEST 0B17 60 PUSH1 0x00 0B19 80 DUP1 0B1A 5B JUMPDEST 0B1B 60 PUSH1 0x40 0B1D 51 MLOAD 0B1E 63 PUSH4 0x70a08231 0B23 60 PUSH1 0xe0 0B25 1B SHL 0B26 81 DUP2 0B27 52 MSTORE 0B28 33 CALLER 0B29 60 PUSH1 0x04 0B2B 82 DUP3 0B2C 01 ADD 0B2D 52 MSTORE 0B2E 7F PUSH32 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e 0B4F 60 PUSH1 0x01 0B51 60 PUSH1 0x01 0B53 60 PUSH1 0xa0 0B55 1B SHL 0B56 03 SUB 0B57 16 AND 0B58 90 SWAP1 0B59 63 PUSH4 0x70a08231 0B5E 90 SWAP1 0B5F 60 PUSH1 0x24 0B61 01 ADD 0B62 60 PUSH1 0x20 0B64 60 PUSH1 0x40 0B66 51 MLOAD 0B67 80 DUP1 0B68 83 DUP4 0B69 03 SUB 0B6A 81 DUP2 0B6B 86 DUP7 0B6C 80 DUP1 0B6D 3B EXTCODESIZE 0B6E 15 ISZERO 0B6F 80 DUP1 0B70 15 ISZERO 0B71 61 PUSH2 0x0b79 0B74 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @0B17 stack[0] = 0x00 // @0B19 stack[1] = 0x00 // @0B27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @0B2D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0B58 stack[2] = (0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e // @0B5E stack[3] = 0x70a08231 // @0B61 stack[4] = 0x24 + memory[0x40:0x60] // @0B62 stack[5] = 0x20 // @0B66 stack[6] = memory[0x40:0x60] // @0B69 stack[7] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60] // @0B6A stack[8] = memory[0x40:0x60] // @0B6B stack[9] = (0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e // @0B6E stack[10] = !address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // } // Block ends with conditional jump to 0x0b79, if !!address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length label_0B75: // Incoming jump from 0x0B74, if not !!address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // Incoming jump from 0x0B74, if not !!address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // Inputs[1] { @0B78 memory[0x00:0x00] } 0B75 60 PUSH1 0x00 0B77 80 DUP1 0B78 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B78 revert(memory[0x00:0x00]); } // Block terminates label_0B79: // Incoming jump from 0x0B74, if !!address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // Incoming jump from 0x0B74, if !!address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // Inputs[8] // { // @0B7B msg.gas // @0B7C stack[-5] // @0B7C memory[stack[-3]:stack[-3] + stack[-4]] // @0B7C stack[-6] // @0B7C address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0B7C stack[-4] // @0B7C stack[-2] // @0B7C stack[-3] // } 0B79 5B JUMPDEST 0B7A 50 POP 0B7B 5A GAS 0B7C FA STATICCALL 0B7D 15 ISZERO 0B7E 80 DUP1 0B7F 15 ISZERO 0B80 61 PUSH2 0x0b8d 0B83 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0B7C memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0B7D stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0b8d, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0B84: // Incoming jump from 0x0B83, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0B84 returndata.length // @0B88 returndata[0x00:0x00 + returndata.length] // @0B89 returndata.length // @0B8C memory[0x00:0x00 + returndata.length] // } 0B84 3D RETURNDATASIZE 0B85 60 PUSH1 0x00 0B87 80 DUP1 0B88 3E RETURNDATACOPY 0B89 3D RETURNDATASIZE 0B8A 60 PUSH1 0x00 0B8C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0B88 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0B8C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0B8D: // Incoming jump from 0x0B83, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0B94 memory[0x40:0x60] // @0B95 returndata.length // } 0B8D 5B JUMPDEST 0B8E 50 POP 0B8F 50 POP 0B90 50 POP 0B91 50 POP 0B92 60 PUSH1 0x40 0B94 51 MLOAD 0B95 3D RETURNDATASIZE 0B96 60 PUSH1 0x1f 0B98 19 NOT 0B99 60 PUSH1 0x1f 0B9B 82 DUP3 0B9C 01 ADD 0B9D 16 AND 0B9E 82 DUP3 0B9F 01 ADD 0BA0 80 DUP1 0BA1 60 PUSH1 0x40 0BA3 52 MSTORE 0BA4 50 POP 0BA5 81 DUP2 0BA6 01 ADD 0BA7 90 SWAP1 0BA8 61 PUSH2 0x0bb1 0BAB 91 SWAP2 0BAC 90 SWAP1 0BAD 61 PUSH2 0x286c 0BB0 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0BA3 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0BAB stack[-4] = 0x0bb1 // @0BAC stack[-2] = memory[0x40:0x60] // @0BAC stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x286c, returns to 0x0BB1 label_0BB1: // Incoming return from call to 0x286C at 0x0BB0 // Inputs[2] // { // @0BB2 stack[-2] // @0BB3 stack[-1] // } 0BB1 5B JUMPDEST 0BB2 81 DUP2 0BB3 10 LT 0BB4 15 ISZERO 0BB5 61 PUSH2 0x0c92 0BB8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c92, if !(stack[-2] < stack[-1]) label_0BB9: // Incoming jump from 0x0BB8, if not !(stack[-2] < stack[-1]) // Inputs[5] // { // @0BBB memory[0x40:0x60] // @0BC6 msg.sender // @0BD0 stack[-1] // @0C0E memory[0x40:0x60] // @0C15 address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // } 0BB9 60 PUSH1 0x40 0BBB 51 MLOAD 0BBC 63 PUSH4 0x2f745c59 0BC1 60 PUSH1 0xe0 0BC3 1B SHL 0BC4 81 DUP2 0BC5 52 MSTORE 0BC6 33 CALLER 0BC7 60 PUSH1 0x04 0BC9 82 DUP3 0BCA 01 ADD 0BCB 52 MSTORE 0BCC 60 PUSH1 0x24 0BCE 81 DUP2 0BCF 01 ADD 0BD0 82 DUP3 0BD1 90 SWAP1 0BD2 52 MSTORE 0BD3 60 PUSH1 0x00 0BD5 90 SWAP1 0BD6 7F PUSH32 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e 0BF7 60 PUSH1 0x01 0BF9 60 PUSH1 0x01 0BFB 60 PUSH1 0xa0 0BFD 1B SHL 0BFE 03 SUB 0BFF 16 AND 0C00 90 SWAP1 0C01 63 PUSH4 0x2f745c59 0C06 90 SWAP1 0C07 60 PUSH1 0x44 0C09 01 ADD 0C0A 60 PUSH1 0x20 0C0C 60 PUSH1 0x40 0C0E 51 MLOAD 0C0F 80 DUP1 0C10 83 DUP4 0C11 03 SUB 0C12 81 DUP2 0C13 86 DUP7 0C14 80 DUP1 0C15 3B EXTCODESIZE 0C16 15 ISZERO 0C17 80 DUP1 0C18 15 ISZERO 0C19 61 PUSH2 0x0c21 0C1C 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @0BC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2f745c59 << 0xe0 // @0BCB memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0BD2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] // @0BD5 stack[0] = 0x00 // @0C00 stack[1] = (0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e // @0C06 stack[2] = 0x2f745c59 // @0C09 stack[3] = 0x44 + memory[0x40:0x60] // @0C0A stack[4] = 0x20 // @0C0E stack[5] = memory[0x40:0x60] // @0C11 stack[6] = (0x44 + memory[0x40:0x60]) - memory[0x40:0x60] // @0C12 stack[7] = memory[0x40:0x60] // @0C13 stack[8] = (0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e // @0C16 stack[9] = !address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // } // Block ends with conditional jump to 0x0c21, if !!address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length label_0C1D: // Incoming jump from 0x0C1C, if not !!address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // Inputs[1] { @0C20 memory[0x00:0x00] } 0C1D 60 PUSH1 0x00 0C1F 80 DUP1 0C20 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C20 revert(memory[0x00:0x00]); } // Block terminates label_0C21: // Incoming jump from 0x0C1C, if !!address((0x01 << 0xa0) - 0x01 & 0x0000000000000000000000008a90cab2b38dba80c64b7734e58ee1db38b8992e).code.length // Inputs[8] // { // @0C23 msg.gas // @0C24 stack[-2] // @0C24 stack[-5] // @0C24 stack[-6] // @0C24 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0C24 stack[-3] // @0C24 stack[-4] // @0C24 memory[stack[-3]:stack[-3] + stack[-4]] // } 0C21 5B JUMPDEST 0C22 50 POP 0C23 5A GAS 0C24 FA STATICCALL 0C25 15 ISZERO 0C26 80 DUP1 0C27 15 ISZERO 0C28 61 PUSH2 0x0c35 0C2B 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0C24 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0C25 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0c35, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0C2C: // Incoming jump from 0x0C2B, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0C2C returndata.length // @0C30 returndata[0x00:0x00 + returndata.length] // @0C31 returndata.length // @0C34 memory[0x00:0x00 + returndata.length] // } 0C2C 3D RETURNDATASIZE 0C2D 60 PUSH1 0x00 0C2F 80 DUP1 0C30 3E RETURNDATACOPY 0C31 3D RETURNDATASIZE 0C32 60 PUSH1 0x00 0C34 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C30 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0C34 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0C35: // Incoming jump from 0x0C2B, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0C3C memory[0x40:0x60] // @0C3D returndata.length // } 0C35 5B JUMPDEST 0C36 50 POP 0C37 50 POP 0C38 50 POP 0C39 50 POP 0C3A 60 PUSH1 0x40 0C3C 51 MLOAD 0C3D 3D RETURNDATASIZE 0C3E 60 PUSH1 0x1f 0C40 19 NOT 0C41 60 PUSH1 0x1f 0C43 82 DUP3 0C44 01 ADD 0C45 16 AND 0C46 82 DUP3 0C47 01 ADD 0C48 80 DUP1 0C49 60 PUSH1 0x40 0C4B 52 MSTORE 0C4C 50 POP 0C4D 81 DUP2 0C4E 01 ADD 0C4F 90 SWAP1 0C50 61 PUSH2 0x0c59 0C53 91 SWAP2 0C54 90 SWAP1 0C55 61 PUSH2 0x286c 0C58 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0C4B memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0C53 stack[-4] = 0x0c59 // @0C54 stack[-2] = memory[0x40:0x60] // @0C54 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x286c, returns to 0x0C59 label_0C59: // Incoming return from call to 0x286C at 0x0C58 // Inputs[2] // { // @0C5A stack[-2] // @0C5A stack[-1] // } 0C59 5B JUMPDEST 0C5A 90 SWAP1 0C5B 50 POP 0C5C 61 PUSH2 0x0c64 0C5F 81 DUP2 0C60 61 PUSH2 0x1002 0C63 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0C5A stack[-2] = stack[-1] // @0C5C stack[-1] = 0x0c64 // @0C5F stack[0] = stack[-1] // } // Block ends with call to 0x1002, returns to 0x0C64 label_0C64: // Incoming return from call to 0x1002 at 0x0C63 // Inputs[1] { @0C68 stack[-1] } 0C64 5B JUMPDEST 0C65 61 PUSH2 0x0c7f 0C68 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c7f, if stack[-1] label_0C69: // Incoming jump from 0x0C68, if not stack[-1] // Inputs[1] { @0C6C stack[-1] } 0C69 61 PUSH2 0x0c71 0C6C 81 DUP2 0C6D 61 PUSH2 0x1a73 0C70 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C69 stack[0] = 0x0c71 // @0C6C stack[1] = stack[-1] // } // Block ends with call to 0x1a73, returns to 0x0C71 label_0C71: // Incoming return from call to 0x1A73 at 0x0C70 // Inputs[1] { @0C72 stack[-3] } 0C71 5B JUMPDEST 0C72 82 DUP3 0C73 61 PUSH2 0x0c7b 0C76 81 DUP2 0C77 61 PUSH2 0x2aee 0C7A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C72 stack[0] = stack[-3] // @0C73 stack[1] = 0x0c7b // @0C76 stack[2] = stack[-3] // } // Block ends with call to 0x2aee, returns to 0x0C7B label_0C7B: // Incoming return from call to 0x2AEE at 0x0C7A // Inputs[2] // { // @0C7C stack[-1] // @0C7C stack[-5] // } 0C7B 5B JUMPDEST 0C7C 93 SWAP4 0C7D 50 POP 0C7E 50 POP // Stack delta = -2 // Outputs[1] { @0C7C stack[-5] = stack[-1] } // Block continues label_0C7F: // Incoming jump from 0x0C7E // Incoming jump from 0x0C68, if stack[-1] // Inputs[1] { @0C81 stack[-2] } 0C7F 5B JUMPDEST 0C80 50 POP 0C81 80 DUP1 0C82 61 PUSH2 0x0c8a 0C85 81 DUP2 0C86 61 PUSH2 0x2aee 0C89 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0C81 stack[-1] = stack[-2] // @0C82 stack[0] = 0x0c8a // @0C85 stack[1] = stack[-2] // } // Block ends with call to 0x2aee, returns to 0x0C8A label_0C8A: // Incoming return from call to 0x2AEE at 0x0C89 // Inputs[2] // { // @0C8B stack[-3] // @0C8B stack[-1] // } 0C8A 5B JUMPDEST 0C8B 91 SWAP2 0C8C 50 POP 0C8D 50 POP 0C8E 61 PUSH2 0x0b1a 0C91 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C8B stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0b1a label_0C92: // Incoming jump from 0x0BB8, if !(stack[-2] < stack[-1]) // Inputs[4] // { // @0C99 memory[0x40:0x60] // @0CA4 msg.sender // @0CE2 memory[0x40:0x60] // @0CE9 address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // } 0C92 5B JUMPDEST 0C93 50 POP 0C94 60 PUSH1 0x00 0C96 5B JUMPDEST 0C97 60 PUSH1 0x40 0C99 51 MLOAD 0C9A 63 PUSH4 0x70a08231 0C9F 60 PUSH1 0xe0 0CA1 1B SHL 0CA2 81 DUP2 0CA3 52 MSTORE 0CA4 33 CALLER 0CA5 60 PUSH1 0x04 0CA7 82 DUP3 0CA8 01 ADD 0CA9 52 MSTORE 0CAA 7F PUSH32 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8 0CCB 60 PUSH1 0x01 0CCD 60 PUSH1 0x01 0CCF 60 PUSH1 0xa0 0CD1 1B SHL 0CD2 03 SUB 0CD3 16 AND 0CD4 90 SWAP1 0CD5 63 PUSH4 0x70a08231 0CDA 90 SWAP1 0CDB 60 PUSH1 0x24 0CDD 01 ADD 0CDE 60 PUSH1 0x20 0CE0 60 PUSH1 0x40 0CE2 51 MLOAD 0CE3 80 DUP1 0CE4 83 DUP4 0CE5 03 SUB 0CE6 81 DUP2 0CE7 86 DUP7 0CE8 80 DUP1 0CE9 3B EXTCODESIZE 0CEA 15 ISZERO 0CEB 80 DUP1 0CEC 15 ISZERO 0CED 61 PUSH2 0x0cf5 0CF0 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @0C94 stack[-1] = 0x00 // @0CA3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x70a08231 << 0xe0 // @0CA9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0CD4 stack[0] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8 // @0CDA stack[1] = 0x70a08231 // @0CDD stack[2] = 0x24 + memory[0x40:0x60] // @0CDE stack[3] = 0x20 // @0CE2 stack[4] = memory[0x40:0x60] // @0CE5 stack[5] = (0x24 + memory[0x40:0x60]) - memory[0x40:0x60] // @0CE6 stack[6] = memory[0x40:0x60] // @0CE7 stack[7] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8 // @0CEA stack[8] = !address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // } // Block ends with conditional jump to 0x0cf5, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length label_0CF1: // Incoming jump from 0x0CF0, if not !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // Incoming jump from 0x0CF0, if not !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // Inputs[1] { @0CF4 memory[0x00:0x00] } 0CF1 60 PUSH1 0x00 0CF3 80 DUP1 0CF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CF4 revert(memory[0x00:0x00]); } // Block terminates label_0CF5: // Incoming jump from 0x0CF0, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // Incoming jump from 0x0CF0, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // Inputs[8] // { // @0CF7 msg.gas // @0CF8 stack[-2] // @0CF8 memory[stack[-3]:stack[-3] + stack[-4]] // @0CF8 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0CF8 stack[-4] // @0CF8 stack[-6] // @0CF8 stack[-3] // @0CF8 stack[-5] // } 0CF5 5B JUMPDEST 0CF6 50 POP 0CF7 5A GAS 0CF8 FA STATICCALL 0CF9 15 ISZERO 0CFA 80 DUP1 0CFB 15 ISZERO 0CFC 61 PUSH2 0x0d09 0CFF 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0CF8 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0CF9 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0d09, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0D00: // Incoming jump from 0x0CFF, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0D00 returndata.length // @0D04 returndata[0x00:0x00 + returndata.length] // @0D05 returndata.length // @0D08 memory[0x00:0x00 + returndata.length] // } 0D00 3D RETURNDATASIZE 0D01 60 PUSH1 0x00 0D03 80 DUP1 0D04 3E RETURNDATACOPY 0D05 3D RETURNDATASIZE 0D06 60 PUSH1 0x00 0D08 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0D04 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0D08 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0D09: // Incoming jump from 0x0CFF, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0D10 memory[0x40:0x60] // @0D11 returndata.length // } 0D09 5B JUMPDEST 0D0A 50 POP 0D0B 50 POP 0D0C 50 POP 0D0D 50 POP 0D0E 60 PUSH1 0x40 0D10 51 MLOAD 0D11 3D RETURNDATASIZE 0D12 60 PUSH1 0x1f 0D14 19 NOT 0D15 60 PUSH1 0x1f 0D17 82 DUP3 0D18 01 ADD 0D19 16 AND 0D1A 82 DUP3 0D1B 01 ADD 0D1C 80 DUP1 0D1D 60 PUSH1 0x40 0D1F 52 MSTORE 0D20 50 POP 0D21 81 DUP2 0D22 01 ADD 0D23 90 SWAP1 0D24 61 PUSH2 0x0d2d 0D27 91 SWAP2 0D28 90 SWAP1 0D29 61 PUSH2 0x286c 0D2C 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0D1F memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0D27 stack[-4] = 0x0d2d // @0D28 stack[-2] = memory[0x40:0x60] // @0D28 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x286c, returns to 0x0D2D label_0D2D: // Incoming return from call to 0x286C at 0x0D2C // Inputs[2] // { // @0D2E stack[-2] // @0D2F stack[-1] // } 0D2D 5B JUMPDEST 0D2E 81 DUP2 0D2F 10 LT 0D30 15 ISZERO 0D31 61 PUSH2 0x0e0e 0D34 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e0e, if !(stack[-2] < stack[-1]) label_0D35: // Incoming jump from 0x0D34, if not !(stack[-2] < stack[-1]) // Inputs[5] // { // @0D37 memory[0x40:0x60] // @0D42 msg.sender // @0D4C stack[-1] // @0D8A memory[0x40:0x60] // @0D91 address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // } 0D35 60 PUSH1 0x40 0D37 51 MLOAD 0D38 63 PUSH4 0x2f745c59 0D3D 60 PUSH1 0xe0 0D3F 1B SHL 0D40 81 DUP2 0D41 52 MSTORE 0D42 33 CALLER 0D43 60 PUSH1 0x04 0D45 82 DUP3 0D46 01 ADD 0D47 52 MSTORE 0D48 60 PUSH1 0x24 0D4A 81 DUP2 0D4B 01 ADD 0D4C 82 DUP3 0D4D 90 SWAP1 0D4E 52 MSTORE 0D4F 60 PUSH1 0x00 0D51 90 SWAP1 0D52 7F PUSH32 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8 0D73 60 PUSH1 0x01 0D75 60 PUSH1 0x01 0D77 60 PUSH1 0xa0 0D79 1B SHL 0D7A 03 SUB 0D7B 16 AND 0D7C 90 SWAP1 0D7D 63 PUSH4 0x2f745c59 0D82 90 SWAP1 0D83 60 PUSH1 0x44 0D85 01 ADD 0D86 60 PUSH1 0x20 0D88 60 PUSH1 0x40 0D8A 51 MLOAD 0D8B 80 DUP1 0D8C 83 DUP4 0D8D 03 SUB 0D8E 81 DUP2 0D8F 86 DUP7 0D90 80 DUP1 0D91 3B EXTCODESIZE 0D92 15 ISZERO 0D93 80 DUP1 0D94 15 ISZERO 0D95 61 PUSH2 0x0d9d 0D98 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @0D41 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2f745c59 << 0xe0 // @0D47 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0D4E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] // @0D51 stack[0] = 0x00 // @0D7C stack[1] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8 // @0D82 stack[2] = 0x2f745c59 // @0D85 stack[3] = 0x44 + memory[0x40:0x60] // @0D86 stack[4] = 0x20 // @0D8A stack[5] = memory[0x40:0x60] // @0D8D stack[6] = (0x44 + memory[0x40:0x60]) - memory[0x40:0x60] // @0D8E stack[7] = memory[0x40:0x60] // @0D8F stack[8] = (0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8 // @0D92 stack[9] = !address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // } // Block ends with conditional jump to 0x0d9d, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length label_0D99: // Incoming jump from 0x0D98, if not !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // Inputs[1] { @0D9C memory[0x00:0x00] } 0D99 60 PUSH1 0x00 0D9B 80 DUP1 0D9C FD *REVERT // Stack delta = +0 // Outputs[1] { @0D9C revert(memory[0x00:0x00]); } // Block terminates label_0D9D: // Incoming jump from 0x0D98, if !!address((0x01 << 0xa0) - 0x01 & 0x000000000000000000000000620b70123fb810f6c653da7644b5dd0b6312e4d8).code.length // Inputs[8] // { // @0D9F msg.gas // @0DA0 stack[-3] // @0DA0 stack[-4] // @0DA0 stack[-2] // @0DA0 stack[-6] // @0DA0 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0DA0 memory[stack[-3]:stack[-3] + stack[-4]] // @0DA0 stack[-5] // } 0D9D 5B JUMPDEST 0D9E 50 POP 0D9F 5A GAS 0DA0 FA STATICCALL 0DA1 15 ISZERO 0DA2 80 DUP1 0DA3 15 ISZERO 0DA4 61 PUSH2 0x0db1 0DA7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0DA0 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0DA1 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0db1, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0DA8: // Incoming jump from 0x0DA7, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0DA8 returndata.length // @0DAC returndata[0x00:0x00 + returndata.length] // @0DAD returndata.length // @0DB0 memory[0x00:0x00 + returndata.length] // } 0DA8 3D RETURNDATASIZE 0DA9 60 PUSH1 0x00 0DAB 80 DUP1 0DAC 3E RETURNDATACOPY 0DAD 3D RETURNDATASIZE 0DAE 60 PUSH1 0x00 0DB0 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DAC memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0DB0 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0DB1: // Incoming jump from 0x0DA7, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0DB8 memory[0x40:0x60] // @0DB9 returndata.length // } 0DB1 5B JUMPDEST 0DB2 50 POP 0DB3 50 POP 0DB4 50 POP 0DB5 50 POP 0DB6 60 PUSH1 0x40 0DB8 51 MLOAD 0DB9 3D RETURNDATASIZE 0DBA 60 PUSH1 0x1f 0DBC 19 NOT 0DBD 60 PUSH1 0x1f 0DBF 82 DUP3 0DC0 01 ADD 0DC1 16 AND 0DC2 82 DUP3 0DC3 01 ADD 0DC4 80 DUP1 0DC5 60 PUSH1 0x40 0DC7 52 MSTORE 0DC8 50 POP 0DC9 81 DUP2 0DCA 01 ADD 0DCB 90 SWAP1 0DCC 61 PUSH2 0x0dd5 0DCF 91 SWAP2 0DD0 90 SWAP1 0DD1 61 PUSH2 0x286c 0DD4 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0DC7 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0DCF stack[-4] = 0x0dd5 // @0DD0 stack[-2] = memory[0x40:0x60] // @0DD0 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x286c, returns to 0x0DD5 label_0DD5: // Incoming return from call to 0x286C at 0x0DD4 // Inputs[2] // { // @0DD6 stack[-1] // @0DD6 stack[-2] // } 0DD5 5B JUMPDEST 0DD6 90 SWAP1 0DD7 50 POP 0DD8 61 PUSH2 0x0de0 0DDB 81 DUP2 0DDC 61 PUSH2 0x1002 0DDF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0DD6 stack[-2] = stack[-1] // @0DD8 stack[-1] = 0x0de0 // @0DDB stack[0] = stack[-1] // } // Block ends with call to 0x1002, returns to 0x0DE0 label_0DE0: // Incoming return from call to 0x1002 at 0x0DDF // Inputs[1] { @0DE4 stack[-1] } 0DE0 5B JUMPDEST 0DE1 61 PUSH2 0x0dfb 0DE4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dfb, if stack[-1] label_0DE5: // Incoming jump from 0x0DE4, if not stack[-1] // Inputs[1] { @0DE8 stack[-1] } 0DE5 61 PUSH2 0x0ded 0DE8 81 DUP2 0DE9 61 PUSH2 0x1a73 0DEC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DE5 stack[0] = 0x0ded // @0DE8 stack[1] = stack[-1] // } // Block ends with call to 0x1a73, returns to 0x0DED label_0DED: // Incoming return from call to 0x1A73 at 0x0DEC // Inputs[1] { @0DEE stack[-3] } 0DED 5B JUMPDEST 0DEE 82 DUP3 0DEF 61 PUSH2 0x0df7 0DF2 81 DUP2 0DF3 61 PUSH2 0x2aee 0DF6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DEE stack[0] = stack[-3] // @0DEF stack[1] = 0x0df7 // @0DF2 stack[2] = stack[-3] // } // Block ends with call to 0x2aee, returns to 0x0DF7 label_0DF7: // Incoming return from call to 0x2AEE at 0x0DF6 // Inputs[2] // { // @0DF8 stack[-5] // @0DF8 stack[-1] // } 0DF7 5B JUMPDEST 0DF8 93 SWAP4 0DF9 50 POP 0DFA 50 POP // Stack delta = -2 // Outputs[1] { @0DF8 stack[-5] = stack[-1] } // Block continues label_0DFB: // Incoming jump from 0x0DE4, if stack[-1] // Incoming jump from 0x0DFA // Inputs[1] { @0DFD stack[-2] } 0DFB 5B JUMPDEST 0DFC 50 POP 0DFD 80 DUP1 0DFE 61 PUSH2 0x0e06 0E01 81 DUP2 0E02 61 PUSH2 0x2aee 0E05 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DFD stack[-1] = stack[-2] // @0DFE stack[0] = 0x0e06 // @0E01 stack[1] = stack[-2] // } // Block ends with call to 0x2aee, returns to 0x0E06 label_0E06: // Incoming return from call to 0x2AEE at 0x0E05 // Inputs[2] // { // @0E07 stack[-3] // @0E07 stack[-1] // } 0E06 5B JUMPDEST 0E07 91 SWAP2 0E08 50 POP 0E09 50 POP 0E0A 61 PUSH2 0x0c96 0E0D 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E07 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0c96 label_0E0E: // Incoming jump from 0x0D34, if !(stack[-2] < stack[-1]) // Inputs[2] // { // @0E13 msg.sender // @0E14 stack[-2] // } 0E0E 5B JUMPDEST 0E0F 50 POP 0E10 61 PUSH2 0x0e19 0E13 33 CALLER 0E14 82 DUP3 0E15 61 PUSH2 0x1ac7 0E18 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E10 stack[-1] = 0x0e19 // @0E13 stack[0] = msg.sender // @0E14 stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x1ac7 0E19 5B JUMPDEST 0E1A 50 POP 0E1B 60 PUSH1 0x01 0E1D 60 PUSH1 0x0a 0E1F 55 SSTORE 0E20 56 *JUMP label_0E21: // Incoming jump from 0x0455 0E21 5B JUMPDEST 0E22 7F PUSH32 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b 0E43 61 PUSH2 0x0e4b 0E46 81 DUP2 0E47 61 PUSH2 0x1391 0E4A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E22 stack[0] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // @0E43 stack[1] = 0x0e4b // @0E46 stack[2] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // } // Block ends with unconditional jump to 0x1391 0E4B 5B JUMPDEST 0E4C 81 DUP2 0E4D 51 MLOAD 0E4E 61 PUSH2 0x0680 0E51 90 SWAP1 0E52 60 PUSH1 0x36 0E54 90 SWAP1 0E55 60 PUSH1 0x20 0E57 85 DUP6 0E58 01 ADD 0E59 90 SWAP1 0E5A 61 PUSH2 0x24b7 0E5D 56 *JUMP label_0E5E: // Incoming jump from 0x0468 0E5E 5B JUMPDEST 0E5F 7F PUSH32 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b 0E80 61 PUSH2 0x0e88 0E83 81 DUP2 0E84 61 PUSH2 0x1391 0E87 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E5F stack[0] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // @0E80 stack[1] = 0x0e88 // @0E83 stack[2] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // } // Block ends with unconditional jump to 0x1391 0E88 5B JUMPDEST 0E89 61 PUSH2 0x0e93 0E8C 84 DUP5 0E8D 84 DUP5 0E8E 84 DUP5 0E8F 61 PUSH2 0x1ae1 0E92 56 *JUMP label_0E93: // Incoming jump from 0x2A93, if !(stack[-1] > stack[-4]) // Incoming jump from 0x114B, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Incoming call from 0x2256, returns to 0x0E93 // Incoming return from call to 0x0E93 at 0x2256 // Inputs[1] { @0E98 stack[-5] } 0E93 5B JUMPDEST 0E94 50 POP 0E95 50 POP 0E96 50 POP 0E97 50 POP 0E98 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0E99: // Incoming jump from 0x047B // Incoming call from 0x077E, returns to 0x077F // Inputs[1] { @0E9F stack[-1] } 0E99 5B JUMPDEST 0E9A 60 PUSH1 0x00 0E9C 61 PUSH2 0x0ea4 0E9F 82 DUP3 0EA0 61 PUSH2 0x1bf9 0EA3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E9A stack[0] = 0x00 // @0E9C stack[1] = 0x0ea4 // @0E9F stack[2] = stack[-1] // } // Block ends with call to 0x1bf9, returns to 0x0EA4 label_0EA4: // Incoming return from call to 0x1BF9 at 0x0EA3 // Inputs[4] // { // @0EA5 memory[stack[-1]:stack[-1] + 0x20] // @0EA5 stack[-1] // @0EA6 stack[-4] // @0EA7 stack[-3] // } 0EA4 5B JUMPDEST 0EA5 51 MLOAD 0EA6 92 SWAP3 0EA7 91 SWAP2 0EA8 50 POP 0EA9 50 POP 0EAA 56 *JUMP // Stack delta = -3 // Outputs[1] { @0EA6 stack[-4] = memory[stack[-1]:stack[-1] + 0x20] } // Block ends with unconditional jump to stack[-4] label_0EAB: // Incoming jump from 0x048E // Inputs[1] { @0EB6 stack[-1] } 0EAB 5B JUMPDEST 0EAC 60 PUSH1 0x00 0EAE 60 PUSH1 0x01 0EB0 60 PUSH1 0x01 0EB2 60 PUSH1 0xa0 0EB4 1B SHL 0EB5 03 SUB 0EB6 82 DUP3 0EB7 16 AND 0EB8 61 PUSH2 0x0eed 0EBB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EAC stack[0] = 0x00 } // Block ends with conditional jump to 0x0eed, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0EBC: // Incoming jump from 0x0EBB, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0EBE memory[0x40:0x60] // @0EE7 memory[0x40:0x60] // @0EEC memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0EBC 60 PUSH1 0x40 0EBE 51 MLOAD 0EBF 7F PUSH32 0x8f4eb60400000000000000000000000000000000000000000000000000000000 0EE0 81 DUP2 0EE1 52 MSTORE 0EE2 60 PUSH1 0x04 0EE4 01 ADD 0EE5 60 PUSH1 0x40 0EE7 51 MLOAD 0EE8 80 DUP1 0EE9 91 SWAP2 0EEA 03 SUB 0EEB 90 SWAP1 0EEC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8f4eb60400000000000000000000000000000000000000000000000000000000 // @0EEC revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0EED: // Incoming jump from 0x0EBB, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0EF7 stack[-2] // @0F05 memory[0x00:0x40] // @0F06 storage[keccak256(memory[0x00:0x40])] // @0F11 stack[-3] // } 0EED 5B JUMPDEST 0EEE 50 POP 0EEF 60 PUSH1 0x01 0EF1 60 PUSH1 0x01 0EF3 60 PUSH1 0xa0 0EF5 1B SHL 0EF6 03 SUB 0EF7 16 AND 0EF8 60 PUSH1 0x00 0EFA 90 SWAP1 0EFB 81 DUP2 0EFC 52 MSTORE 0EFD 60 PUSH1 0x05 0EFF 60 PUSH1 0x20 0F01 52 MSTORE 0F02 60 PUSH1 0x40 0F04 90 SWAP1 0F05 20 SHA3 0F06 54 SLOAD 0F07 67 PUSH8 0xffffffffffffffff 0F10 16 AND 0F11 90 SWAP1 0F12 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0EFC memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0F01 memory[0x20:0x40] = 0x05 // @0F11 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0F13: // Incoming call from 0x0496, returns to 0x02ED // Inputs[2] // { // @0F16 storage[0x0c] // @0F20 msg.sender // } 0F13 5B JUMPDEST 0F14 60 PUSH1 0x0c 0F16 54 SLOAD 0F17 60 PUSH1 0x01 0F19 60 PUSH1 0x01 0F1B 60 PUSH1 0xa0 0F1D 1B SHL 0F1E 03 SUB 0F1F 16 AND 0F20 33 CALLER 0F21 14 EQ 0F22 61 PUSH2 0x0f6d 0F25 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f6d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] label_0F26: // Incoming jump from 0x0F25, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] // Inputs[1] { @0F28 memory[0x40:0x60] } 0F26 60 PUSH1 0x40 0F28 51 MLOAD 0F29 62 PUSH3 0x461bcd 0F2D 60 PUSH1 0xe5 0F2F 1B SHL 0F30 81 DUP2 0F31 52 MSTORE 0F32 60 PUSH1 0x20 0F34 60 PUSH1 0x04 0F36 82 DUP3 0F37 01 ADD 0F38 81 DUP2 0F39 90 SWAP1 0F3A 52 MSTORE 0F3B 60 PUSH1 0x24 0F3D 82 DUP3 0F3E 01 ADD 0F3F 52 MSTORE 0F40 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0F61 60 PUSH1 0x44 0F63 82 DUP3 0F64 01 ADD 0F65 52 MSTORE 0F66 60 PUSH1 0x64 0F68 01 ADD 0F69 61 PUSH2 0x0a1b 0F6C 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F31 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0F3A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0F3F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @0F65 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0F68 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1b label_0F6D: // Incoming jump from 0x0F25, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] 0F6D 5B JUMPDEST 0F6E 61 PUSH2 0x0f77 0F71 60 PUSH1 0x00 0F73 61 PUSH2 0x1d2e 0F76 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F6E stack[0] = 0x0f77 // @0F71 stack[1] = 0x00 // } // Block ends with call to 0x1d2e, returns to 0x0F77 label_0F77: // Incoming return from call to 0x1D2E at 0x0F76 // Inputs[1] { @0F78 stack[-1] } 0F77 5B JUMPDEST 0F78 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0F79: // Incoming jump from 0x04A9 0F79 5B JUMPDEST 0F7A 7F PUSH32 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b 0F9B 61 PUSH2 0x0fa3 0F9E 81 DUP2 0F9F 61 PUSH2 0x1391 0FA2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F7A stack[0] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // @0F9B stack[1] = 0x0fa3 // @0F9E stack[2] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // } // Block ends with unconditional jump to 0x1391 0FA3 5B JUMPDEST 0FA4 50 POP 0FA5 60 PUSH1 0x37 0FA7 80 DUP1 0FA8 54 SLOAD 0FA9 60 PUSH1 0xff 0FAB 19 NOT 0FAC 16 AND 0FAD 91 SWAP2 0FAE 15 ISZERO 0FAF 15 ISZERO 0FB0 91 SWAP2 0FB1 90 SWAP1 0FB2 91 SWAP2 0FB3 17 OR 0FB4 90 SWAP1 0FB5 55 SSTORE 0FB6 56 *JUMP label_0FB7: // Incoming jump from 0x04BC 0FB7 5B JUMPDEST 0FB8 7F PUSH32 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b 0FD9 61 PUSH2 0x0fe1 0FDC 81 DUP2 0FDD 61 PUSH2 0x1391 0FE0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0FB8 stack[0] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // @0FD9 stack[1] = 0x0fe1 // @0FDC stack[2] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // } // Block ends with unconditional jump to 0x1391 0FE1 5B JUMPDEST 0FE2 50 POP 0FE3 60 PUSH1 0x00 0FE5 90 SWAP1 0FE6 81 DUP2 0FE7 52 MSTORE 0FE8 60 PUSH1 0x09 0FEA 60 PUSH1 0x20 0FEC 52 MSTORE 0FED 60 PUSH1 0x40 0FEF 81 DUP2 0FF0 20 SHA3 0FF1 55 SSTORE 0FF2 56 *JUMP label_0FF3: // Incoming call from 0x055C, returns to 0x02F7 // Inputs[1] { @0FF9 storage[0x03] } 0FF3 5B JUMPDEST 0FF4 60 PUSH1 0x60 0FF6 60 PUSH1 0x03 0FF8 80 DUP1 0FF9 54 SLOAD 0FFA 61 PUSH2 0x0694 0FFD 90 SWAP1 0FFE 61 PUSH2 0x2ab3 1001 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FF4 stack[0] = 0x60 // @0FF6 stack[1] = 0x03 // @0FFD stack[2] = 0x0694 // @0FFD stack[3] = storage[0x03] // } // Block ends with call to 0x2ab3, returns to 0x0694 label_1002: // Incoming jump from 0x056F // Incoming call from 0x0C63, returns to 0x0C64 // Incoming call from 0x0DDF, returns to 0x0DE0 // Inputs[1] { @100C stack[-1] } 1002 5B JUMPDEST 1003 60 PUSH1 0x00 1005 80 DUP1 1006 61 PUSH2 0x1011 1009 61 PUSH2 0x0100 100C 84 DUP5 100D 61 PUSH2 0x2a26 1010 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1003 stack[0] = 0x00 // @1005 stack[1] = 0x00 // @1006 stack[2] = 0x1011 // @1009 stack[3] = 0x0100 // @100C stack[4] = stack[-1] // } // Block ends with call to 0x2a26, returns to 0x1011 label_1011: // Incoming return from call to 0x2A26 at 0x1010 // Inputs[3] // { // @1012 stack[-2] // @1012 stack[-1] // @101C stack[-4] // } 1011 5B JUMPDEST 1012 90 SWAP1 1013 50 POP 1014 60 PUSH1 0x00 1016 61 PUSH2 0x1021 1019 61 PUSH2 0x0100 101C 85 DUP6 101D 61 PUSH2 0x2b09 1020 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1012 stack[-2] = stack[-1] // @1014 stack[-1] = 0x00 // @1016 stack[0] = 0x1021 // @1019 stack[1] = 0x0100 // @101C stack[2] = stack[-4] // } // Block ends with call to 0x2b09, returns to 0x1021 label_1021: // Incoming return from call to 0x2B09 at 0x1020 // Inputs[3] // { // @1022 stack[-2] // @1022 stack[-1] // @1028 stack[-3] // } 1021 5B JUMPDEST 1022 90 SWAP1 1023 50 POP 1024 60 PUSH1 0x00 1026 60 PUSH1 0x0d 1028 83 DUP4 1029 60 PUSH1 0x28 102B 81 DUP2 102C 10 LT 102D 61 PUSH2 0x1038 1030 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1022 stack[-2] = stack[-1] // @1024 stack[-1] = 0x00 // @1026 stack[0] = 0x0d // @1028 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1038, if stack[-3] < 0x28 label_1031: // Incoming jump from 0x1030, if not stack[-3] < 0x28 1031 61 PUSH2 0x1038 1034 61 PUSH2 0x2b49 1037 56 *JUMP // Stack delta = +1 // Outputs[1] { @1031 stack[0] = 0x1038 } // Block ends with unconditional jump to 0x2b49 label_1038: // Incoming jump from 0x1030, if stack[-3] < 0x28 // Inputs[7] // { // @1039 stack[-2] // @1039 stack[-1] // @103A storage[stack[-1] + stack[-2]] // @103E stack[-4] // @1043 stack[-3] // @1046 stack[-8] // @1047 stack[-7] // } 1038 5B JUMPDEST 1039 01 ADD 103A 54 SLOAD 103B 60 PUSH1 0x01 103D 90 SWAP1 103E 92 SWAP3 103F 1B SHL 1040 91 SWAP2 1041 82 DUP3 1042 16 AND 1043 90 SWAP1 1044 91 SWAP2 1045 14 EQ 1046 94 SWAP5 1047 93 SWAP4 1048 50 POP 1049 50 POP 104A 50 POP 104B 50 POP 104C 56 *JUMP // Stack delta = -7 // Outputs[1] { @1046 stack[-8] = 0x01 << stack[-4] == (0x01 << stack[-4]) & storage[stack[-1] + stack[-2]] } // Block ends with unconditional jump to stack[-8] 104D 5B JUMPDEST 104E 60 PUSH1 0x01 1050 60 PUSH1 0x01 1052 60 PUSH1 0xa0 1054 1B SHL 1055 03 SUB 1056 82 DUP3 1057 16 AND 1058 33 CALLER 1059 14 EQ 105A 15 ISZERO 105B 61 PUSH2 0x1090 105E 57 *JUMPI 105F 60 PUSH1 0x40 1061 51 MLOAD 1062 7F PUSH32 0xb06307db00000000000000000000000000000000000000000000000000000000 1083 81 DUP2 1084 52 MSTORE 1085 60 PUSH1 0x04 1087 01 ADD 1088 60 PUSH1 0x40 108A 51 MLOAD 108B 80 DUP1 108C 91 SWAP2 108D 03 SUB 108E 90 SWAP1 108F FD *REVERT 1090 5B JUMPDEST 1091 33 CALLER 1092 60 PUSH1 0x00 1094 81 DUP2 1095 81 DUP2 1096 52 MSTORE 1097 60 PUSH1 0x07 1099 60 PUSH1 0x20 109B 90 SWAP1 109C 81 DUP2 109D 52 MSTORE 109E 60 PUSH1 0x40 10A0 80 DUP1 10A1 83 DUP4 10A2 20 SHA3 10A3 60 PUSH1 0x01 10A5 60 PUSH1 0x01 10A7 60 PUSH1 0xa0 10A9 1B SHL 10AA 03 SUB 10AB 87 DUP8 10AC 16 AND 10AD 80 DUP1 10AE 85 DUP6 10AF 52 MSTORE 10B0 90 SWAP1 10B1 83 DUP4 10B2 52 MSTORE 10B3 92 SWAP3 10B4 81 DUP2 10B5 90 SWAP1 10B6 20 SHA3 10B7 80 DUP1 10B8 54 SLOAD 10B9 60 PUSH1 0xff 10BB 19 NOT 10BC 16 AND 10BD 86 DUP7 10BE 15 ISZERO 10BF 15 ISZERO 10C0 90 SWAP1 10C1 81 DUP2 10C2 17 OR 10C3 90 SWAP1 10C4 91 SWAP2 10C5 55 SSTORE 10C6 90 SWAP1 10C7 51 MLOAD 10C8 90 SWAP1 10C9 81 DUP2 10CA 52 MSTORE 10CB 91 SWAP2 10CC 92 SWAP3 10CD 91 SWAP2 10CE 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 10EF 91 SWAP2 10F0 01 ADD 10F1 60 PUSH1 0x40 10F3 51 MLOAD 10F4 80 DUP1 10F5 91 SWAP2 10F6 03 SUB 10F7 90 SWAP1 10F8 A3 LOG3 10F9 50 POP 10FA 50 POP 10FB 56 *JUMP label_10FC: // Incoming jump from 0x0592 10FC 5B JUMPDEST 10FD 7F PUSH32 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b 111E 61 PUSH2 0x1126 1121 81 DUP2 1122 61 PUSH2 0x1391 1125 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10FD stack[0] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // @111E stack[1] = 0x1126 // @1121 stack[2] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // } // Block ends with unconditional jump to 0x1391 1126 5B JUMPDEST 1127 61 PUSH2 0x0a69 112A 60 PUSH1 0x00 112C 60 PUSH1 0x08 112E 55 SSTORE 112F 56 *JUMP label_1130: // Incoming jump from 0x05A5 // Incoming call from 0x0A4C, returns to 0x0680 // Inputs[3] // { // @1134 stack[-4] // @1135 stack[-3] // @1136 stack[-2] // } 1130 5B JUMPDEST 1131 61 PUSH2 0x113b 1134 84 DUP5 1135 84 DUP5 1136 84 DUP5 1137 61 PUSH2 0x1536 113A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1131 stack[0] = 0x113b // @1134 stack[1] = stack[-4] // @1135 stack[2] = stack[-3] // @1136 stack[3] = stack[-2] // } // Block ends with call to 0x1536, returns to 0x113B label_113B: // Incoming return from call to 0x1536 at 0x113A // Inputs[2] // { // @1144 stack[-3] // @1146 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 113B 5B JUMPDEST 113C 60 PUSH1 0x01 113E 60 PUSH1 0x01 1140 60 PUSH1 0xa0 1142 1B SHL 1143 03 SUB 1144 83 DUP4 1145 16 AND 1146 3B EXTCODESIZE 1147 15 ISZERO 1148 61 PUSH2 0x0e93 114B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e93, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_114C: // Incoming jump from 0x114B, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[4] // { // @114F stack[-4] // @1150 stack[-3] // @1151 stack[-2] // @1152 stack[-1] // } 114C 61 PUSH2 0x1157 114F 84 DUP5 1150 84 DUP5 1151 84 DUP5 1152 84 DUP5 1153 61 PUSH2 0x1d8d 1156 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @114C stack[0] = 0x1157 // @114F stack[1] = stack[-4] // @1150 stack[2] = stack[-3] // @1151 stack[3] = stack[-2] // @1152 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1d8d 1157 5B JUMPDEST 1158 61 PUSH2 0x0e93 115B 57 *JUMPI 115C 60 PUSH1 0x40 115E 51 MLOAD 115F 63 PUSH4 0x68d2bf6b 1164 60 PUSH1 0xe1 1166 1B SHL 1167 81 DUP2 1168 52 MSTORE 1169 60 PUSH1 0x04 116B 01 ADD 116C 60 PUSH1 0x40 116E 51 MLOAD 116F 80 DUP1 1170 91 SWAP2 1171 03 SUB 1172 90 SWAP1 1173 FD *REVERT label_1174: // Incoming jump from 0x05B8 // Inputs[1] { @117A stack[-1] } 1174 5B JUMPDEST 1175 60 PUSH1 0x60 1177 61 PUSH2 0x117f 117A 82 DUP3 117B 61 PUSH2 0x14a2 117E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1175 stack[0] = 0x60 // @1177 stack[1] = 0x117f // @117A stack[2] = stack[-1] // } // Block ends with call to 0x14a2, returns to 0x117F label_117F: // Incoming return from call to 0x14A2 at 0x117E // Inputs[1] { @1183 stack[-1] } 117F 5B JUMPDEST 1180 61 PUSH2 0x11b5 1183 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x11b5, if stack[-1] label_1184: // Incoming jump from 0x1183, if not stack[-1] // Inputs[3] // { // @1186 memory[0x40:0x60] // @11AF memory[0x40:0x60] // @11B4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1184 60 PUSH1 0x40 1186 51 MLOAD 1187 7F PUSH32 0xa14c4b5000000000000000000000000000000000000000000000000000000000 11A8 81 DUP2 11A9 52 MSTORE 11AA 60 PUSH1 0x04 11AC 01 ADD 11AD 60 PUSH1 0x40 11AF 51 MLOAD 11B0 80 DUP1 11B1 91 SWAP2 11B2 03 SUB 11B3 90 SWAP1 11B4 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @11A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa14c4b5000000000000000000000000000000000000000000000000000000000 // @11B4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_11B5: // Incoming jump from 0x1183, if stack[-1] 11B5 5B JUMPDEST 11B6 60 PUSH1 0x00 11B8 61 PUSH2 0x11bf 11BB 61 PUSH2 0x1e85 11BE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @11B6 stack[0] = 0x00 // @11B8 stack[1] = 0x11bf // } // Block ends with unconditional jump to 0x1e85 11BF 5B JUMPDEST 11C0 90 SWAP1 11C1 50 POP 11C2 80 DUP1 11C3 51 MLOAD 11C4 60 PUSH1 0x00 11C6 14 EQ 11C7 15 ISZERO 11C8 61 PUSH2 0x11e0 11CB 57 *JUMPI 11CC 60 PUSH1 0x40 11CE 51 MLOAD 11CF 80 DUP1 11D0 60 PUSH1 0x20 11D2 01 ADD 11D3 60 PUSH1 0x40 11D5 52 MSTORE 11D6 80 DUP1 11D7 60 PUSH1 0x00 11D9 81 DUP2 11DA 52 MSTORE 11DB 50 POP 11DC 61 PUSH2 0x120b 11DF 56 *JUMP 11E0 5B JUMPDEST 11E1 80 DUP1 11E2 61 PUSH2 0x11ea 11E5 84 DUP5 11E6 61 PUSH2 0x1e94 11E9 56 *JUMP 11EA 5B JUMPDEST 11EB 60 PUSH1 0x40 11ED 51 MLOAD 11EE 60 PUSH1 0x20 11F0 01 ADD 11F1 61 PUSH2 0x11fb 11F4 92 SWAP3 11F5 91 SWAP2 11F6 90 SWAP1 11F7 61 PUSH2 0x290f 11FA 56 *JUMP 11FB 5B JUMPDEST 11FC 60 PUSH1 0x40 11FE 51 MLOAD 11FF 60 PUSH1 0x20 1201 81 DUP2 1202 83 DUP4 1203 03 SUB 1204 03 SUB 1205 81 DUP2 1206 52 MSTORE 1207 90 SWAP1 1208 60 PUSH1 0x40 120A 52 MSTORE label_120B: // Incoming return from call to 0x28E3 at 0x2A0D // Incoming return from call to 0x25C6 at 0x2628 // Incoming return from call to 0x2B75 at 0x2805 // Incoming jump from 0x246F, if !stack[-5] // Incoming return from call to 0x25E2 at 0x27AC // Incoming return from call to 0x2B75 at 0x2822 // Inputs[3] // { // @120C stack[-1] // @120C stack[-5] // @120D stack[-4] // } 120B 5B JUMPDEST 120C 93 SWAP4 120D 92 SWAP3 120E 50 POP 120F 50 POP 1210 50 POP 1211 56 *JUMP // Stack delta = -4 // Outputs[1] { @120C stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1212: // Incoming jump from 0x05D8 // Inputs[3] // { // @1215 stack[-2] // @1220 memory[0x00:0x40] // @1224 storage[0x01 + keccak256(memory[0x00:0x40])] // } 1212 5B JUMPDEST 1213 60 PUSH1 0x00 1215 82 DUP3 1216 81 DUP2 1217 52 MSTORE 1218 60 PUSH1 0x0b 121A 60 PUSH1 0x20 121C 52 MSTORE 121D 60 PUSH1 0x40 121F 90 SWAP1 1220 20 SHA3 1221 60 PUSH1 0x01 1223 01 ADD 1224 54 SLOAD 1225 61 PUSH2 0x122d 1228 81 DUP2 1229 61 PUSH2 0x1391 122C 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1217 memory[0x00:0x20] = stack[-2] // @121C memory[0x20:0x40] = 0x0b // @1224 stack[0] = storage[0x01 + keccak256(memory[0x00:0x40])] // @1225 stack[1] = 0x122d // @1228 stack[2] = storage[0x01 + keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x1391 122D 5B JUMPDEST 122E 61 PUSH2 0x0680 1231 83 DUP4 1232 83 DUP4 1233 61 PUSH2 0x17fa 1236 56 *JUMP label_1237: // Incoming jump from 0x0627 // Inputs[2] // { // @123A storage[0x0c] // @1244 msg.sender // } 1237 5B JUMPDEST 1238 60 PUSH1 0x0c 123A 54 SLOAD 123B 60 PUSH1 0x01 123D 60 PUSH1 0x01 123F 60 PUSH1 0xa0 1241 1B SHL 1242 03 SUB 1243 16 AND 1244 33 CALLER 1245 14 EQ 1246 61 PUSH2 0x1291 1249 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1291, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] label_124A: // Incoming jump from 0x1249, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] // Inputs[1] { @124C memory[0x40:0x60] } 124A 60 PUSH1 0x40 124C 51 MLOAD 124D 62 PUSH3 0x461bcd 1251 60 PUSH1 0xe5 1253 1B SHL 1254 81 DUP2 1255 52 MSTORE 1256 60 PUSH1 0x20 1258 60 PUSH1 0x04 125A 82 DUP3 125B 01 ADD 125C 81 DUP2 125D 90 SWAP1 125E 52 MSTORE 125F 60 PUSH1 0x24 1261 82 DUP3 1262 01 ADD 1263 52 MSTORE 1264 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1285 60 PUSH1 0x44 1287 82 DUP3 1288 01 ADD 1289 52 MSTORE 128A 60 PUSH1 0x64 128C 01 ADD 128D 61 PUSH2 0x0a1b 1290 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1255 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @125E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1263 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @1289 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @128C stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1b label_1291: // Incoming jump from 0x1249, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0c] // Inputs[1] { @129A stack[-1] } 1291 5B JUMPDEST 1292 60 PUSH1 0x01 1294 60 PUSH1 0x01 1296 60 PUSH1 0xa0 1298 1B SHL 1299 03 SUB 129A 81 DUP2 129B 16 AND 129C 61 PUSH2 0x130d 129F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x130d, if stack[-1] & (0x01 << 0xa0) - 0x01 label_12A0: // Incoming jump from 0x129F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12A2 memory[0x40:0x60] } 12A0 60 PUSH1 0x40 12A2 51 MLOAD 12A3 62 PUSH3 0x461bcd 12A7 60 PUSH1 0xe5 12A9 1B SHL 12AA 81 DUP2 12AB 52 MSTORE 12AC 60 PUSH1 0x20 12AE 60 PUSH1 0x04 12B0 82 DUP3 12B1 01 ADD 12B2 52 MSTORE 12B3 60 PUSH1 0x26 12B5 60 PUSH1 0x24 12B7 82 DUP3 12B8 01 ADD 12B9 52 MSTORE 12BA 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 12DB 60 PUSH1 0x44 12DD 82 DUP3 12DE 01 ADD 12DF 52 MSTORE 12E0 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 1301 60 PUSH1 0x64 1303 82 DUP3 1304 01 ADD 1305 52 MSTORE 1306 60 PUSH1 0x84 1308 01 ADD 1309 61 PUSH2 0x0a1b 130C 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @12AB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12B2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12B9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @12DF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1305 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @1308 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1b label_130D: // Incoming jump from 0x129F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1311 stack[-1] } 130D 5B JUMPDEST 130E 61 PUSH2 0x0a69 1311 81 DUP2 1312 61 PUSH2 0x1d2e 1315 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @130E stack[0] = 0x0a69 // @1311 stack[1] = stack[-1] // } // Block ends with call to 0x1d2e, returns to 0x0A69 label_1316: // Incoming jump from 0x063A 1316 5B JUMPDEST 1317 7F PUSH32 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b 1338 61 PUSH2 0x1340 133B 81 DUP2 133C 61 PUSH2 0x1391 133F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1317 stack[0] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // @1338 stack[1] = 0x1340 // @133B stack[2] = 0xd8acb51ff3d48f690a25887aaf234c4ae5a66ab9839243cd8e2b639cade0663b // } // Block ends with unconditional jump to 0x1391 1340 5B JUMPDEST 1341 81 DUP2 1342 51 MLOAD 1343 61 PUSH2 0x0680 1346 90 SWAP1 1347 60 PUSH1 0x35 1349 90 SWAP1 134A 60 PUSH1 0x20 134C 85 DUP6 134D 01 ADD 134E 90 SWAP1 134F 61 PUSH2 0x24b7 1352 56 *JUMP label_1353: // Incoming call from 0x0645, returns to 0x0646 // Inputs[1] { @135F stack[-1] } 1353 5B JUMPDEST 1354 60 PUSH1 0x00 1356 60 PUSH1 0x01 1358 60 PUSH1 0x01 135A 60 PUSH1 0xe0 135C 1B SHL 135D 03 SUB 135E 19 NOT 135F 82 DUP3 1360 16 AND 1361 7F PUSH32 0x7965db0b00000000000000000000000000000000000000000000000000000000 1382 14 EQ 1383 80 DUP1 1384 61 PUSH2 0x0646 1387 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1354 stack[0] = 0x00 // @1382 stack[1] = 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0646, if 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1388: // Incoming jump from 0x1387, if not 0x7965db0b00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @138C stack[-3] } 1388 50 POP 1389 61 PUSH2 0x0646 138C 82 DUP3 138D 61 PUSH2 0x1f92 1390 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1389 stack[-1] = 0x0646 // @138C stack[0] = stack[-3] // } // Block ends with call to 0x1f92, returns to 0x0646 label_1391: // Incoming jump from 0x0E87 // Incoming jump from 0x1125 // Incoming jump from 0x0FE0 // Incoming jump from 0x0E4A // Incoming jump from 0x133F // Incoming jump from 0x0996 // Incoming jump from 0x122C // Incoming jump from 0x0FA2 // Inputs[2] // { // @1395 stack[-1] // @1396 msg.sender // } 1391 5B JUMPDEST 1392 61 PUSH2 0x0a69 1395 81 DUP2 1396 33 CALLER 1397 61 PUSH2 0x1fd0 139A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1392 stack[0] = 0x0a69 // @1395 stack[1] = stack[-1] // @1396 stack[2] = msg.sender // } // Block ends with call to 0x1fd0, returns to 0x0A69 139B 5B JUMPDEST 139C 61 PUSH2 0x2710 139F 6B PUSH12 0xffffffffffffffffffffffff 13AC 82 DUP3 13AD 16 AND 13AE 11 GT 13AF 15 ISZERO 13B0 61 PUSH2 0x140e 13B3 57 *JUMPI 13B4 60 PUSH1 0x40 13B6 51 MLOAD 13B7 62 PUSH3 0x461bcd 13BB 60 PUSH1 0xe5 13BD 1B SHL 13BE 81 DUP2 13BF 52 MSTORE 13C0 60 PUSH1 0x20 13C2 60 PUSH1 0x04 13C4 82 DUP3 13C5 01 ADD 13C6 52 MSTORE 13C7 60 PUSH1 0x2a 13C9 60 PUSH1 0x24 13CB 82 DUP3 13CC 01 ADD 13CD 52 MSTORE 13CE 7F PUSH32 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 13EF 60 PUSH1 0x44 13F1 82 DUP3 13F2 01 ADD 13F3 52 MSTORE 13F4 69 PUSH10 0x2073616c655072696365 13FF 60 PUSH1 0xb0 1401 1B SHL 1402 60 PUSH1 0x64 1404 82 DUP3 1405 01 ADD 1406 52 MSTORE 1407 60 PUSH1 0x84 1409 01 ADD 140A 61 PUSH2 0x0a1b 140D 56 *JUMP 140E 5B JUMPDEST 140F 60 PUSH1 0x01 1411 60 PUSH1 0x01 1413 60 PUSH1 0xa0 1415 1B SHL 1416 03 SUB 1417 82 DUP3 1418 16 AND 1419 61 PUSH2 0x1464 141C 57 *JUMPI 141D 60 PUSH1 0x40 141F 51 MLOAD 1420 62 PUSH3 0x461bcd 1424 60 PUSH1 0xe5 1426 1B SHL 1427 81 DUP2 1428 52 MSTORE 1429 60 PUSH1 0x20 142B 60 PUSH1 0x04 142D 82 DUP3 142E 01 ADD 142F 52 MSTORE 1430 60 PUSH1 0x19 1432 60 PUSH1 0x24 1434 82 DUP3 1435 01 ADD 1436 52 MSTORE 1437 7F PUSH32 0x455243323938313a20696e76616c696420726563656976657200000000000000 1458 60 PUSH1 0x44 145A 82 DUP3 145B 01 ADD 145C 52 MSTORE 145D 60 PUSH1 0x64 145F 01 ADD 1460 61 PUSH2 0x0a1b 1463 56 *JUMP 1464 5B JUMPDEST 1465 60 PUSH1 0x40 1467 80 DUP1 1468 51 MLOAD 1469 80 DUP1 146A 82 DUP3 146B 01 ADD 146C 90 SWAP1 146D 91 SWAP2 146E 52 MSTORE 146F 60 PUSH1 0x01 1471 60 PUSH1 0x01 1473 60 PUSH1 0xa0 1475 1B SHL 1476 03 SUB 1477 90 SWAP1 1478 92 SWAP3 1479 16 AND 147A 80 DUP1 147B 83 DUP4 147C 52 MSTORE 147D 6B PUSH12 0xffffffffffffffffffffffff 148A 90 SWAP1 148B 91 SWAP2 148C 16 AND 148D 60 PUSH1 0x20 148F 90 SWAP1 1490 92 SWAP3 1491 01 ADD 1492 82 DUP3 1493 90 SWAP1 1494 52 MSTORE 1495 60 PUSH1 0x01 1497 60 PUSH1 0xa0 1499 1B SHL 149A 90 SWAP1 149B 91 SWAP2 149C 02 MUL 149D 17 OR 149E 60 PUSH1 0x08 14A0 55 SSTORE 14A1 56 *JUMP label_14A2: // Incoming call from 0x0721, returns to 0x0722 // Incoming call from 0x117E, returns to 0x117F // Inputs[2] // { // @14A6 storage[0x00] // @14A7 stack[-1] // } 14A2 5B JUMPDEST 14A3 60 PUSH1 0x00 14A5 80 DUP1 14A6 54 SLOAD 14A7 82 DUP3 14A8 10 LT 14A9 80 DUP1 14AA 15 ISZERO 14AB 61 PUSH2 0x0646 14AE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14A3 stack[0] = 0x00 // @14A8 stack[1] = stack[-1] < storage[0x00] // } // Block ends with conditional jump to 0x0646, if !(stack[-1] < storage[0x00]) label_14AF: // Incoming jump from 0x14AE, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @14B3 stack[-3] // @14BE memory[0x00:0x40] // @14BF storage[keccak256(memory[0x00:0x40])] // @14CB stack[-4] // } 14AF 50 POP 14B0 50 POP 14B1 60 PUSH1 0x00 14B3 90 SWAP1 14B4 81 DUP2 14B5 52 MSTORE 14B6 60 PUSH1 0x04 14B8 60 PUSH1 0x20 14BA 52 MSTORE 14BB 60 PUSH1 0x40 14BD 90 SWAP1 14BE 20 SHA3 14BF 54 SLOAD 14C0 60 PUSH1 0x01 14C2 60 PUSH1 0xe0 14C4 1B SHL 14C5 90 SWAP1 14C6 04 DIV 14C7 60 PUSH1 0xff 14C9 16 AND 14CA 15 ISZERO 14CB 90 SWAP1 14CC 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @14B5 memory[0x00:0x20] = stack[-3] // @14BA memory[0x20:0x40] = 0x04 // @14CB stack[-4] = !(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with unconditional jump to stack[-4] label_14CD: // Incoming call from 0x18F9, returns to 0x18FA // Incoming call from 0x1636, returns to 0x1637 // Incoming call from 0x0827, returns to 0x0680 // Inputs[8] // { // @14D0 stack[-2] // @14DC memory[0x00:0x40] // @14DE storage[keccak256(memory[0x00:0x40])] // @14FE stack[-3] // @1508 memory[0x40:0x60] // @150C stack[-1] // @1531 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1535 stack[-4] // } 14CD 5B JUMPDEST 14CE 60 PUSH1 0x00 14D0 82 DUP3 14D1 81 DUP2 14D2 52 MSTORE 14D3 60 PUSH1 0x06 14D5 60 PUSH1 0x20 14D7 52 MSTORE 14D8 60 PUSH1 0x40 14DA 80 DUP1 14DB 82 DUP3 14DC 20 SHA3 14DD 80 DUP1 14DE 54 SLOAD 14DF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14F4 19 NOT 14F5 16 AND 14F6 60 PUSH1 0x01 14F8 60 PUSH1 0x01 14FA 60 PUSH1 0xa0 14FC 1B SHL 14FD 03 SUB 14FE 87 DUP8 14FF 81 DUP2 1500 16 AND 1501 91 SWAP2 1502 82 DUP3 1503 17 OR 1504 90 SWAP1 1505 92 SWAP3 1506 55 SSTORE 1507 91 SWAP2 1508 51 MLOAD 1509 85 DUP6 150A 93 SWAP4 150B 91 SWAP2 150C 85 DUP6 150D 16 AND 150E 91 SWAP2 150F 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1530 91 SWAP2 1531 A4 LOG4 1532 50 POP 1533 50 POP 1534 50 POP 1535 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @14D2 memory[0x00:0x20] = stack[-2] // @14D7 memory[0x20:0x40] = 0x06 // @1506 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | (~0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])]) // @1531 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_1536: // Incoming call from 0x113A, returns to 0x113B // Incoming call from 0x08C0, returns to 0x0680 // Inputs[1] { @153C stack[-1] } 1536 5B JUMPDEST 1537 60 PUSH1 0x00 1539 61 PUSH2 0x1541 153C 82 DUP3 153D 61 PUSH2 0x1bf9 1540 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1537 stack[0] = 0x00 // @1539 stack[1] = 0x1541 // @153C stack[2] = stack[-1] // } // Block ends with call to 0x1bf9, returns to 0x1541 label_1541: // Incoming return from call to 0x1BF9 at 0x1540 // Inputs[4] // { // @1542 stack[-1] // @1542 stack[-2] // @1544 stack[-5] // @1552 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 1541 5B JUMPDEST 1542 90 SWAP1 1543 50 POP 1544 83 DUP4 1545 60 PUSH1 0x01 1547 60 PUSH1 0x01 1549 60 PUSH1 0xa0 154B 1B SHL 154C 03 SUB 154D 16 AND 154E 81 DUP2 154F 60 PUSH1 0x00 1551 01 ADD 1552 51 MLOAD 1553 60 PUSH1 0x01 1555 60 PUSH1 0x01 1557 60 PUSH1 0xa0 1559 1B SHL 155A 03 SUB 155B 16 AND 155C 14 EQ 155D 61 PUSH2 0x1592 1560 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1542 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1592, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] label_1561: // Incoming jump from 0x1560, if not (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[3] // { // @1563 memory[0x40:0x60] // @158C memory[0x40:0x60] // @1591 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1561 60 PUSH1 0x40 1563 51 MLOAD 1564 7F PUSH32 0xa114810000000000000000000000000000000000000000000000000000000000 1585 81 DUP2 1586 52 MSTORE 1587 60 PUSH1 0x04 1589 01 ADD 158A 60 PUSH1 0x40 158C 51 MLOAD 158D 80 DUP1 158E 91 SWAP2 158F 03 SUB 1590 90 SWAP1 1591 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1586 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa114810000000000000000000000000000000000000000000000000000000000 // @1591 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1592: // Incoming jump from 0x1560, if (0x01 << 0xa0) - 0x01 & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] == (0x01 << 0xa0) - 0x01 & stack[-5] // Inputs[2] // { // @1595 msg.sender // @159E stack[-4] // } 1592 5B JUMPDEST 1593 60 PUSH1 0x00 1595 33 CALLER 1596 60 PUSH1 0x01 1598 60 PUSH1 0x01 159A 60 PUSH1 0xa0 159C 1B SHL 159D 03 SUB 159E 86 DUP7 159F 16 AND 15A0 14 EQ 15A1 80 DUP1 15A2 61 PUSH2 0x15b0 15A5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1593 stack[0] = 0x00 // @15A0 stack[1] = stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x15b0, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender label_15A6: // Incoming jump from 0x15A5, if not stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @15AA stack[-6] // @15AB msg.sender // } 15A6 50 POP 15A7 61 PUSH2 0x15b0 15AA 85 DUP6 15AB 33 CALLER 15AC 61 PUSH2 0x05e7 15AF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15A7 stack[-1] = 0x15b0 // @15AA stack[0] = stack[-6] // @15AB stack[1] = msg.sender // } // Block ends with call to 0x05e7, returns to 0x15B0 label_15B0: // Incoming jump from 0x15A5, if stack[-4] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x05E7 at 0x15AF // Inputs[1] { @15B1 stack[-1] } 15B0 5B JUMPDEST 15B1 80 DUP1 15B2 61 PUSH2 0x15cb 15B5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x15cb, if stack[-1] label_15B6: // Incoming jump from 0x15B5, if not stack[-1] // Inputs[2] // { // @15B7 msg.sender // @15BB stack[-4] // } 15B6 50 POP 15B7 33 CALLER 15B8 61 PUSH2 0x15c0 15BB 84 DUP5 15BC 61 PUSH2 0x0717 15BF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @15B7 stack[-1] = msg.sender // @15B8 stack[0] = 0x15c0 // @15BB stack[1] = stack[-4] // } // Block ends with call to 0x0717, returns to 0x15C0 label_15C0: // Incoming return from call to 0x0717 at 0x15BF // Inputs[2] // { // @15C9 stack[-1] // @15CA stack[-2] // } 15C0 5B JUMPDEST 15C1 60 PUSH1 0x01 15C3 60 PUSH1 0x01 15C5 60 PUSH1 0xa0 15C7 1B SHL 15C8 03 SUB 15C9 16 AND 15CA 14 EQ // Stack delta = -1 // Outputs[1] { @15CA stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_15CB: // Incoming jump from 0x15CA // Incoming jump from 0x15B5, if stack[-1] // Inputs[2] // { // @15CC stack[-1] // @15CC stack[-2] // } 15CB 5B JUMPDEST 15CC 90 SWAP1 15CD 50 POP 15CE 80 DUP1 15CF 61 PUSH2 0x15eb 15D2 57 *JUMPI // Stack delta = -1 // Outputs[1] { @15CC stack[-2] = stack[-1] } // Block ends with conditional jump to 0x15eb, if stack[-1] label_15D3: // Incoming jump from 0x15D2, if not stack[-1] // Inputs[3] // { // @15D5 memory[0x40:0x60] // @15E5 memory[0x40:0x60] // @15EA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 15D3 60 PUSH1 0x40 15D5 51 MLOAD 15D6 63 PUSH4 0x2ce44b5f 15DB 60 PUSH1 0xe1 15DD 1B SHL 15DE 81 DUP2 15DF 52 MSTORE 15E0 60 PUSH1 0x04 15E2 01 ADD 15E3 60 PUSH1 0x40 15E5 51 MLOAD 15E6 80 DUP1 15E7 91 SWAP2 15E8 03 SUB 15E9 90 SWAP1 15EA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @15DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @15EA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_15EB: // Incoming jump from 0x15D2, if stack[-1] // Inputs[1] { @15F4 stack[-4] } 15EB 5B JUMPDEST 15EC 60 PUSH1 0x01 15EE 60 PUSH1 0x01 15F0 60 PUSH1 0xa0 15F2 1B SHL 15F3 03 SUB 15F4 84 DUP5 15F5 16 AND 15F6 61 PUSH2 0x162b 15F9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x162b, if stack[-4] & (0x01 << 0xa0) - 0x01 label_15FA: // Incoming jump from 0x15F9, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @15FC memory[0x40:0x60] // @1625 memory[0x40:0x60] // @162A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 15FA 60 PUSH1 0x40 15FC 51 MLOAD 15FD 7F PUSH32 0xea553b3400000000000000000000000000000000000000000000000000000000 161E 81 DUP2 161F 52 MSTORE 1620 60 PUSH1 0x04 1622 01 ADD 1623 60 PUSH1 0x40 1625 51 MLOAD 1626 80 DUP1 1627 91 SWAP2 1628 03 SUB 1629 90 SWAP1 162A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @161F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000 // @162A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_162B: // Incoming jump from 0x15F9, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1631 stack[-3] // @1632 stack[-5] // } 162B 5B JUMPDEST 162C 61 PUSH2 0x1637 162F 60 PUSH1 0x00 1631 84 DUP5 1632 87 DUP8 1633 61 PUSH2 0x14cd 1636 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @162C stack[0] = 0x1637 // @162F stack[1] = 0x00 // @1631 stack[2] = stack[-3] // @1632 stack[3] = stack[-5] // } // Block ends with call to 0x14cd, returns to 0x1637 label_1637: // Incoming return from call to 0x14CD at 0x1636 // Inputs[12] // { // @1640 stack[-5] // @1653 memory[0x00:0x40] // @1655 storage[keccak256(memory[0x00:0x40])] // @1679 stack[-4] // @1681 memory[0x00:0x40] // @1683 storage[keccak256(memory[0x00:0x40])] // @1697 stack[-3] // @16A1 memory[0x00:0x40] // @16A3 storage[keccak256(memory[0x00:0x40])] // @16B6 block.timestamp // @16C7 memory[0x00:0x40] // @16C9 storage[keccak256(memory[0x00:0x40])] // } 1637 5B JUMPDEST 1638 60 PUSH1 0x01 163A 60 PUSH1 0x01 163C 60 PUSH1 0xa0 163E 1B SHL 163F 03 SUB 1640 85 DUP6 1641 81 DUP2 1642 16 AND 1643 60 PUSH1 0x00 1645 90 SWAP1 1646 81 DUP2 1647 52 MSTORE 1648 60 PUSH1 0x05 164A 60 PUSH1 0x20 164C 90 SWAP1 164D 81 DUP2 164E 52 MSTORE 164F 60 PUSH1 0x40 1651 80 DUP1 1652 83 DUP4 1653 20 SHA3 1654 80 DUP1 1655 54 SLOAD 1656 67 PUSH8 0xffffffffffffffff 165F 19 NOT 1660 80 DUP1 1661 82 DUP3 1662 16 AND 1663 67 PUSH8 0xffffffffffffffff 166C 92 SWAP3 166D 83 DUP4 166E 16 AND 166F 60 PUSH1 0x00 1671 19 NOT 1672 01 ADD 1673 83 DUP4 1674 16 AND 1675 17 OR 1676 90 SWAP1 1677 92 SWAP3 1678 55 SSTORE 1679 89 DUP10 167A 86 DUP7 167B 16 AND 167C 80 DUP1 167D 86 DUP7 167E 52 MSTORE 167F 83 DUP4 1680 86 DUP7 1681 20 SHA3 1682 80 DUP1 1683 54 SLOAD 1684 93 SWAP4 1685 84 DUP5 1686 16 AND 1687 93 SWAP4 1688 83 DUP4 1689 16 AND 168A 60 PUSH1 0x01 168C 90 SWAP1 168D 81 DUP2 168E 01 ADD 168F 84 DUP5 1690 16 AND 1691 94 SWAP5 1692 90 SWAP1 1693 94 SWAP5 1694 17 OR 1695 90 SWAP1 1696 55 SSTORE 1697 89 DUP10 1698 86 DUP7 1699 52 MSTORE 169A 60 PUSH1 0x04 169C 90 SWAP1 169D 94 SWAP5 169E 52 MSTORE 169F 82 DUP3 16A0 85 DUP6 16A1 20 SHA3 16A2 80 DUP1 16A3 54 SLOAD 16A4 60 PUSH1 0x01 16A6 60 PUSH1 0x01 16A8 60 PUSH1 0xe0 16AA 1B SHL 16AB 03 SUB 16AC 19 NOT 16AD 16 AND 16AE 90 SWAP1 16AF 94 SWAP5 16B0 17 OR 16B1 60 PUSH1 0x01 16B3 60 PUSH1 0xa0 16B5 1B SHL 16B6 42 TIMESTAMP 16B7 90 SWAP1 16B8 92 SWAP3 16B9 16 AND 16BA 91 SWAP2 16BB 90 SWAP1 16BC 91 SWAP2 16BD 02 MUL 16BE 17 OR 16BF 83 DUP4 16C0 55 SSTORE 16C1 87 DUP8 16C2 01 ADD 16C3 80 DUP1 16C4 84 DUP5 16C5 52 MSTORE 16C6 92 SWAP3 16C7 20 SHA3 16C8 80 DUP1 16C9 54 SLOAD 16CA 91 SWAP2 16CB 93 SWAP4 16CC 90 SWAP1 16CD 91 SWAP2 16CE 16 AND 16CF 61 PUSH2 0x170d 16D2 57 *JUMPI // Stack delta = +3 // Outputs[12] // { // @1647 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @164E memory[0x20:0x40] = 0x05 // @1678 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & ~0x00 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @167E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1696 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])])) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff) // @1699 memory[0x00:0x20] = stack[-3] // @169E memory[0x20:0x40] = 0x04 // @16C0 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | ((0x01 << 0xa0) - 0x01 & stack[-4]) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @16C5 memory[0x00:0x20] = stack[-3] + 0x01 // @16C6 stack[1] = stack[-3] + 0x01 // @16CB stack[0] = keccak256(memory[0x00:0x40]) // @16CD stack[2] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x170d, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_16D3: // Incoming jump from 0x16D2, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @16D5 storage[0x00] // @16D6 stack[-2] // } 16D3 60 PUSH1 0x00 16D5 54 SLOAD 16D6 82 DUP3 16D7 14 EQ 16D8 61 PUSH2 0x170d 16DB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x170d, if stack[-2] == storage[0x00] label_16DC: // Incoming jump from 0x16DB, if not stack[-2] == storage[0x00] // Inputs[5] // { // @16DC stack[-1] // @16DD storage[stack[-1]] // @16E0 stack[-5] // @16E2 memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1707 stack[-8] // } 16DC 80 DUP1 16DD 54 SLOAD 16DE 60 PUSH1 0x20 16E0 86 DUP7 16E1 01 ADD 16E2 51 MLOAD 16E3 67 PUSH8 0xffffffffffffffff 16EC 16 AND 16ED 60 PUSH1 0x01 16EF 60 PUSH1 0xa0 16F1 1B SHL 16F2 02 MUL 16F3 60 PUSH1 0x01 16F5 60 PUSH1 0x01 16F7 60 PUSH1 0xe0 16F9 1B SHL 16FA 03 SUB 16FB 19 NOT 16FC 90 SWAP1 16FD 91 SWAP2 16FE 16 AND 16FF 60 PUSH1 0x01 1701 60 PUSH1 0x01 1703 60 PUSH1 0xa0 1705 1B SHL 1706 03 SUB 1707 8A DUP11 1708 16 AND 1709 17 OR 170A 17 OR 170B 81 DUP2 170C 55 SSTORE // Stack delta = +0 // Outputs[1] { @170C storage[stack[-1]] = (stack[-8] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20]) } // Block continues label_170D: // Incoming jump from 0x170C // Incoming jump from 0x16DB, if stack[-2] == storage[0x00] // Incoming jump from 0x16D2, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[7] // { // @1711 stack[-6] // @1712 stack[-7] // @171C stack[-8] // @1749 memory[0x40:0x60] // @174C memory[0x40:0x60] // @1751 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1757 stack[-9] // } 170D 5B JUMPDEST 170E 50 POP 170F 50 POP 1710 50 POP 1711 82 DUP3 1712 84 DUP5 1713 60 PUSH1 0x01 1715 60 PUSH1 0x01 1717 60 PUSH1 0xa0 1719 1B SHL 171A 03 SUB 171B 16 AND 171C 86 DUP7 171D 60 PUSH1 0x01 171F 60 PUSH1 0x01 1721 60 PUSH1 0xa0 1723 1B SHL 1724 03 SUB 1725 16 AND 1726 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1747 60 PUSH1 0x40 1749 51 MLOAD 174A 60 PUSH1 0x40 174C 51 MLOAD 174D 80 DUP1 174E 91 SWAP2 174F 03 SUB 1750 90 SWAP1 1751 A4 LOG4 1752 50 POP 1753 50 POP 1754 50 POP 1755 50 POP 1756 50 POP 1757 56 *JUMP // Stack delta = -9 // Outputs[1] { @1751 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-8] & (0x01 << 0xa0) - 0x01, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6]]); } // Block ends with unconditional jump to stack[-9] 1758 5B JUMPDEST 1759 60 PUSH1 0x00 175B 82 DUP3 175C 81 DUP2 175D 52 MSTORE 175E 60 PUSH1 0x0b 1760 60 PUSH1 0x20 1762 90 SWAP1 1763 81 DUP2 1764 52 MSTORE 1765 60 PUSH1 0x40 1767 80 DUP1 1768 83 DUP4 1769 20 SHA3 176A 60 PUSH1 0x01 176C 60 PUSH1 0x01 176E 60 PUSH1 0xa0 1770 1B SHL 1771 03 SUB 1772 85 DUP6 1773 16 AND 1774 84 DUP5 1775 52 MSTORE 1776 90 SWAP1 1777 91 SWAP2 1778 52 MSTORE 1779 90 SWAP1 177A 20 SHA3 177B 54 SLOAD 177C 60 PUSH1 0xff 177E 16 AND 177F 61 PUSH2 0x0a2e 1782 57 *JUMPI 1783 60 PUSH1 0x00 1785 82 DUP3 1786 81 DUP2 1787 52 MSTORE 1788 60 PUSH1 0x0b 178A 60 PUSH1 0x20 178C 90 SWAP1 178D 81 DUP2 178E 52 MSTORE 178F 60 PUSH1 0x40 1791 80 DUP1 1792 83 DUP4 1793 20 SHA3 1794 60 PUSH1 0x01 1796 60 PUSH1 0x01 1798 60 PUSH1 0xa0 179A 1B SHL 179B 03 SUB 179C 85 DUP6 179D 16 AND 179E 84 DUP5 179F 52 MSTORE 17A0 90 SWAP1 17A1 91 SWAP2 17A2 52 MSTORE 17A3 90 SWAP1 17A4 20 SHA3 17A5 80 DUP1 17A6 54 SLOAD 17A7 60 PUSH1 0xff 17A9 19 NOT 17AA 16 AND 17AB 60 PUSH1 0x01 17AD 17 OR 17AE 90 SWAP1 17AF 55 SSTORE 17B0 61 PUSH2 0x17b6 17B3 33 CALLER 17B4 90 SWAP1 17B5 56 *JUMP 17B6 5B JUMPDEST 17B7 60 PUSH1 0x01 17B9 60 PUSH1 0x01 17BB 60 PUSH1 0xa0 17BD 1B SHL 17BE 03 SUB 17BF 16 AND 17C0 81 DUP2 17C1 60 PUSH1 0x01 17C3 60 PUSH1 0x01 17C5 60 PUSH1 0xa0 17C7 1B SHL 17C8 03 SUB 17C9 16 AND 17CA 83 DUP4 17CB 7F PUSH32 0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d 17EC 60 PUSH1 0x40 17EE 51 MLOAD 17EF 60 PUSH1 0x40 17F1 51 MLOAD 17F2 80 DUP1 17F3 91 SWAP2 17F4 03 SUB 17F5 90 SWAP1 17F6 A4 LOG4 17F7 50 POP 17F8 50 POP 17F9 56 *JUMP label_17FA: // Incoming call from 0x0A2D, returns to 0x0A2E // Inputs[5] // { // @17FD stack[-2] // @180B memory[0x00:0x40] // @1814 stack[-1] // @181C memory[0x00:0x40] // @181D storage[keccak256(memory[0x00:0x40])] // } 17FA 5B JUMPDEST 17FB 60 PUSH1 0x00 17FD 82 DUP3 17FE 81 DUP2 17FF 52 MSTORE 1800 60 PUSH1 0x0b 1802 60 PUSH1 0x20 1804 90 SWAP1 1805 81 DUP2 1806 52 MSTORE 1807 60 PUSH1 0x40 1809 80 DUP1 180A 83 DUP4 180B 20 SHA3 180C 60 PUSH1 0x01 180E 60 PUSH1 0x01 1810 60 PUSH1 0xa0 1812 1B SHL 1813 03 SUB 1814 85 DUP6 1815 16 AND 1816 84 DUP5 1817 52 MSTORE 1818 90 SWAP1 1819 91 SWAP2 181A 52 MSTORE 181B 90 SWAP1 181C 20 SHA3 181D 54 SLOAD 181E 60 PUSH1 0xff 1820 16 AND 1821 15 ISZERO 1822 61 PUSH2 0x0a2e 1825 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @17FF memory[0x00:0x20] = stack[-2] // @1806 memory[0x20:0x40] = 0x0b // @1817 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @181A memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0a2e, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_1826: // Incoming jump from 0x1825, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[9] // { // @1828 stack[-2] // @1836 memory[0x00:0x40] // @183F stack[-1] // @1848 memory[0x00:0x40] // @184A storage[keccak256(memory[0x00:0x40])] // @1851 memory[0x40:0x60] // @1852 msg.sender // @1879 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @187C stack[-3] // } 1826 60 PUSH1 0x00 1828 82 DUP3 1829 81 DUP2 182A 52 MSTORE 182B 60 PUSH1 0x0b 182D 60 PUSH1 0x20 182F 90 SWAP1 1830 81 DUP2 1831 52 MSTORE 1832 60 PUSH1 0x40 1834 80 DUP1 1835 83 DUP4 1836 20 SHA3 1837 60 PUSH1 0x01 1839 60 PUSH1 0x01 183B 60 PUSH1 0xa0 183D 1B SHL 183E 03 SUB 183F 85 DUP6 1840 16 AND 1841 80 DUP1 1842 85 DUP6 1843 52 MSTORE 1844 92 SWAP3 1845 52 MSTORE 1846 80 DUP1 1847 83 DUP4 1848 20 SHA3 1849 80 DUP1 184A 54 SLOAD 184B 60 PUSH1 0xff 184D 19 NOT 184E 16 AND 184F 90 SWAP1 1850 55 SSTORE 1851 51 MLOAD 1852 33 CALLER 1853 92 SWAP3 1854 85 DUP6 1855 91 SWAP2 1856 7F PUSH32 0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b 1877 91 SWAP2 1878 90 SWAP1 1879 A4 LOG4 187A 50 POP 187B 50 POP 187C 56 *JUMP // Stack delta = -3 // Outputs[6] // { // @182A memory[0x00:0x20] = stack[-2] // @1831 memory[0x20:0x40] = 0x0b // @1843 memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1845 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1850 storage[keccak256(memory[0x00:0x40])] = ~0xff & storage[keccak256(memory[0x00:0x40])] // @1879 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b, stack[-2], stack[-1] & (0x01 << 0xa0) - 0x01, msg.sender]); // } // Block ends with unconditional jump to stack[-3] label_187D: // Incoming call from 0x0A57, returns to 0x0A58 // Inputs[1] { @1883 stack[-2] } 187D 5B JUMPDEST 187E 60 PUSH1 0x00 1880 61 PUSH2 0x1888 1883 83 DUP4 1884 61 PUSH2 0x1bf9 1887 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @187E stack[0] = 0x00 // @1880 stack[1] = 0x1888 // @1883 stack[2] = stack[-2] // } // Block ends with call to 0x1bf9, returns to 0x1888 label_1888: // Incoming return from call to 0x1BF9 at 0x1887 // Inputs[4] // { // @1889 stack[-1] // @188A memory[stack[-1]:stack[-1] + 0x20] // @188C stack[-2] // @188E stack[-3] // } 1888 5B JUMPDEST 1889 80 DUP1 188A 51 MLOAD 188B 90 SWAP1 188C 91 SWAP2 188D 50 POP 188E 82 DUP3 188F 15 ISZERO 1890 61 PUSH2 0x18ee 1893 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @188B stack[-1] = memory[stack[-1]:stack[-1] + 0x20] // @188C stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x18ee, if !stack[-3] label_1894: // Incoming jump from 0x1893, if not !stack[-3] // Inputs[2] // { // @1896 msg.sender // @189F stack[-1] // } 1894 60 PUSH1 0x00 1896 33 CALLER 1897 60 PUSH1 0x01 1899 60 PUSH1 0x01 189B 60 PUSH1 0xa0 189D 1B SHL 189E 03 SUB 189F 83 DUP4 18A0 16 AND 18A1 14 EQ 18A2 80 DUP1 18A3 61 PUSH2 0x18b1 18A6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1894 stack[0] = 0x00 // @18A1 stack[1] = stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // } // Block ends with conditional jump to 0x18b1, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender label_18A7: // Incoming jump from 0x18A6, if not stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Inputs[2] // { // @18AB stack[-3] // @18AC msg.sender // } 18A7 50 POP 18A8 61 PUSH2 0x18b1 18AB 82 DUP3 18AC 33 CALLER 18AD 61 PUSH2 0x05e7 18B0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18A8 stack[-1] = 0x18b1 // @18AB stack[0] = stack[-3] // @18AC stack[1] = msg.sender // } // Block ends with call to 0x05e7, returns to 0x18B1 label_18B1: // Incoming jump from 0x18A6, if stack[-1] & (0x01 << 0xa0) - 0x01 == msg.sender // Incoming return from call to 0x05E7 at 0x18B0 // Inputs[1] { @18B2 stack[-1] } 18B1 5B JUMPDEST 18B2 80 DUP1 18B3 61 PUSH2 0x18cc 18B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18cc, if stack[-1] label_18B7: // Incoming jump from 0x18B6, if not stack[-1] // Inputs[2] // { // @18B8 msg.sender // @18BC stack[-6] // } 18B7 50 POP 18B8 33 CALLER 18B9 61 PUSH2 0x18c1 18BC 86 DUP7 18BD 61 PUSH2 0x0717 18C0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @18B8 stack[-1] = msg.sender // @18B9 stack[0] = 0x18c1 // @18BC stack[1] = stack[-6] // } // Block ends with call to 0x0717, returns to 0x18C1 label_18C1: // Incoming return from call to 0x0717 at 0x18C0 // Inputs[2] // { // @18CA stack[-1] // @18CB stack[-2] // } 18C1 5B JUMPDEST 18C2 60 PUSH1 0x01 18C4 60 PUSH1 0x01 18C6 60 PUSH1 0xa0 18C8 1B SHL 18C9 03 SUB 18CA 16 AND 18CB 14 EQ // Stack delta = -1 // Outputs[1] { @18CB stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_18CC: // Incoming jump from 0x18CB // Incoming jump from 0x18B6, if stack[-1] // Inputs[2] // { // @18CD stack[-2] // @18CD stack[-1] // } 18CC 5B JUMPDEST 18CD 90 SWAP1 18CE 50 POP 18CF 80 DUP1 18D0 61 PUSH2 0x18ec 18D3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @18CD stack[-2] = stack[-1] } // Block ends with conditional jump to 0x18ec, if stack[-1] label_18D4: // Incoming jump from 0x18D3, if not stack[-1] // Inputs[3] // { // @18D6 memory[0x40:0x60] // @18E6 memory[0x40:0x60] // @18EB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 18D4 60 PUSH1 0x40 18D6 51 MLOAD 18D7 63 PUSH4 0x2ce44b5f 18DC 60 PUSH1 0xe1 18DE 1B SHL 18DF 81 DUP2 18E0 52 MSTORE 18E1 60 PUSH1 0x04 18E3 01 ADD 18E4 60 PUSH1 0x40 18E6 51 MLOAD 18E7 80 DUP1 18E8 91 SWAP2 18E9 03 SUB 18EA 90 SWAP1 18EB FD *REVERT // Stack delta = +0 // Outputs[2] // { // @18E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2ce44b5f << 0xe1 // @18EB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_18EC: // Incoming jump from 0x18D3, if stack[-1] 18EC 5B JUMPDEST 18ED 50 POP // Stack delta = -1 // Block continues label_18EE: // Incoming jump from 0x18ED // Incoming jump from 0x1893, if !stack[-3] // Inputs[2] // { // @18F4 stack[-4] // @18F5 stack[-1] // } 18EE 5B JUMPDEST 18EF 61 PUSH2 0x18fa 18F2 60 PUSH1 0x00 18F4 85 DUP6 18F5 83 DUP4 18F6 61 PUSH2 0x14cd 18F9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18EF stack[0] = 0x18fa // @18F2 stack[1] = 0x00 // @18F4 stack[2] = stack[-4] // @18F5 stack[3] = stack[-1] // } // Block ends with call to 0x14cd, returns to 0x18FA label_18FA: // Incoming return from call to 0x14CD at 0x18F9 // Inputs[9] // { // @1904 stack[-1] // @1916 memory[0x00:0x40] // @1918 storage[keccak256(memory[0x00:0x40])] // @1988 stack[-4] // @1992 memory[0x00:0x40] // @1994 storage[keccak256(memory[0x00:0x40])] // @19B6 block.timestamp // @19E3 memory[0x00:0x40] // @19E5 storage[keccak256(memory[0x00:0x40])] // } 18FA 5B JUMPDEST 18FB 60 PUSH1 0x01 18FD 60 PUSH1 0x01 18FF 60 PUSH1 0xa0 1901 1B SHL 1902 03 SUB 1903 80 DUP1 1904 82 DUP3 1905 16 AND 1906 60 PUSH1 0x00 1908 81 DUP2 1909 81 DUP2 190A 52 MSTORE 190B 60 PUSH1 0x05 190D 60 PUSH1 0x20 190F 90 SWAP1 1910 81 DUP2 1911 52 MSTORE 1912 60 PUSH1 0x40 1914 80 DUP1 1915 83 DUP4 1916 20 SHA3 1917 80 DUP1 1918 54 SLOAD 1919 70 PUSH17 0x0100000000000000000000000000000000 192B 60 PUSH1 0x00 192D 19 NOT 192E 67 PUSH8 0xffffffffffffffff 1937 80 DUP1 1938 84 DUP5 1939 16 AND 193A 91 SWAP2 193B 90 SWAP1 193C 91 SWAP2 193D 01 ADD 193E 81 DUP2 193F 16 AND 1940 67 PUSH8 0xffffffffffffffff 1949 19 NOT 194A 84 DUP5 194B 16 AND 194C 81 DUP2 194D 17 OR 194E 83 DUP4 194F 90 SWAP1 1950 04 DIV 1951 82 DUP3 1952 16 AND 1953 60 PUSH1 0x01 1955 90 SWAP1 1956 81 DUP2 1957 01 ADD 1958 83 DUP4 1959 16 AND 195A 90 SWAP1 195B 93 SWAP4 195C 02 MUL 195D 7F PUSH32 0xffffffffffffffff0000000000000000ffffffffffffffff0000000000000000 197E 90 SWAP1 197F 94 SWAP5 1980 16 AND 1981 17 OR 1982 92 SWAP3 1983 90 SWAP1 1984 92 SWAP3 1985 17 OR 1986 83 DUP4 1987 55 SSTORE 1988 8B DUP12 1989 86 DUP7 198A 52 MSTORE 198B 60 PUSH1 0x04 198D 90 SWAP1 198E 94 SWAP5 198F 52 MSTORE 1990 82 DUP3 1991 85 DUP6 1992 20 SHA3 1993 80 DUP1 1994 54 SLOAD 1995 7F PUSH32 0xffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffff 19B6 42 TIMESTAMP 19B7 90 SWAP1 19B8 93 SWAP4 19B9 16 AND 19BA 60 PUSH1 0x01 19BC 60 PUSH1 0xa0 19BE 1B SHL 19BF 02 MUL 19C0 60 PUSH1 0x01 19C2 60 PUSH1 0x01 19C4 60 PUSH1 0xe0 19C6 1B SHL 19C7 03 SUB 19C8 19 NOT 19C9 90 SWAP1 19CA 91 SWAP2 19CB 16 AND 19CC 90 SWAP1 19CD 97 SWAP8 19CE 17 OR 19CF 96 SWAP7 19D0 90 SWAP1 19D1 96 SWAP7 19D2 17 OR 19D3 16 AND 19D4 60 PUSH1 0x01 19D6 60 PUSH1 0xe0 19D8 1B SHL 19D9 17 OR 19DA 85 DUP6 19DB 55 SSTORE 19DC 91 SWAP2 19DD 89 DUP10 19DE 01 ADD 19DF 80 DUP1 19E0 84 DUP5 19E1 52 MSTORE 19E2 92 SWAP3 19E3 20 SHA3 19E4 80 DUP1 19E5 54 SLOAD 19E6 91 SWAP2 19E7 94 SWAP5 19E8 90 SWAP1 19E9 91 SWAP2 19EA 16 AND 19EB 61 PUSH2 0x1a29 19EE 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @190A memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1911 memory[0x20:0x40] = 0x05 // @1987 storage[keccak256(memory[0x00:0x40])] = (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff0000000000000000ffffffffffffffff0000000000000000) | (0xffffffffffffffff & (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff) + ~0x00) | 0x0100000000000000000000000000000000 * (0xffffffffffffffff & 0x01 + (0xffffffffffffffff & ((0xffffffffffffffff & (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff) + ~0x00) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x0100000000000000000000000000000000)) // @198A memory[0x00:0x20] = stack[-4] // @198F memory[0x20:0x40] = 0x04 // @19D1 stack[1] = keccak256(memory[0x00:0x40]) // @19DB storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe0) | (((stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & block.timestamp)) & 0xffffff00ffffffffffffffffffffffffffffffffffffffffffffffffffffffff) // @19E1 memory[0x00:0x20] = stack[-4] + 0x01 // @19E2 stack[2] = stack[-4] + 0x01 // @19E7 stack[0] = keccak256(memory[0x00:0x40]) // @19E9 stack[3] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x1a29, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_19EF: // Incoming jump from 0x19EE, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @19F1 storage[0x00] // @19F2 stack[-2] // } 19EF 60 PUSH1 0x00 19F1 54 SLOAD 19F2 82 DUP3 19F3 14 EQ 19F4 61 PUSH2 0x1a29 19F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a29, if stack[-2] == storage[0x00] label_19F8: // Incoming jump from 0x19F7, if not stack[-2] == storage[0x00] // Inputs[5] // { // @19F8 stack[-1] // @19F9 storage[stack[-1]] // @19FC stack[-6] // @19FE memory[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @1A23 stack[-5] // } 19F8 80 DUP1 19F9 54 SLOAD 19FA 60 PUSH1 0x20 19FC 87 DUP8 19FD 01 ADD 19FE 51 MLOAD 19FF 67 PUSH8 0xffffffffffffffff 1A08 16 AND 1A09 60 PUSH1 0x01 1A0B 60 PUSH1 0xa0 1A0D 1B SHL 1A0E 02 MUL 1A0F 60 PUSH1 0x01 1A11 60 PUSH1 0x01 1A13 60 PUSH1 0xe0 1A15 1B SHL 1A16 03 SUB 1A17 19 NOT 1A18 90 SWAP1 1A19 91 SWAP2 1A1A 16 AND 1A1B 60 PUSH1 0x01 1A1D 60 PUSH1 0x01 1A1F 60 PUSH1 0xa0 1A21 1B SHL 1A22 03 SUB 1A23 87 DUP8 1A24 16 AND 1A25 17 OR 1A26 17 OR 1A27 81 DUP2 1A28 55 SSTORE // Stack delta = +0 // Outputs[1] { @1A28 storage[stack[-1]] = (stack[-5] & (0x01 << 0xa0) - 0x01) | (storage[stack[-1]] & ~((0x01 << 0xe0) - 0x01)) | (0x01 << 0xa0) * (0xffffffffffffffff & memory[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20]) } // Block continues label_1A29: // Incoming jump from 0x19EE, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x19F7, if stack[-2] == storage[0x00] // Incoming jump from 0x1A28 // Inputs[8] // { // @1A2E memory[0x40:0x60] // @1A2F stack[-8] // @1A30 stack[-4] // @1A34 stack[-3] // @1A3E stack[-5] // @1A65 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1A6B storage[0x01] // @1A72 stack[-9] // } 1A29 5B JUMPDEST 1A2A 50 POP 1A2B 50 POP 1A2C 60 PUSH1 0x40 1A2E 51 MLOAD 1A2F 86 DUP7 1A30 92 SWAP3 1A31 50 POP 1A32 60 PUSH1 0x00 1A34 91 SWAP2 1A35 50 POP 1A36 60 PUSH1 0x01 1A38 60 PUSH1 0x01 1A3A 60 PUSH1 0xa0 1A3C 1B SHL 1A3D 03 SUB 1A3E 84 DUP5 1A3F 16 AND 1A40 90 SWAP1 1A41 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1A62 90 SWAP1 1A63 83 DUP4 1A64 90 SWAP1 1A65 A4 LOG4 1A66 50 POP 1A67 50 POP 1A68 60 PUSH1 0x01 1A6A 80 DUP1 1A6B 54 SLOAD 1A6C 81 DUP2 1A6D 01 ADD 1A6E 90 SWAP1 1A6F 55 SSTORE 1A70 50 POP 1A71 50 POP 1A72 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @1A65 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-5] & (0x01 << 0xa0) - 0x01, 0x00, stack[-8]]); // @1A6F storage[0x01] = 0x01 + storage[0x01] // } // Block ends with unconditional jump to stack[-9] label_1A73: // Incoming call from 0x0C70, returns to 0x0C71 // Incoming call from 0x0DEC, returns to 0x0DED // Inputs[1] { @1A7C stack[-1] } 1A73 5B JUMPDEST 1A74 60 PUSH1 0x00 1A76 61 PUSH2 0x1a81 1A79 61 PUSH2 0x0100 1A7C 83 DUP4 1A7D 61 PUSH2 0x2a26 1A80 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1A74 stack[0] = 0x00 // @1A76 stack[1] = 0x1a81 // @1A79 stack[2] = 0x0100 // @1A7C stack[3] = stack[-1] // } // Block ends with call to 0x2a26, returns to 0x1A81 label_1A81: // Incoming return from call to 0x2A26 at 0x1A80 // Inputs[3] // { // @1A82 stack[-2] // @1A82 stack[-1] // @1A8C stack[-3] // } 1A81 5B JUMPDEST 1A82 90 SWAP1 1A83 50 POP 1A84 60 PUSH1 0x00 1A86 61 PUSH2 0x1a91 1A89 61 PUSH2 0x0100 1A8C 84 DUP5 1A8D 61 PUSH2 0x2b09 1A90 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @1A82 stack[-2] = stack[-1] // @1A84 stack[-1] = 0x00 // @1A86 stack[0] = 0x1a91 // @1A89 stack[1] = 0x0100 // @1A8C stack[2] = stack[-3] // } // Block ends with call to 0x2b09, returns to 0x1A91 label_1A91: // Incoming return from call to 0x2B09 at 0x1A90 // Inputs[3] // { // @1A92 stack[-2] // @1A92 stack[-1] // @1A9A stack[-3] // } 1A91 5B JUMPDEST 1A92 90 SWAP1 1A93 50 POP 1A94 60 PUSH1 0x01 1A96 81 DUP2 1A97 1B SHL 1A98 60 PUSH1 0x0d 1A9A 83 DUP4 1A9B 60 PUSH1 0x28 1A9D 81 DUP2 1A9E 10 LT 1A9F 61 PUSH2 0x1aaa 1AA2 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1A92 stack[-2] = stack[-1] // @1A97 stack[-1] = 0x01 << stack[-1] // @1A98 stack[0] = 0x0d // @1A9A stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1aaa, if stack[-3] < 0x28 label_1AA3: // Incoming jump from 0x1AA2, if not stack[-3] < 0x28 1AA3 61 PUSH2 0x1aaa 1AA6 61 PUSH2 0x2b49 1AA9 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AA3 stack[0] = 0x1aaa } // Block ends with unconditional jump to 0x2b49 label_1AAA: // Incoming jump from 0x1AA2, if stack[-3] < 0x28 // Inputs[5] // { // @1AAB stack[-2] // @1AAB stack[-1] // @1AAC storage[stack[-1] + stack[-2]] // @1AAD stack[-3] // @1AB0 stack[-5] // } 1AAA 5B JUMPDEST 1AAB 01 ADD 1AAC 54 SLOAD 1AAD 17 OR 1AAE 60 PUSH1 0x0d 1AB0 83 DUP4 1AB1 60 PUSH1 0x28 1AB3 81 DUP2 1AB4 10 LT 1AB5 61 PUSH2 0x1ac0 1AB8 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1AAD stack[-3] = storage[stack[-1] + stack[-2]] | stack[-3] // @1AAE stack[-2] = 0x0d // @1AB0 stack[-1] = stack[-5] // } // Block ends with conditional jump to 0x1ac0, if stack[-5] < 0x28 label_1AB9: // Incoming jump from 0x1AB8, if not stack[-5] < 0x28 1AB9 61 PUSH2 0x1ac0 1ABC 61 PUSH2 0x2b49 1ABF 56 *JUMP // Stack delta = +1 // Outputs[1] { @1AB9 stack[0] = 0x1ac0 } // Block ends with unconditional jump to 0x2b49 label_1AC0: // Incoming jump from 0x1AB8, if stack[-5] < 0x28 // Inputs[4] // { // @1AC1 stack[-1] // @1AC1 stack[-2] // @1AC2 stack[-3] // @1AC6 stack[-7] // } 1AC0 5B JUMPDEST 1AC1 01 ADD 1AC2 55 SSTORE 1AC3 50 POP 1AC4 50 POP 1AC5 50 POP 1AC6 56 *JUMP // Stack delta = -7 // Outputs[1] { @1AC2 storage[stack[-1] + stack[-2]] = stack[-3] } // Block ends with unconditional jump to stack[-7] label_1AC7: // Incoming jump from 0x0E18 // Inputs[3] // { // @1ACB stack[-2] // @1ACC stack[-1] // @1ACF memory[0x40:0x60] // } 1AC7 5B JUMPDEST 1AC8 61 PUSH2 0x0a2e 1ACB 82 DUP3 1ACC 82 DUP3 1ACD 60 PUSH1 0x40 1ACF 51 MLOAD 1AD0 80 DUP1 1AD1 60 PUSH1 0x20 1AD3 01 ADD 1AD4 60 PUSH1 0x40 1AD6 52 MSTORE 1AD7 80 DUP1 1AD8 60 PUSH1 0x00 1ADA 81 DUP2 1ADB 52 MSTORE 1ADC 50 POP 1ADD 61 PUSH2 0x2050 1AE0 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1AC8 stack[0] = 0x0a2e // @1ACB stack[1] = stack[-2] // @1ACC stack[2] = stack[-1] // @1ACF stack[3] = memory[0x40:0x60] // @1AD6 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1ADB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x2050 1AE1 5B JUMPDEST 1AE2 61 PUSH2 0x2710 1AE5 6B PUSH12 0xffffffffffffffffffffffff 1AF2 82 DUP3 1AF3 16 AND 1AF4 11 GT 1AF5 15 ISZERO 1AF6 61 PUSH2 0x1b54 1AF9 57 *JUMPI 1AFA 60 PUSH1 0x40 1AFC 51 MLOAD 1AFD 62 PUSH3 0x461bcd 1B01 60 PUSH1 0xe5 1B03 1B SHL 1B04 81 DUP2 1B05 52 MSTORE 1B06 60 PUSH1 0x20 1B08 60 PUSH1 0x04 1B0A 82 DUP3 1B0B 01 ADD 1B0C 52 MSTORE 1B0D 60 PUSH1 0x2a 1B0F 60 PUSH1 0x24 1B11 82 DUP3 1B12 01 ADD 1B13 52 MSTORE 1B14 7F PUSH32 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 1B35 60 PUSH1 0x44 1B37 82 DUP3 1B38 01 ADD 1B39 52 MSTORE 1B3A 69 PUSH10 0x2073616c655072696365 1B45 60 PUSH1 0xb0 1B47 1B SHL 1B48 60 PUSH1 0x64 1B4A 82 DUP3 1B4B 01 ADD 1B4C 52 MSTORE 1B4D 60 PUSH1 0x84 1B4F 01 ADD 1B50 61 PUSH2 0x0a1b 1B53 56 *JUMP 1B54 5B JUMPDEST 1B55 60 PUSH1 0x01 1B57 60 PUSH1 0x01 1B59 60 PUSH1 0xa0 1B5B 1B SHL 1B5C 03 SUB 1B5D 82 DUP3 1B5E 16 AND 1B5F 61 PUSH2 0x1baa 1B62 57 *JUMPI 1B63 60 PUSH1 0x40 1B65 51 MLOAD 1B66 62 PUSH3 0x461bcd 1B6A 60 PUSH1 0xe5 1B6C 1B SHL 1B6D 81 DUP2 1B6E 52 MSTORE 1B6F 60 PUSH1 0x20 1B71 60 PUSH1 0x04 1B73 82 DUP3 1B74 01 ADD 1B75 52 MSTORE 1B76 60 PUSH1 0x1b 1B78 60 PUSH1 0x24 1B7A 82 DUP3 1B7B 01 ADD 1B7C 52 MSTORE 1B7D 7F PUSH32 0x455243323938313a20496e76616c696420706172616d65746572730000000000 1B9E 60 PUSH1 0x44 1BA0 82 DUP3 1BA1 01 ADD 1BA2 52 MSTORE 1BA3 60 PUSH1 0x64 1BA5 01 ADD 1BA6 61 PUSH2 0x0a1b 1BA9 56 *JUMP 1BAA 5B JUMPDEST 1BAB 60 PUSH1 0x40 1BAD 80 DUP1 1BAE 51 MLOAD 1BAF 80 DUP1 1BB0 82 DUP3 1BB1 01 ADD 1BB2 82 DUP3 1BB3 52 MSTORE 1BB4 60 PUSH1 0x01 1BB6 60 PUSH1 0x01 1BB8 60 PUSH1 0xa0 1BBA 1B SHL 1BBB 03 SUB 1BBC 93 SWAP4 1BBD 84 DUP5 1BBE 16 AND 1BBF 81 DUP2 1BC0 52 MSTORE 1BC1 6B PUSH12 0xffffffffffffffffffffffff 1BCE 92 SWAP3 1BCF 83 DUP4 1BD0 16 AND 1BD1 60 PUSH1 0x20 1BD3 80 DUP1 1BD4 83 DUP4 1BD5 01 ADD 1BD6 91 SWAP2 1BD7 82 DUP3 1BD8 52 MSTORE 1BD9 60 PUSH1 0x00 1BDB 96 SWAP7 1BDC 87 DUP8 1BDD 52 MSTORE 1BDE 60 PUSH1 0x09 1BE0 90 SWAP1 1BE1 52 MSTORE 1BE2 91 SWAP2 1BE3 90 SWAP1 1BE4 94 SWAP5 1BE5 20 SHA3 1BE6 93 SWAP4 1BE7 51 MLOAD 1BE8 90 SWAP1 1BE9 51 MLOAD 1BEA 90 SWAP1 1BEB 91 SWAP2 1BEC 16 AND 1BED 60 PUSH1 0x01 1BEF 60 PUSH1 0xa0 1BF1 1B SHL 1BF2 02 MUL 1BF3 91 SWAP2 1BF4 16 AND 1BF5 17 OR 1BF6 90 SWAP1 1BF7 55 SSTORE 1BF8 56 *JUMP label_1BF9: // Incoming call from 0x1887, returns to 0x1888 // Incoming call from 0x1540, returns to 0x1541 // Incoming call from 0x0EA3, returns to 0x0EA4 // Inputs[3] // { // @1BFD memory[0x40:0x60] // @1C17 stack[-1] // @1C1A storage[0x00] // } 1BF9 5B JUMPDEST 1BFA 60 PUSH1 0x40 1BFC 80 DUP1 1BFD 51 MLOAD 1BFE 60 PUSH1 0x60 1C00 81 DUP2 1C01 01 ADD 1C02 82 DUP3 1C03 52 MSTORE 1C04 60 PUSH1 0x00 1C06 80 DUP1 1C07 82 DUP3 1C08 52 MSTORE 1C09 60 PUSH1 0x20 1C0B 82 DUP3 1C0C 01 ADD 1C0D 81 DUP2 1C0E 90 SWAP1 1C0F 52 MSTORE 1C10 91 SWAP2 1C11 81 DUP2 1C12 01 ADD 1C13 91 SWAP2 1C14 90 SWAP1 1C15 91 SWAP2 1C16 52 MSTORE 1C17 81 DUP2 1C18 60 PUSH1 0x00 1C1A 54 SLOAD 1C1B 81 DUP2 1C1C 10 LT 1C1D 15 ISZERO 1C1E 61 PUSH2 0x1cfc 1C21 57 *JUMPI // Stack delta = +2 // Outputs[6] // { // @1C03 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1C08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1C0F memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1C15 stack[0] = memory[0x40:0x60] // @1C16 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1C17 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1cfc, if !(stack[-1] < storage[0x00]) label_1C22: // Incoming jump from 0x1C21, if not !(stack[-1] < storage[0x00]) // Inputs[4] // { // @1C24 stack[-1] // @1C33 memory[0x00:0x40] // @1C35 memory[0x40:0x60] // @1C3D storage[keccak256(memory[0x00:0x40])] // } 1C22 60 PUSH1 0x00 1C24 81 DUP2 1C25 81 DUP2 1C26 52 MSTORE 1C27 60 PUSH1 0x04 1C29 60 PUSH1 0x20 1C2B 90 SWAP1 1C2C 81 DUP2 1C2D 52 MSTORE 1C2E 60 PUSH1 0x40 1C30 91 SWAP2 1C31 82 DUP3 1C32 90 SWAP1 1C33 20 SHA3 1C34 82 DUP3 1C35 51 MLOAD 1C36 60 PUSH1 0x60 1C38 81 DUP2 1C39 01 ADD 1C3A 84 DUP5 1C3B 52 MSTORE 1C3C 90 SWAP1 1C3D 54 SLOAD 1C3E 60 PUSH1 0x01 1C40 60 PUSH1 0x01 1C42 60 PUSH1 0xa0 1C44 1B SHL 1C45 03 SUB 1C46 81 DUP2 1C47 16 AND 1C48 82 DUP3 1C49 52 MSTORE 1C4A 60 PUSH1 0x01 1C4C 60 PUSH1 0xa0 1C4E 1B SHL 1C4F 81 DUP2 1C50 04 DIV 1C51 67 PUSH8 0xffffffffffffffff 1C5A 16 AND 1C5B 92 SWAP3 1C5C 82 DUP3 1C5D 01 ADD 1C5E 92 SWAP3 1C5F 90 SWAP1 1C60 92 SWAP3 1C61 52 MSTORE 1C62 60 PUSH1 0x01 1C64 60 PUSH1 0xe0 1C66 1B SHL 1C67 90 SWAP1 1C68 91 SWAP2 1C69 04 DIV 1C6A 60 PUSH1 0xff 1C6C 16 AND 1C6D 15 ISZERO 1C6E 15 ISZERO 1C6F 91 SWAP2 1C70 81 DUP2 1C71 01 ADD 1C72 82 DUP3 1C73 90 SWAP1 1C74 52 MSTORE 1C75 90 SWAP1 1C76 61 PUSH2 0x1cfa 1C79 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @1C26 memory[0x00:0x20] = stack[-1] // @1C2D memory[0x20:0x40] = 0x04 // @1C3B memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1C49 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1C61 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1C74 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // @1C75 stack[0] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1cfa, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) label_1C7A: // Incoming jump from 0x1C79, if not !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // Inputs[2] // { // @1C7A stack[-1] // @1C7B memory[stack[-1]:stack[-1] + 0x20] // } 1C7A 80 DUP1 1C7B 51 MLOAD 1C7C 60 PUSH1 0x01 1C7E 60 PUSH1 0x01 1C80 60 PUSH1 0xa0 1C82 1B SHL 1C83 03 SUB 1C84 16 AND 1C85 15 ISZERO 1C86 61 PUSH2 0x1c90 1C89 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c90, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) label_1C8A: // Incoming jump from 0x1C89, if not !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @1C8A stack[-1] // @1C8A stack[-5] // @1C8B stack[-4] // } 1C8A 93 SWAP4 1C8B 92 SWAP3 1C8C 50 POP 1C8D 50 POP 1C8E 50 POP 1C8F 56 *JUMP // Stack delta = -4 // Outputs[1] { @1C8A stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1C90: // Incoming jump from 0x1CF9 // Incoming jump from 0x1C89, if !((0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @1C95 stack[-2] // @1CA7 memory[0x00:0x40] // @1CA9 memory[0x40:0x60] // @1CB1 storage[keccak256(memory[0x00:0x40])] // } 1C90 5B JUMPDEST 1C91 50 POP 1C92 60 PUSH1 0x00 1C94 19 NOT 1C95 01 ADD 1C96 60 PUSH1 0x00 1C98 81 DUP2 1C99 81 DUP2 1C9A 52 MSTORE 1C9B 60 PUSH1 0x04 1C9D 60 PUSH1 0x20 1C9F 90 SWAP1 1CA0 81 DUP2 1CA1 52 MSTORE 1CA2 60 PUSH1 0x40 1CA4 91 SWAP2 1CA5 82 DUP3 1CA6 90 SWAP1 1CA7 20 SHA3 1CA8 82 DUP3 1CA9 51 MLOAD 1CAA 60 PUSH1 0x60 1CAC 81 DUP2 1CAD 01 ADD 1CAE 84 DUP5 1CAF 52 MSTORE 1CB0 90 SWAP1 1CB1 54 SLOAD 1CB2 60 PUSH1 0x01 1CB4 60 PUSH1 0x01 1CB6 60 PUSH1 0xa0 1CB8 1B SHL 1CB9 03 SUB 1CBA 81 DUP2 1CBB 16 AND 1CBC 80 DUP1 1CBD 83 DUP4 1CBE 52 MSTORE 1CBF 60 PUSH1 0x01 1CC1 60 PUSH1 0xa0 1CC3 1B SHL 1CC4 82 DUP3 1CC5 04 DIV 1CC6 67 PUSH8 0xffffffffffffffff 1CCF 16 AND 1CD0 93 SWAP4 1CD1 83 DUP4 1CD2 01 ADD 1CD3 93 SWAP4 1CD4 90 SWAP1 1CD5 93 SWAP4 1CD6 52 MSTORE 1CD7 60 PUSH1 0x01 1CD9 60 PUSH1 0xe0 1CDB 1B SHL 1CDC 90 SWAP1 1CDD 04 DIV 1CDE 60 PUSH1 0xff 1CE0 16 AND 1CE1 15 ISZERO 1CE2 15 ISZERO 1CE3 92 SWAP3 1CE4 81 DUP2 1CE5 01 ADD 1CE6 92 SWAP3 1CE7 90 SWAP1 1CE8 92 SWAP3 1CE9 52 MSTORE 1CEA 15 ISZERO 1CEB 61 PUSH2 0x1cf5 1CEE 57 *JUMPI // Stack delta = +0 // Outputs[8] // { // @1C95 stack[-2] = ~0x00 + stack[-2] // @1C9A memory[0x00:0x20] = ~0x00 + stack[-2] // @1CA1 memory[0x20:0x40] = 0x04 // @1CAF memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @1CBE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @1CD6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @1CE8 stack[-1] = memory[0x40:0x60] // @1CE9 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) // } // Block ends with conditional jump to 0x1cf5, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) label_1CEF: // Incoming jump from 0x1CEE, if not !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) // Inputs[3] // { // @1CEF stack[-1] // @1CEF stack[-5] // @1CF0 stack[-4] // } 1CEF 93 SWAP4 1CF0 92 SWAP3 1CF1 50 POP 1CF2 50 POP 1CF3 50 POP 1CF4 56 *JUMP // Stack delta = -4 // Outputs[1] { @1CEF stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1CF5: // Incoming jump from 0x1CEE, if !(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01) 1CF5 5B JUMPDEST 1CF6 61 PUSH2 0x1c90 1CF9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1c90 label_1CFA: // Incoming jump from 0x1C79, if !!(0xff & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xe0)) 1CFA 5B JUMPDEST 1CFB 50 POP // Stack delta = -1 // Block continues label_1CFC: // Incoming jump from 0x1C21, if !(stack[-1] < storage[0x00]) // Incoming jump from 0x1CFB // Inputs[3] // { // @1CFF memory[0x40:0x60] // @1D28 memory[0x40:0x60] // @1D2D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1CFC 5B JUMPDEST 1CFD 60 PUSH1 0x40 1CFF 51 MLOAD 1D00 7F PUSH32 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 1D21 81 DUP2 1D22 52 MSTORE 1D23 60 PUSH1 0x04 1D25 01 ADD 1D26 60 PUSH1 0x40 1D28 51 MLOAD 1D29 80 DUP1 1D2A 91 SWAP2 1D2B 03 SUB 1D2C 90 SWAP1 1D2D FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1D22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 // @1D2D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1D2E: // Incoming call from 0x0F76, returns to 0x0F77 // Incoming call from 0x1315, returns to 0x0A69 // Inputs[5] // { // @1D32 storage[0x0c] // @1D3B stack[-1] // @1D5D memory[0x40:0x60] // @1D89 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1D8C stack[-2] // } 1D2E 5B JUMPDEST 1D2F 60 PUSH1 0x0c 1D31 80 DUP1 1D32 54 SLOAD 1D33 60 PUSH1 0x01 1D35 60 PUSH1 0x01 1D37 60 PUSH1 0xa0 1D39 1B SHL 1D3A 03 SUB 1D3B 83 DUP4 1D3C 81 DUP2 1D3D 16 AND 1D3E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D53 19 NOT 1D54 83 DUP4 1D55 16 AND 1D56 81 DUP2 1D57 17 OR 1D58 90 SWAP1 1D59 93 SWAP4 1D5A 55 SSTORE 1D5B 60 PUSH1 0x40 1D5D 51 MLOAD 1D5E 91 SWAP2 1D5F 16 AND 1D60 91 SWAP2 1D61 90 SWAP1 1D62 82 DUP3 1D63 90 SWAP1 1D64 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1D85 90 SWAP1 1D86 60 PUSH1 0x00 1D88 90 SWAP1 1D89 A3 LOG3 1D8A 50 POP 1D8B 50 POP 1D8C 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1D5A storage[0x0c] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x0c] & ~0xffffffffffffffffffffffffffffffffffffffff) // @1D89 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0c] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_1D8D: // Incoming jump from 0x1156 // Incoming jump from 0x21CA // Inputs[6] // { // @1D90 memory[0x40:0x60] // @1DA6 stack[-3] // @1DB3 msg.sender // @1DB5 stack[-4] // @1DB7 stack[-2] // @1DB9 stack[-1] // } 1D8D 5B JUMPDEST 1D8E 60 PUSH1 0x40 1D90 51 MLOAD 1D91 63 PUSH4 0x0a85bd01 1D96 60 PUSH1 0xe1 1D98 1B SHL 1D99 81 DUP2 1D9A 52 MSTORE 1D9B 60 PUSH1 0x00 1D9D 90 SWAP1 1D9E 60 PUSH1 0x01 1DA0 60 PUSH1 0x01 1DA2 60 PUSH1 0xa0 1DA4 1B SHL 1DA5 03 SUB 1DA6 85 DUP6 1DA7 16 AND 1DA8 90 SWAP1 1DA9 63 PUSH4 0x150b7a02 1DAE 90 SWAP1 1DAF 61 PUSH2 0x1dc2 1DB2 90 SWAP1 1DB3 33 CALLER 1DB4 90 SWAP1 1DB5 89 DUP10 1DB6 90 SWAP1 1DB7 88 DUP9 1DB8 90 SWAP1 1DB9 88 DUP9 1DBA 90 SWAP1 1DBB 60 PUSH1 0x04 1DBD 01 ADD 1DBE 61 PUSH2 0x29bf 1DC1 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1D9A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0a85bd01 << 0xe1 // @1D9D stack[0] = 0x00 // @1DA8 stack[1] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1DAE stack[2] = 0x150b7a02 // @1DB2 stack[3] = 0x1dc2 // @1DB4 stack[4] = msg.sender // @1DB6 stack[5] = stack[-4] // @1DB8 stack[6] = stack[-2] // @1DBA stack[7] = stack[-1] // @1DBD stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x29bf, returns to 0x1DC2 label_1DC2: // Incoming return from call to 0x29BF at 0x1DC1 // Inputs[4] // { // @1DC7 memory[0x40:0x60] // @1DC9 stack[-1] // @1DCE stack[-3] // @1DD0 address(stack[-3]).code.length // } 1DC2 5B JUMPDEST 1DC3 60 PUSH1 0x20 1DC5 60 PUSH1 0x40 1DC7 51 MLOAD 1DC8 80 DUP1 1DC9 83 DUP4 1DCA 03 SUB 1DCB 81 DUP2 1DCC 60 PUSH1 0x00 1DCE 87 DUP8 1DCF 80 DUP1 1DD0 3B EXTCODESIZE 1DD1 15 ISZERO 1DD2 80 DUP1 1DD3 15 ISZERO 1DD4 61 PUSH2 0x1ddc 1DD7 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1DC3 stack[0] = 0x20 // @1DC7 stack[1] = memory[0x40:0x60] // @1DCA stack[2] = stack[-1] - memory[0x40:0x60] // @1DCB stack[3] = memory[0x40:0x60] // @1DCC stack[4] = 0x00 // @1DCE stack[5] = stack[-3] // @1DD1 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1ddc, if !!address(stack[-3]).code.length label_1DD8: // Incoming jump from 0x1DD7, if not !!address(stack[-3]).code.length // Inputs[1] { @1DDB memory[0x00:0x00] } 1DD8 60 PUSH1 0x00 1DDA 80 DUP1 1DDB FD *REVERT // Stack delta = +0 // Outputs[1] { @1DDB revert(memory[0x00:0x00]); } // Block terminates label_1DDC: // Incoming jump from 0x1DD7, if !!address(stack[-3]).code.length // Inputs[10] // { // @1DDE msg.gas // @1DDF memory[stack[-4]:stack[-4] + stack[-5]] // @1DDF stack[-3] // @1DDF stack[-6] // @1DDF stack[-5] // @1DDF stack[-4] // @1DDF stack[-2] // @1DDF stack[-7] // @1DDF address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1DE0 stack[-10] // } 1DDC 5B JUMPDEST 1DDD 50 POP 1DDE 5A GAS 1DDF F1 CALL 1DE0 92 SWAP3 1DE1 50 POP 1DE2 50 POP 1DE3 50 POP 1DE4 80 DUP1 1DE5 15 ISZERO 1DE6 61 PUSH2 0x1e0c 1DE9 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1DDF memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1DE0 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1e0c, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1DEA: // Incoming jump from 0x1DE9, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1DEE memory[0x40:0x60] // @1DF1 returndata.length // } 1DEA 50 POP 1DEB 60 PUSH1 0x40 1DED 80 DUP1 1DEE 51 MLOAD 1DEF 60 PUSH1 0x1f 1DF1 3D RETURNDATASIZE 1DF2 90 SWAP1 1DF3 81 DUP2 1DF4 01 ADD 1DF5 60 PUSH1 0x1f 1DF7 19 NOT 1DF8 16 AND 1DF9 82 DUP3 1DFA 01 ADD 1DFB 90 SWAP1 1DFC 92 SWAP3 1DFD 52 MSTORE 1DFE 61 PUSH2 0x1e09 1E01 91 SWAP2 1E02 81 DUP2 1E03 01 ADD 1E04 90 SWAP1 1E05 61 PUSH2 0x2806 1E08 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1DFD memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1E01 stack[-1] = 0x1e09 // @1E04 stack[1] = memory[0x40:0x60] // @1E04 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2806 1E09 5B JUMPDEST 1E0A 60 PUSH1 0x01 label_1E0C: // Incoming jump from 0x1DE9, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1E10 stack[-1] } 1E0C 5B JUMPDEST 1E0D 61 PUSH2 0x1e67 1E10 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1e67, if stack[-1] label_1E11: // Incoming jump from 0x1E10, if not stack[-1] // Inputs[1] { @1E11 returndata.length } 1E11 3D RETURNDATASIZE 1E12 80 DUP1 1E13 80 DUP1 1E14 15 ISZERO 1E15 61 PUSH2 0x1e3a 1E18 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E11 stack[0] = returndata.length // @1E12 stack[1] = returndata.length // } // Block ends with conditional jump to 0x1e3a, if !returndata.length label_1E19: // Incoming jump from 0x1E18, if not !returndata.length // Inputs[6] // { // @1E1B memory[0x40:0x60] // @1E1C stack[-2] // @1E23 returndata.length // @1E2B returndata.length // @1E2E returndata.length // @1E35 returndata[0x00:0x00 + returndata.length] // } 1E19 60 PUSH1 0x40 1E1B 51 MLOAD 1E1C 91 SWAP2 1E1D 50 POP 1E1E 60 PUSH1 0x1f 1E20 19 NOT 1E21 60 PUSH1 0x3f 1E23 3D RETURNDATASIZE 1E24 01 ADD 1E25 16 AND 1E26 82 DUP3 1E27 01 ADD 1E28 60 PUSH1 0x40 1E2A 52 MSTORE 1E2B 3D RETURNDATASIZE 1E2C 82 DUP3 1E2D 52 MSTORE 1E2E 3D RETURNDATASIZE 1E2F 60 PUSH1 0x00 1E31 60 PUSH1 0x20 1E33 84 DUP5 1E34 01 ADD 1E35 3E RETURNDATACOPY 1E36 61 PUSH2 0x1e3f 1E39 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1E1C stack[-2] = memory[0x40:0x60] // @1E2A memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1E2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1E35 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1e3f label_1E3A: // Incoming jump from 0x1E18, if !returndata.length // Inputs[2] // { // @1E3D stack[-2] // @1E42 memory[0x60:0x80] // } 1E3A 5B JUMPDEST 1E3B 60 PUSH1 0x60 1E3D 91 SWAP2 1E3E 50 POP 1E3F 5B JUMPDEST 1E40 50 POP 1E41 80 DUP1 1E42 51 MLOAD 1E43 61 PUSH2 0x1e5f 1E46 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1E3D stack[-2] = 0x60 } // Block ends with conditional jump to 0x1e5f, if memory[0x60:0x80] label_1E47: // Incoming jump from 0x1E46, if not memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1E46, if not memory[0x60:0x80] // Inputs[3] // { // @1E49 memory[0x40:0x60] // @1E59 memory[0x40:0x60] // @1E5E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1E47 60 PUSH1 0x40 1E49 51 MLOAD 1E4A 63 PUSH4 0x68d2bf6b 1E4F 60 PUSH1 0xe1 1E51 1B SHL 1E52 81 DUP2 1E53 52 MSTORE 1E54 60 PUSH1 0x04 1E56 01 ADD 1E57 60 PUSH1 0x40 1E59 51 MLOAD 1E5A 80 DUP1 1E5B 91 SWAP2 1E5C 03 SUB 1E5D 90 SWAP1 1E5E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1E53 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x68d2bf6b << 0xe1 // @1E5E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1E5F: // Incoming jump from 0x1E46, if memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1E46, if memory[0x60:0x80] // Inputs[3] // { // @1E60 stack[-1] // @1E61 memory[stack[-1]:stack[-1] + 0x20] // @1E66 memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1E5F 5B JUMPDEST 1E60 80 DUP1 1E61 51 MLOAD 1E62 81 DUP2 1E63 60 PUSH1 0x20 1E65 01 ADD 1E66 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E66 revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1E67: // Incoming jump from 0x1E10, if stack[-1] // Inputs[2] // { // @1E71 stack[-1] // @1E7B stack[-2] // } 1E67 5B JUMPDEST 1E68 60 PUSH1 0x01 1E6A 60 PUSH1 0x01 1E6C 60 PUSH1 0xe0 1E6E 1B SHL 1E6F 03 SUB 1E70 19 NOT 1E71 16 AND 1E72 63 PUSH4 0x0a85bd01 1E77 60 PUSH1 0xe1 1E79 1B SHL 1E7A 14 EQ 1E7B 90 SWAP1 1E7C 50 POP // Stack delta = -1 // Outputs[1] { @1E7B stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block continues label_1E7D: // Incoming return from call to 0x2550 at 0x286B // Incoming jump from 0x1E7C // Inputs[3] // { // @1E7E stack[-1] // @1E7E stack[-6] // @1E7F stack[-5] // } 1E7D 5B JUMPDEST 1E7E 94 SWAP5 1E7F 93 SWAP4 1E80 50 POP 1E81 50 POP 1E82 50 POP 1E83 50 POP 1E84 56 *JUMP // Stack delta = -5 // Outputs[1] { @1E7E stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1E85: // Incoming jump from 0x11BE // Inputs[1] { @1E8B storage[0x36] } 1E85 5B JUMPDEST 1E86 60 PUSH1 0x60 1E88 60 PUSH1 0x36 1E8A 80 DUP1 1E8B 54 SLOAD 1E8C 61 PUSH2 0x0694 1E8F 90 SWAP1 1E90 61 PUSH2 0x2ab3 1E93 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1E86 stack[0] = 0x60 // @1E88 stack[1] = 0x36 // @1E8F stack[2] = 0x0694 // @1E8F stack[3] = storage[0x36] // } // Block ends with call to 0x2ab3, returns to 0x0694 1E94 5B JUMPDEST 1E95 60 PUSH1 0x60 1E97 81 DUP2 1E98 61 PUSH2 0x1eb8 1E9B 57 *JUMPI 1E9C 50 POP 1E9D 50 POP 1E9E 60 PUSH1 0x40 1EA0 80 DUP1 1EA1 51 MLOAD 1EA2 80 DUP1 1EA3 82 DUP3 1EA4 01 ADD 1EA5 90 SWAP1 1EA6 91 SWAP2 1EA7 52 MSTORE 1EA8 60 PUSH1 0x01 1EAA 81 DUP2 1EAB 52 MSTORE 1EAC 60 PUSH1 0x03 1EAE 60 PUSH1 0xfc 1EB0 1B SHL 1EB1 60 PUSH1 0x20 1EB3 82 DUP3 1EB4 01 ADD 1EB5 52 MSTORE 1EB6 90 SWAP1 1EB7 56 *JUMP 1EB8 5B JUMPDEST 1EB9 81 DUP2 1EBA 60 PUSH1 0x00 1EBC 5B JUMPDEST 1EBD 81 DUP2 1EBE 15 ISZERO 1EBF 61 PUSH2 0x1ee2 1EC2 57 *JUMPI 1EC3 80 DUP1 1EC4 61 PUSH2 0x1ecc 1EC7 81 DUP2 1EC8 61 PUSH2 0x2aee 1ECB 56 *JUMP 1ECC 5B JUMPDEST 1ECD 91 SWAP2 1ECE 50 POP 1ECF 61 PUSH2 0x1edb 1ED2 90 SWAP1 1ED3 50 POP 1ED4 60 PUSH1 0x0a 1ED6 83 DUP4 1ED7 61 PUSH2 0x2a26 1EDA 56 *JUMP 1EDB 5B JUMPDEST 1EDC 91 SWAP2 1EDD 50 POP 1EDE 61 PUSH2 0x1ebc 1EE1 56 *JUMP 1EE2 5B JUMPDEST 1EE3 60 PUSH1 0x00 1EE5 81 DUP2 1EE6 67 PUSH8 0xffffffffffffffff 1EEF 81 DUP2 1EF0 11 GT 1EF1 15 ISZERO 1EF2 61 PUSH2 0x1efd 1EF5 57 *JUMPI 1EF6 61 PUSH2 0x1efd 1EF9 61 PUSH2 0x2b5f 1EFC 56 *JUMP 1EFD 5B JUMPDEST 1EFE 60 PUSH1 0x40 1F00 51 MLOAD 1F01 90 SWAP1 1F02 80 DUP1 1F03 82 DUP3 1F04 52 MSTORE 1F05 80 DUP1 1F06 60 PUSH1 0x1f 1F08 01 ADD 1F09 60 PUSH1 0x1f 1F0B 19 NOT 1F0C 16 AND 1F0D 60 PUSH1 0x20 1F0F 01 ADD 1F10 82 DUP3 1F11 01 ADD 1F12 60 PUSH1 0x40 1F14 52 MSTORE 1F15 80 DUP1 1F16 15 ISZERO 1F17 61 PUSH2 0x1f27 1F1A 57 *JUMPI 1F1B 60 PUSH1 0x20 1F1D 82 DUP3 1F1E 01 ADD 1F1F 81 DUP2 1F20 80 DUP1 1F21 36 CALLDATASIZE 1F22 83 DUP4 1F23 37 CALLDATACOPY 1F24 01 ADD 1F25 90 SWAP1 1F26 50 POP 1F27 5B JUMPDEST 1F28 50 POP 1F29 90 SWAP1 1F2A 50 POP 1F2B 5B JUMPDEST 1F2C 84 DUP5 1F2D 15 ISZERO 1F2E 61 PUSH2 0x1e7d 1F31 57 *JUMPI 1F32 61 PUSH2 0x1f3c 1F35 60 PUSH1 0x01 1F37 83 DUP4 1F38 61 PUSH2 0x2a59 1F3B 56 *JUMP 1F3C 5B JUMPDEST 1F3D 91 SWAP2 1F3E 50 POP 1F3F 61 PUSH2 0x1f49 1F42 60 PUSH1 0x0a 1F44 86 DUP7 1F45 61 PUSH2 0x2b09 1F48 56 *JUMP 1F49 5B JUMPDEST 1F4A 61 PUSH2 0x1f54 1F4D 90 SWAP1 1F4E 60 PUSH1 0x30 1F50 61 PUSH2 0x2a0e 1F53 56 *JUMP 1F54 5B JUMPDEST 1F55 60 PUSH1 0xf8 1F57 1B SHL 1F58 81 DUP2 1F59 83 DUP4 1F5A 81 DUP2 1F5B 51 MLOAD 1F5C 81 DUP2 1F5D 10 LT 1F5E 61 PUSH2 0x1f69 1F61 57 *JUMPI 1F62 61 PUSH2 0x1f69 1F65 61 PUSH2 0x2b49 1F68 56 *JUMP 1F69 5B JUMPDEST 1F6A 60 PUSH1 0x20 1F6C 01 ADD 1F6D 01 ADD 1F6E 90 SWAP1 1F6F 60 PUSH1 0x01 1F71 60 PUSH1 0x01 1F73 60 PUSH1 0xf8 1F75 1B SHL 1F76 03 SUB 1F77 19 NOT 1F78 16 AND 1F79 90 SWAP1 1F7A 81 DUP2 1F7B 60 PUSH1 0x00 1F7D 1A BYTE 1F7E 90 SWAP1 1F7F 53 MSTORE8 1F80 50 POP 1F81 61 PUSH2 0x1f8b 1F84 60 PUSH1 0x0a 1F86 86 DUP7 1F87 61 PUSH2 0x2a26 1F8A 56 *JUMP 1F8B 5B JUMPDEST 1F8C 94 SWAP5 1F8D 50 POP 1F8E 61 PUSH2 0x1f2b 1F91 56 *JUMP label_1F92: // Incoming call from 0x1390, returns to 0x0646 // Inputs[1] { @1F9E stack[-1] } 1F92 5B JUMPDEST 1F93 60 PUSH1 0x00 1F95 60 PUSH1 0x01 1F97 60 PUSH1 0x01 1F99 60 PUSH1 0xe0 1F9B 1B SHL 1F9C 03 SUB 1F9D 19 NOT 1F9E 82 DUP3 1F9F 16 AND 1FA0 7F PUSH32 0x2a55205a00000000000000000000000000000000000000000000000000000000 1FC1 14 EQ 1FC2 80 DUP1 1FC3 61 PUSH2 0x0646 1FC6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F93 stack[0] = 0x00 // @1FC1 stack[1] = 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0646, if 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1FC7: // Incoming jump from 0x1FC6, if not 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1FCB stack[-3] } 1FC7 50 POP 1FC8 61 PUSH2 0x0646 1FCB 82 DUP3 1FCC 61 PUSH2 0x2257 1FCF 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1FC8 stack[-1] = 0x0646 // @1FCB stack[0] = stack[-3] // } // Block ends with call to 0x2257, returns to 0x0646 label_1FD0: // Incoming call from 0x139A, returns to 0x0A69 // Inputs[5] // { // @1FD3 stack[-2] // @1FE1 memory[0x00:0x40] // @1FEA stack[-1] // @1FF2 memory[0x00:0x40] // @1FF3 storage[keccak256(memory[0x00:0x40])] // } 1FD0 5B JUMPDEST 1FD1 60 PUSH1 0x00 1FD3 82 DUP3 1FD4 81 DUP2 1FD5 52 MSTORE 1FD6 60 PUSH1 0x0b 1FD8 60 PUSH1 0x20 1FDA 90 SWAP1 1FDB 81 DUP2 1FDC 52 MSTORE 1FDD 60 PUSH1 0x40 1FDF 80 DUP1 1FE0 83 DUP4 1FE1 20 SHA3 1FE2 60 PUSH1 0x01 1FE4 60 PUSH1 0x01 1FE6 60 PUSH1 0xa0 1FE8 1B SHL 1FE9 03 SUB 1FEA 85 DUP6 1FEB 16 AND 1FEC 84 DUP5 1FED 52 MSTORE 1FEE 90 SWAP1 1FEF 91 SWAP2 1FF0 52 MSTORE 1FF1 90 SWAP1 1FF2 20 SHA3 1FF3 54 SLOAD 1FF4 60 PUSH1 0xff 1FF6 16 AND 1FF7 61 PUSH2 0x0a2e 1FFA 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1FD5 memory[0x00:0x20] = stack[-2] // @1FDC memory[0x20:0x40] = 0x0b // @1FED memory[0x00:0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1FF0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // } // Block ends with conditional jump to 0x0a2e, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1FFB: // Incoming jump from 0x1FFA, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1FFE stack[-1] } 1FFB 61 PUSH2 0x200e 1FFE 81 DUP2 1FFF 60 PUSH1 0x01 2001 60 PUSH1 0x01 2003 60 PUSH1 0xa0 2005 1B SHL 2006 03 SUB 2007 16 AND 2008 60 PUSH1 0x14 200A 61 PUSH2 0x22f2 200D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FFB stack[0] = 0x200e // @2007 stack[1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @2008 stack[2] = 0x14 // } // Block ends with call to 0x22f2, returns to 0x200E label_200E: // Incoming return from call to 0x22F2 at 0x200D // Inputs[1] { @2012 stack[-3] } 200E 5B JUMPDEST 200F 61 PUSH2 0x2019 2012 83 DUP4 2013 60 PUSH1 0x20 2015 61 PUSH2 0x22f2 2018 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @200F stack[0] = 0x2019 // @2012 stack[1] = stack[-3] // @2013 stack[2] = 0x20 // } // Block ends with call to 0x22f2, returns to 0x2019 label_2019: // Incoming return from call to 0x22F2 at 0x2018 // Inputs[3] // { // @201C memory[0x40:0x60] // @2023 stack[-2] // @2024 stack[-1] // } 2019 5B JUMPDEST 201A 60 PUSH1 0x40 201C 51 MLOAD 201D 60 PUSH1 0x20 201F 01 ADD 2020 61 PUSH2 0x202a 2023 92 SWAP3 2024 91 SWAP2 2025 90 SWAP1 2026 61 PUSH2 0x293e 2029 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2023 stack[-2] = 0x202a // @2024 stack[-1] = stack[-2] // @2025 stack[1] = 0x20 + memory[0x40:0x60] // @2025 stack[0] = stack[-1] // } // Block ends with call to 0x293e, returns to 0x202A label_202A: // Incoming return from call to 0x293E at 0x2029 // Inputs[2] // { // @202E memory[0x40:0x60] // @2033 stack[-1] // } 202A 5B JUMPDEST 202B 60 PUSH1 0x40 202D 80 DUP1 202E 51 MLOAD 202F 60 PUSH1 0x1f 2031 19 NOT 2032 81 DUP2 2033 84 DUP5 2034 03 SUB 2035 01 ADD 2036 81 DUP2 2037 52 MSTORE 2038 90 SWAP1 2039 82 DUP3 203A 90 SWAP1 203B 52 MSTORE 203C 62 PUSH3 0x461bcd 2040 60 PUSH1 0xe5 2042 1B SHL 2043 82 DUP3 2044 52 MSTORE 2045 61 PUSH2 0x0a1b 2048 91 SWAP2 2049 60 PUSH1 0x04 204B 01 ADD 204C 61 PUSH2 0x29fb 204F 56 *JUMP // Stack delta = +2 // Outputs[6] // { // @2037 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + ~0x1f // @2038 stack[0] = memory[0x40:0x60] // @203B memory[0x40:0x60] = stack[-1] // @2044 memory[stack[-1]:stack[-1] + 0x20] = 0x461bcd << 0xe5 // @2048 stack[-1] = 0x0a1b // @204B stack[1] = 0x04 + stack[-1] // } // Block ends with call to 0x29fb, returns to 0x0A1B label_2050: // Incoming jump from 0x1AE0 // Inputs[2] // { // @2053 storage[0x00] // @205C stack[-3] // } 2050 5B JUMPDEST 2051 60 PUSH1 0x00 2053 54 SLOAD 2054 60 PUSH1 0x01 2056 60 PUSH1 0x01 2058 60 PUSH1 0xa0 205A 1B SHL 205B 03 SUB 205C 84 DUP5 205D 16 AND 205E 61 PUSH2 0x2093 2061 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2053 stack[0] = storage[0x00] } // Block ends with conditional jump to 0x2093, if stack[-3] & (0x01 << 0xa0) - 0x01 label_2062: // Incoming jump from 0x2061, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2064 memory[0x40:0x60] // @208D memory[0x40:0x60] // @2092 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2062 60 PUSH1 0x40 2064 51 MLOAD 2065 7F PUSH32 0x2e07630000000000000000000000000000000000000000000000000000000000 2086 81 DUP2 2087 52 MSTORE 2088 60 PUSH1 0x04 208A 01 ADD 208B 60 PUSH1 0x40 208D 51 MLOAD 208E 80 DUP1 208F 91 SWAP2 2090 03 SUB 2091 90 SWAP1 2092 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @2087 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000 // @2092 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2093: // Incoming jump from 0x2061, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @2094 stack[-3] } 2093 5B JUMPDEST 2094 82 DUP3 2095 61 PUSH2 0x20ca 2098 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x20ca, if stack[-3] label_2099: // Incoming jump from 0x2098, if not stack[-3] // Inputs[3] // { // @209B memory[0x40:0x60] // @20C4 memory[0x40:0x60] // @20C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2099 60 PUSH1 0x40 209B 51 MLOAD 209C 7F PUSH32 0xb562e8dd00000000000000000000000000000000000000000000000000000000 20BD 81 DUP2 20BE 52 MSTORE 20BF 60 PUSH1 0x04 20C1 01 ADD 20C2 60 PUSH1 0x40 20C4 51 MLOAD 20C5 80 DUP1 20C6 91 SWAP2 20C7 03 SUB 20C8 90 SWAP1 20C9 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @20BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000 // @20C9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_20CA: // Incoming jump from 0x2098, if stack[-3] // Inputs[9] // { // @20D3 stack[-4] // @20E5 memory[0x00:0x40] // @20E7 storage[keccak256(memory[0x00:0x40])] // @2117 stack[-3] // @2148 stack[-1] // @2152 memory[0x00:0x40] // @2154 storage[keccak256(memory[0x00:0x40])] // @2166 block.timestamp // @217A address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 20CA 5B JUMPDEST 20CB 60 PUSH1 0x01 20CD 60 PUSH1 0x01 20CF 60 PUSH1 0xa0 20D1 1B SHL 20D2 03 SUB 20D3 84 DUP5 20D4 16 AND 20D5 60 PUSH1 0x00 20D7 81 DUP2 20D8 81 DUP2 20D9 52 MSTORE 20DA 60 PUSH1 0x05 20DC 60 PUSH1 0x20 20DE 90 SWAP1 20DF 81 DUP2 20E0 52 MSTORE 20E1 60 PUSH1 0x40 20E3 80 DUP1 20E4 83 DUP4 20E5 20 SHA3 20E6 80 DUP1 20E7 54 SLOAD 20E8 7F PUSH32 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000 2109 81 DUP2 210A 16 AND 210B 67 PUSH8 0xffffffffffffffff 2114 80 DUP1 2115 83 DUP4 2116 16 AND 2117 8B DUP12 2118 01 ADD 2119 81 DUP2 211A 16 AND 211B 91 SWAP2 211C 82 DUP3 211D 17 OR 211E 68 PUSH9 0x010000000000000000 2128 67 PUSH8 0xffffffffffffffff 2131 19 NOT 2132 90 SWAP1 2133 94 SWAP5 2134 16 AND 2135 90 SWAP1 2136 92 SWAP3 2137 17 OR 2138 83 DUP4 2139 90 SWAP1 213A 04 DIV 213B 81 DUP2 213C 16 AND 213D 8B DUP12 213E 01 ADD 213F 81 DUP2 2140 16 AND 2141 90 SWAP1 2142 92 SWAP3 2143 02 MUL 2144 17 OR 2145 90 SWAP1 2146 91 SWAP2 2147 55 SSTORE 2148 85 DUP6 2149 84 DUP5 214A 52 MSTORE 214B 60 PUSH1 0x04 214D 90 SWAP1 214E 92 SWAP3 214F 52 MSTORE 2150 90 SWAP1 2151 91 SWAP2 2152 20 SHA3 2153 80 DUP1 2154 54 SLOAD 2155 60 PUSH1 0x01 2157 60 PUSH1 0x01 2159 60 PUSH1 0xe0 215B 1B SHL 215C 03 SUB 215D 19 NOT 215E 16 AND 215F 83 DUP4 2160 17 OR 2161 60 PUSH1 0x01 2163 60 PUSH1 0xa0 2165 1B SHL 2166 42 TIMESTAMP 2167 90 SWAP1 2168 93 SWAP4 2169 16 AND 216A 92 SWAP3 216B 90 SWAP1 216C 92 SWAP3 216D 02 MUL 216E 91 SWAP2 216F 90 SWAP1 2170 91 SWAP2 2171 17 OR 2172 90 SWAP1 2173 55 SSTORE 2174 81 DUP2 2175 90 SWAP1 2176 81 DUP2 2177 85 DUP6 2178 01 ADD 2179 90 SWAP1 217A 3B EXTCODESIZE 217B 15 ISZERO 217C 61 PUSH2 0x2202 217F 57 *JUMPI // Stack delta = +2 // Outputs[8] // { // @20D9 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @20E0 memory[0x20:0x40] = 0x05 // @2147 storage[keccak256(memory[0x00:0x40])] = 0x010000000000000000 * (0xffffffffffffffff & stack[-3] + (0xffffffffffffffff & ((0xffffffffffffffff & stack[-3] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & ~0xffffffffffffffff)) / 0x010000000000000000)) | (0xffffffffffffffff & stack[-3] + (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffff)) | (storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffff00000000000000000000000000000000) // @214A memory[0x00:0x20] = stack[-1] // @214F memory[0x20:0x40] = 0x04 // @2173 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffff & block.timestamp) * (0x01 << 0xa0) | (stack[-4] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xe0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @2175 stack[0] = stack[-1] // @2179 stack[1] = stack[-3] + stack[-1] // } // Block ends with conditional jump to 0x2202, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_2180: // Incoming jump from 0x217F, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @2183 memory[0x40:0x60] // @2184 stack[-2] // @218E stack[-6] // @21B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @21C6 stack[-4] // } 2180 5B JUMPDEST 2181 60 PUSH1 0x40 2183 51 MLOAD 2184 82 DUP3 2185 90 SWAP1 2186 60 PUSH1 0x01 2188 60 PUSH1 0x01 218A 60 PUSH1 0xa0 218C 1B SHL 218D 03 SUB 218E 88 DUP9 218F 16 AND 2190 90 SWAP1 2191 60 PUSH1 0x00 2193 90 SWAP1 2194 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 21B5 90 SWAP1 21B6 82 DUP3 21B7 90 SWAP1 21B8 A4 LOG4 21B9 61 PUSH2 0x21cb 21BC 60 PUSH1 0x00 21BE 87 DUP8 21BF 84 DUP5 21C0 80 DUP1 21C1 60 PUSH1 0x01 21C3 01 ADD 21C4 95 SWAP6 21C5 50 POP 21C6 87 DUP8 21C7 61 PUSH2 0x1d8d 21CA 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @21B8 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-2]]); // @21B9 stack[0] = 0x21cb // @21BC stack[1] = 0x00 // @21BE stack[2] = stack[-6] // @21BF stack[3] = stack[-2] // @21C4 stack[-2] = 0x01 + stack[-2] // @21C6 stack[4] = stack[-4] // } // Block ends with unconditional jump to 0x1d8d 21CB 5B JUMPDEST 21CC 61 PUSH2 0x21e8 21CF 57 *JUMPI 21D0 60 PUSH1 0x40 21D2 51 MLOAD 21D3 63 PUSH4 0x68d2bf6b 21D8 60 PUSH1 0xe1 21DA 1B SHL 21DB 81 DUP2 21DC 52 MSTORE 21DD 60 PUSH1 0x04 21DF 01 ADD 21E0 60 PUSH1 0x40 21E2 51 MLOAD 21E3 80 DUP1 21E4 91 SWAP2 21E5 03 SUB 21E6 90 SWAP1 21E7 FD *REVERT 21E8 5B JUMPDEST 21E9 80 DUP1 21EA 82 DUP3 21EB 10 LT 21EC 61 PUSH2 0x2180 21EF 57 *JUMPI 21F0 82 DUP3 21F1 60 PUSH1 0x00 21F3 54 SLOAD 21F4 14 EQ 21F5 61 PUSH2 0x21fd 21F8 57 *JUMPI 21F9 60 PUSH1 0x00 21FB 80 DUP1 21FC FD *REVERT 21FD 5B JUMPDEST 21FE 61 PUSH2 0x2247 2201 56 *JUMP label_2202: // Incoming jump from 0x217F, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[5] // { // @2206 memory[0x40:0x60] // @2209 stack[-2] // @2215 stack[-6] // @223F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @2240 stack[-1] // } 2202 5B JUMPDEST 2203 5B JUMPDEST 2204 60 PUSH1 0x40 2206 51 MLOAD 2207 60 PUSH1 0x01 2209 83 DUP4 220A 01 ADD 220B 92 SWAP3 220C 90 SWAP1 220D 60 PUSH1 0x01 220F 60 PUSH1 0x01 2211 60 PUSH1 0xa0 2213 1B SHL 2214 03 SUB 2215 88 DUP9 2216 16 AND 2217 90 SWAP1 2218 60 PUSH1 0x00 221A 90 SWAP1 221B 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 223C 90 SWAP1 223D 82 DUP3 223E 90 SWAP1 223F A4 LOG4 2240 80 DUP1 2241 82 DUP3 2242 10 LT 2243 61 PUSH2 0x2203 2246 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @220B stack[-2] = stack[-2] + 0x01 // @223F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-2]]); // } // Block ends with conditional jump to 0x2203, if stack[-2] + 0x01 < stack[-1] label_2247: // Incoming jump from 0x2246, if not stack[-2] + 0x01 < stack[-1] // Incoming jump from 0x2246, if not stack[-2] + 0x01 < stack[-1] // Inputs[4] // { // @224B stack[-2] // @2252 stack[-6] // @2253 stack[-3] // @2254 stack[-5] // } 2247 5B JUMPDEST 2248 50 POP 2249 60 PUSH1 0x00 224B 90 SWAP1 224C 81 DUP2 224D 55 SSTORE 224E 61 PUSH2 0x0e93 2251 90 SWAP1 2252 85 DUP6 2253 83 DUP4 2254 86 DUP7 2255 84 DUP5 2256 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @224D storage[0x00] = stack[-2] // @2251 stack[-2] = 0x0e93 // @2251 stack[-1] = 0x00 // @2252 stack[0] = stack[-6] // @2253 stack[1] = stack[-3] // @2254 stack[2] = stack[-5] // } // Block ends with call to 0x0e93, returns to 0x0E93 label_2257: // Incoming call from 0x1FCF, returns to 0x0646 // Inputs[1] { @2263 stack[-1] } 2257 5B JUMPDEST 2258 60 PUSH1 0x00 225A 60 PUSH1 0x01 225C 60 PUSH1 0x01 225E 60 PUSH1 0xe0 2260 1B SHL 2261 03 SUB 2262 19 NOT 2263 82 DUP3 2264 16 AND 2265 7F PUSH32 0x80ac58cd00000000000000000000000000000000000000000000000000000000 2286 14 EQ 2287 80 DUP1 2288 61 PUSH2 0x22ba 228B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2258 stack[0] = 0x00 // @2286 stack[1] = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x22ba, if 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_228C: // Incoming jump from 0x228B, if not 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2296 stack[-3] } 228C 50 POP 228D 60 PUSH1 0x01 228F 60 PUSH1 0x01 2291 60 PUSH1 0xe0 2293 1B SHL 2294 03 SUB 2295 19 NOT 2296 82 DUP3 2297 16 AND 2298 7F PUSH32 0x5b5e139f00000000000000000000000000000000000000000000000000000000 22B9 14 EQ 22BA 5B JUMPDEST 22BB 80 DUP1 22BC 61 PUSH2 0x0646 22BF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22B9 stack[-1] = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0646, if 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_22C0: // Incoming jump from 0x22BF, if not stack[-1] // Incoming jump from 0x22BF, if not 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @22EB stack[-3] } 22C0 50 POP 22C1 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 22E2 60 PUSH1 0x01 22E4 60 PUSH1 0x01 22E6 60 PUSH1 0xe0 22E8 1B SHL 22E9 03 SUB 22EA 19 NOT 22EB 83 DUP4 22EC 16 AND 22ED 14 EQ 22EE 61 PUSH2 0x0646 22F1 56 *JUMP // Stack delta = +0 // Outputs[1] { @22ED stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to 0x0646 label_22F2: // Incoming call from 0x200D, returns to 0x200E // Incoming call from 0x2018, returns to 0x2019 // Inputs[1] { @22FA stack[-1] } 22F2 5B JUMPDEST 22F3 60 PUSH1 0x60 22F5 60 PUSH1 0x00 22F7 61 PUSH2 0x2301 22FA 83 DUP4 22FB 60 PUSH1 0x02 22FD 61 PUSH2 0x2a3a 2300 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @22F3 stack[0] = 0x60 // @22F5 stack[1] = 0x00 // @22F7 stack[2] = 0x2301 // @22FA stack[3] = stack[-1] // @22FB stack[4] = 0x02 // } // Block ends with call to 0x2a3a, returns to 0x2301 label_2301: // Incoming return from call to 0x2A3A at 0x2300 // Inputs[1] { @2305 stack[-1] } 2301 5B JUMPDEST 2302 61 PUSH2 0x230c 2305 90 SWAP1 2306 60 PUSH1 0x02 2308 61 PUSH2 0x2a0e 230B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2305 stack[0] = stack[-1] // @2305 stack[-1] = 0x230c // @2306 stack[1] = 0x02 // } // Block ends with call to 0x2a0e, returns to 0x230C label_230C: // Incoming return from call to 0x2A0E at 0x230B // Inputs[1] { @2316 stack[-1] } 230C 5B JUMPDEST 230D 67 PUSH8 0xffffffffffffffff 2316 81 DUP2 2317 11 GT 2318 15 ISZERO 2319 61 PUSH2 0x2324 231C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2324, if !(stack[-1] > 0xffffffffffffffff) label_231D: // Incoming jump from 0x231C, if not !(stack[-1] > 0xffffffffffffffff) 231D 61 PUSH2 0x2324 2320 61 PUSH2 0x2b5f 2323 56 *JUMP // Stack delta = +1 // Outputs[1] { @231D stack[0] = 0x2324 } // Block ends with unconditional jump to 0x2b5f label_2324: // Incoming jump from 0x231C, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @2327 memory[0x40:0x60] // @2328 stack[-1] // } 2324 5B JUMPDEST 2325 60 PUSH1 0x40 2327 51 MLOAD 2328 90 SWAP1 2329 80 DUP1 232A 82 DUP3 232B 52 MSTORE 232C 80 DUP1 232D 60 PUSH1 0x1f 232F 01 ADD 2330 60 PUSH1 0x1f 2332 19 NOT 2333 16 AND 2334 60 PUSH1 0x20 2336 01 ADD 2337 82 DUP3 2338 01 ADD 2339 60 PUSH1 0x40 233B 52 MSTORE 233C 80 DUP1 233D 15 ISZERO 233E 61 PUSH2 0x234e 2341 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2328 stack[-1] = memory[0x40:0x60] // @2328 stack[0] = stack[-1] // @232B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @233B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x234e, if !stack[-1] label_2342: // Incoming jump from 0x2341, if not !stack[-1] // Inputs[6] // { // @2344 stack[-2] // @2346 stack[-1] // @2348 msg.data.length // @234A msg.data[msg.data.length:msg.data.length + stack[-1]] // @2350 stack[-3] // @235B memory[stack[-2]:stack[-2] + 0x20] // } 2342 60 PUSH1 0x20 2344 82 DUP3 2345 01 ADD 2346 81 DUP2 2347 80 DUP1 2348 36 CALLDATASIZE 2349 83 DUP4 234A 37 CALLDATACOPY 234B 01 ADD 234C 90 SWAP1 234D 50 POP 234E 5B JUMPDEST 234F 50 POP 2350 90 SWAP1 2351 50 POP 2352 60 PUSH1 0x03 2354 60 PUSH1 0xfc 2356 1B SHL 2357 81 DUP2 2358 60 PUSH1 0x00 235A 81 DUP2 235B 51 MLOAD 235C 81 DUP2 235D 10 LT 235E 61 PUSH2 0x2369 2361 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @234A memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @2350 stack[-3] = stack[-2] // @2356 stack[-2] = 0x03 << 0xfc // @2357 stack[-1] = stack[-2] // @2358 stack[0] = 0x00 // } // Block ends with conditional jump to 0x2369, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] label_2362: // Incoming jump from 0x2361, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x2361, if not 0x00 < memory[stack[-2]:stack[-2] + 0x20] 2362 61 PUSH2 0x2369 2365 61 PUSH2 0x2b49 2368 56 *JUMP // Stack delta = +1 // Outputs[1] { @2362 stack[0] = 0x2369 } // Block ends with unconditional jump to 0x2b49 label_2369: // Incoming jump from 0x2361, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x2361, if 0x00 < memory[stack[-2]:stack[-2] + 0x20] // Inputs[5] // { // @236C stack[-1] // @236D stack[-2] // @236E stack[-3] // @23A2 stack[-4] // @23A6 memory[stack[-4]:stack[-4] + 0x20] // } 2369 5B JUMPDEST 236A 60 PUSH1 0x20 236C 01 ADD 236D 01 ADD 236E 90 SWAP1 236F 60 PUSH1 0x01 2371 60 PUSH1 0x01 2373 60 PUSH1 0xf8 2375 1B SHL 2376 03 SUB 2377 19 NOT 2378 16 AND 2379 90 SWAP1 237A 81 DUP2 237B 60 PUSH1 0x00 237D 1A BYTE 237E 90 SWAP1 237F 53 MSTORE8 2380 50 POP 2381 7F PUSH32 0x7800000000000000000000000000000000000000000000000000000000000000 23A2 81 DUP2 23A3 60 PUSH1 0x01 23A5 81 DUP2 23A6 51 MLOAD 23A7 81 DUP2 23A8 10 LT 23A9 61 PUSH2 0x23b4 23AC 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @237F memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @2381 stack[-3] = 0x7800000000000000000000000000000000000000000000000000000000000000 // @23A2 stack[-2] = stack[-4] // @23A3 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x23b4, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] label_23AD: // Incoming jump from 0x23AC, if not 0x01 < memory[stack[-4]:stack[-4] + 0x20] 23AD 61 PUSH2 0x23b4 23B0 61 PUSH2 0x2b49 23B3 56 *JUMP // Stack delta = +1 // Outputs[1] { @23AD stack[0] = 0x23b4 } // Block ends with unconditional jump to 0x2b49 label_23B4: // Incoming jump from 0x23AC, if 0x01 < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @23B7 stack[-1] // @23B8 stack[-2] // @23B9 stack[-3] // @23D1 stack[-6] // } 23B4 5B JUMPDEST 23B5 60 PUSH1 0x20 23B7 01 ADD 23B8 01 ADD 23B9 90 SWAP1 23BA 60 PUSH1 0x01 23BC 60 PUSH1 0x01 23BE 60 PUSH1 0xf8 23C0 1B SHL 23C1 03 SUB 23C2 19 NOT 23C3 16 AND 23C4 90 SWAP1 23C5 81 DUP2 23C6 60 PUSH1 0x00 23C8 1A BYTE 23C9 90 SWAP1 23CA 53 MSTORE8 23CB 50 POP 23CC 60 PUSH1 0x00 23CE 61 PUSH2 0x23d8 23D1 84 DUP5 23D2 60 PUSH1 0x02 23D4 61 PUSH2 0x2a3a 23D7 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @23CA memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @23CC stack[-3] = 0x00 // @23CE stack[-2] = 0x23d8 // @23D1 stack[-1] = stack[-6] // @23D2 stack[0] = 0x02 // } // Block ends with call to 0x2a3a, returns to 0x23D8 label_23D8: // Incoming return from call to 0x2A3A at 0x23D7 // Inputs[1] { @23DC stack[-1] } 23D8 5B JUMPDEST 23D9 61 PUSH2 0x23e3 23DC 90 SWAP1 23DD 60 PUSH1 0x01 23DF 61 PUSH2 0x2a0e 23E2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @23DC stack[0] = stack[-1] // @23DC stack[-1] = 0x23e3 // @23DD stack[1] = 0x01 // } // Block ends with call to 0x2a0e, returns to 0x23E3 label_23E3: // Incoming return from call to 0x2A0E at 0x23E2 // Inputs[2] // { // @23E4 stack[-1] // @23E4 stack[-2] // } 23E3 5B JUMPDEST 23E4 90 SWAP1 23E5 50 POP 23E6 5B JUMPDEST 23E7 60 PUSH1 0x01 23E9 81 DUP2 23EA 11 GT 23EB 15 ISZERO 23EC 61 PUSH2 0x2468 23EF 57 *JUMPI // Stack delta = -1 // Outputs[1] { @23E4 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x2468, if !(stack[-1] > 0x01) label_23F0: // Incoming jump from 0x23EF, if not !(stack[-1] > 0x01) // Incoming jump from 0x23EF, if not !(stack[-1] > 0x01) // Inputs[1] { @2411 stack[-5] } 23F0 7F PUSH32 0x3031323334353637383961626364656600000000000000000000000000000000 2411 85 DUP6 2412 60 PUSH1 0x0f 2414 16 AND 2415 60 PUSH1 0x10 2417 81 DUP2 2418 10 LT 2419 61 PUSH2 0x2424 241C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23F0 stack[0] = 0x3031323334353637383961626364656600000000000000000000000000000000 // @2414 stack[1] = 0x0f & stack[-5] // } // Block ends with conditional jump to 0x2424, if 0x0f & stack[-5] < 0x10 label_241D: // Incoming jump from 0x241C, if not 0x0f & stack[-5] < 0x10 241D 61 PUSH2 0x2424 2420 61 PUSH2 0x2b49 2423 56 *JUMP // Stack delta = +1 // Outputs[1] { @241D stack[0] = 0x2424 } // Block ends with unconditional jump to 0x2b49 label_2424: // Incoming jump from 0x241C, if 0x0f & stack[-5] < 0x10 // Inputs[5] // { // @2425 stack[-1] // @2425 stack[-2] // @2429 stack[-4] // @242A stack[-3] // @242C memory[stack[-4]:stack[-4] + 0x20] // } 2424 5B JUMPDEST 2425 1A BYTE 2426 60 PUSH1 0xf8 2428 1B SHL 2429 82 DUP3 242A 82 DUP3 242B 81 DUP2 242C 51 MLOAD 242D 81 DUP2 242E 10 LT 242F 61 PUSH2 0x243a 2432 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2428 stack[-2] = byte(stack[-2], stack[-1]) << 0xf8 // @2429 stack[-1] = stack[-4] // @242A stack[0] = stack[-3] // } // Block ends with conditional jump to 0x243a, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_2433: // Incoming jump from 0x2432, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 2433 61 PUSH2 0x243a 2436 61 PUSH2 0x2b49 2439 56 *JUMP // Stack delta = +1 // Outputs[1] { @2433 stack[0] = 0x243a } // Block ends with unconditional jump to 0x2b49 label_243A: // Incoming jump from 0x2432, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[5] // { // @243D stack[-1] // @243E stack[-2] // @243F stack[-3] // @2454 stack[-8] // @2455 stack[-4] // } 243A 5B JUMPDEST 243B 60 PUSH1 0x20 243D 01 ADD 243E 01 ADD 243F 90 SWAP1 2440 60 PUSH1 0x01 2442 60 PUSH1 0x01 2444 60 PUSH1 0xf8 2446 1B SHL 2447 03 SUB 2448 19 NOT 2449 16 AND 244A 90 SWAP1 244B 81 DUP2 244C 60 PUSH1 0x00 244E 1A BYTE 244F 90 SWAP1 2450 53 MSTORE8 2451 50 POP 2452 60 PUSH1 0x04 2454 94 SWAP5 2455 90 SWAP1 2456 94 SWAP5 2457 1C SHR 2458 93 SWAP4 2459 61 PUSH2 0x2461 245C 81 DUP2 245D 61 PUSH2 0x2a9c 2460 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2450 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @2458 stack[-4] = stack[-4] // @2458 stack[-8] = stack[-8] >> 0x04 // @2459 stack[-3] = 0x2461 // @245C stack[-2] = stack[-4] // } // Block ends with call to 0x2a9c, returns to 0x2461 label_2461: // Incoming return from call to 0x2A9C at 0x2460 // Inputs[2] // { // @2462 stack[-2] // @2462 stack[-1] // } 2461 5B JUMPDEST 2462 90 SWAP1 2463 50 POP 2464 61 PUSH2 0x23e6 2467 56 *JUMP // Stack delta = -1 // Outputs[1] { @2462 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x23e6 label_2468: // Incoming jump from 0x23EF, if !(stack[-1] > 0x01) // Incoming jump from 0x23EF, if !(stack[-1] > 0x01) // Inputs[1] { @246A stack[-5] } 2468 5B JUMPDEST 2469 50 POP 246A 83 DUP4 246B 15 ISZERO 246C 61 PUSH2 0x120b 246F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x120b, if !stack[-5] label_2470: // Incoming jump from 0x246F, if not !stack[-5] // Inputs[1] { @2472 memory[0x40:0x60] } 2470 60 PUSH1 0x40 2472 51 MLOAD 2473 62 PUSH3 0x461bcd 2477 60 PUSH1 0xe5 2479 1B SHL 247A 81 DUP2 247B 52 MSTORE 247C 60 PUSH1 0x20 247E 60 PUSH1 0x04 2480 82 DUP3 2481 01 ADD 2482 81 DUP2 2483 90 SWAP1 2484 52 MSTORE 2485 60 PUSH1 0x24 2487 82 DUP3 2488 01 ADD 2489 52 MSTORE 248A 7F PUSH32 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 24AB 60 PUSH1 0x44 24AD 82 DUP3 24AE 01 ADD 24AF 52 MSTORE 24B0 60 PUSH1 0x64 24B2 01 ADD 24B3 61 PUSH2 0x0a1b 24B6 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @247B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @2484 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2489 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @24AF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x537472696e67733a20686578206c656e67746820696e73756666696369656e74 // @24B2 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0a1b 24B7 5B JUMPDEST 24B8 82 DUP3 24B9 80 DUP1 24BA 54 SLOAD 24BB 61 PUSH2 0x24c3 24BE 90 SWAP1 24BF 61 PUSH2 0x2ab3 24C2 56 *JUMP 24C3 5B JUMPDEST 24C4 90 SWAP1 24C5 60 PUSH1 0x00 24C7 52 MSTORE 24C8 60 PUSH1 0x20 24CA 60 PUSH1 0x00 24CC 20 SHA3 24CD 90 SWAP1 24CE 60 PUSH1 0x1f 24D0 01 ADD 24D1 60 PUSH1 0x20 24D3 90 SWAP1 24D4 04 DIV 24D5 81 DUP2 24D6 01 ADD 24D7 92 SWAP3 24D8 82 DUP3 24D9 61 PUSH2 0x24e5 24DC 57 *JUMPI 24DD 60 PUSH1 0x00 24DF 85 DUP6 24E0 55 SSTORE 24E1 61 PUSH2 0x252b 24E4 56 *JUMP 24E5 5B JUMPDEST 24E6 82 DUP3 24E7 60 PUSH1 0x1f 24E9 10 LT 24EA 61 PUSH2 0x24fe 24ED 57 *JUMPI 24EE 80 DUP1 24EF 51 MLOAD 24F0 60 PUSH1 0xff 24F2 19 NOT 24F3 16 AND 24F4 83 DUP4 24F5 80 DUP1 24F6 01 ADD 24F7 17 OR 24F8 85 DUP6 24F9 55 SSTORE 24FA 61 PUSH2 0x252b 24FD 56 *JUMP 24FE 5B JUMPDEST 24FF 82 DUP3 2500 80 DUP1 2501 01 ADD 2502 60 PUSH1 0x01 2504 01 ADD 2505 85 DUP6 2506 55 SSTORE 2507 82 DUP3 2508 15 ISZERO 2509 61 PUSH2 0x252b 250C 57 *JUMPI 250D 91 SWAP2 250E 82 DUP3 250F 01 ADD 2510 5B JUMPDEST 2511 82 DUP3 2512 81 DUP2 2513 11 GT 2514 15 ISZERO 2515 61 PUSH2 0x252b 2518 57 *JUMPI 2519 82 DUP3 251A 51 MLOAD 251B 82 DUP3 251C 55 SSTORE 251D 91 SWAP2 251E 60 PUSH1 0x20 2520 01 ADD 2521 91 SWAP2 2522 90 SWAP1 2523 60 PUSH1 0x01 2525 01 ADD 2526 90 SWAP1 2527 61 PUSH2 0x2510 252A 56 *JUMP 252B 5B JUMPDEST 252C 50 POP 252D 61 PUSH2 0x2537 2530 92 SWAP3 2531 91 SWAP2 2532 50 POP 2533 61 PUSH2 0x253b 2536 56 *JUMP 2537 5B JUMPDEST 2538 50 POP 2539 90 SWAP1 253A 56 *JUMP 253B 5B JUMPDEST 253C 5B JUMPDEST 253D 80 DUP1 253E 82 DUP3 253F 11 GT 2540 15 ISZERO 2541 61 PUSH2 0x2537 2544 57 *JUMPI 2545 60 PUSH1 0x00 2547 81 DUP2 2548 55 SSTORE 2549 60 PUSH1 0x01 254B 01 ADD 254C 61 PUSH2 0x253c 254F 56 *JUMP label_2550: // Incoming call from 0x286B, returns to 0x1E7D // Incoming call from 0x2707, returns to 0x2708 // Inputs[1] { @255D stack[-2] } 2550 5B JUMPDEST 2551 60 PUSH1 0x00 2553 67 PUSH8 0xffffffffffffffff 255C 80 DUP1 255D 84 DUP5 255E 11 GT 255F 15 ISZERO 2560 61 PUSH2 0x256b 2563 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2551 stack[0] = 0x00 // @2553 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x256b, if !(stack[-2] > 0xffffffffffffffff) label_2564: // Incoming jump from 0x2563, if not !(stack[-2] > 0xffffffffffffffff) 2564 61 PUSH2 0x256b 2567 61 PUSH2 0x2b5f 256A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2564 stack[0] = 0x256b } // Block ends with unconditional jump to 0x2b5f label_256B: // Incoming jump from 0x2563, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @256E memory[0x40:0x60] // @2571 stack[-4] // @2580 stack[-1] // } 256B 5B JUMPDEST 256C 60 PUSH1 0x40 256E 51 MLOAD 256F 60 PUSH1 0x1f 2571 85 DUP6 2572 01 ADD 2573 60 PUSH1 0x1f 2575 19 NOT 2576 90 SWAP1 2577 81 DUP2 2578 16 AND 2579 60 PUSH1 0x3f 257B 01 ADD 257C 16 AND 257D 81 DUP2 257E 01 ADD 257F 90 SWAP1 2580 82 DUP3 2581 82 DUP3 2582 11 GT 2583 81 DUP2 2584 83 DUP4 2585 10 LT 2586 17 OR 2587 15 ISZERO 2588 61 PUSH2 0x2593 258B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @257F stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @257F stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x2593, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_258C: // Incoming jump from 0x258B, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 258C 61 PUSH2 0x2593 258F 61 PUSH2 0x2b5f 2592 56 *JUMP // Stack delta = +1 // Outputs[1] { @258C stack[0] = 0x2593 } // Block ends with unconditional jump to 0x2b5f label_2593: // Incoming jump from 0x258B, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @2594 stack[-2] // @2598 stack[-1] // @2599 stack[-4] // @259B stack[-6] // @259E stack[-7] // @25A0 stack[-5] // } 2593 5B JUMPDEST 2594 81 DUP2 2595 60 PUSH1 0x40 2597 52 MSTORE 2598 80 DUP1 2599 93 SWAP4 259A 50 POP 259B 85 DUP6 259C 81 DUP2 259D 52 MSTORE 259E 86 DUP7 259F 86 DUP7 25A0 86 DUP7 25A1 01 ADD 25A2 11 GT 25A3 15 ISZERO 25A4 61 PUSH2 0x25ac 25A7 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2597 memory[0x40:0x60] = stack[-2] // @2599 stack[-4] = stack[-1] // @259D memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x25ac, if !(stack[-5] + stack[-6] > stack[-7]) label_25A8: // Incoming jump from 0x25A7, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @25AB memory[0x00:0x00] } 25A8 60 PUSH1 0x00 25AA 80 DUP1 25AB FD *REVERT // Stack delta = +0 // Outputs[1] { @25AB revert(memory[0x00:0x00]); } // Block terminates label_25AC: // Incoming jump from 0x25A7, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @25AD stack[-6] // @25AE stack[-5] // @25B1 stack[-1] // @25B3 msg.data[stack[-5]:stack[-5] + stack[-6]] // @25C0 stack[-4] // @25C0 stack[-8] // @25C1 stack[-7] // } 25AC 5B JUMPDEST 25AD 85 DUP6 25AE 85 DUP6 25AF 60 PUSH1 0x20 25B1 83 DUP4 25B2 01 ADD 25B3 37 CALLDATACOPY 25B4 60 PUSH1 0x00 25B6 60 PUSH1 0x20 25B8 87 DUP8 25B9 83 DUP4 25BA 01 ADD 25BB 01 ADD 25BC 52 MSTORE 25BD 50 POP 25BE 50 POP 25BF 50 POP 25C0 93 SWAP4 25C1 92 SWAP3 25C2 50 POP 25C3 50 POP 25C4 50 POP 25C5 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @25B3 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @25BC memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @25C0 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_25C6: // Incoming call from 0x2628, returns to 0x120B // Incoming call from 0x2652, returns to 0x2653 // Incoming call from 0x28A9, returns to 0x28AA // Incoming call from 0x26B6, returns to 0x26B7 // Incoming call from 0x27E8, returns to 0x2653 // Incoming call from 0x2687, returns to 0x2688 // Incoming call from 0x2783, returns to 0x2784 // Incoming call from 0x26C4, returns to 0x26C5 // Incoming call from 0x2644, returns to 0x2645 // Incoming call from 0x272F, returns to 0x2730 // Incoming call from 0x2759, returns to 0x275A // Incoming call from 0x2679, returns to 0x267A // Inputs[2] // { // @25C7 stack[-1] // @25C8 msg.data[stack[-1]:stack[-1] + 0x20] // } 25C6 5B JUMPDEST 25C7 80 DUP1 25C8 35 CALLDATALOAD 25C9 60 PUSH1 0x01 25CB 60 PUSH1 0x01 25CD 60 PUSH1 0xa0 25CF 1B SHL 25D0 03 SUB 25D1 81 DUP2 25D2 16 AND 25D3 81 DUP2 25D4 14 EQ 25D5 61 PUSH2 0x25dd 25D8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25C8 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x25dd, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_25D9: // Incoming jump from 0x25D8, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @25DC memory[0x00:0x00] } 25D9 60 PUSH1 0x00 25DB 80 DUP1 25DC FD *REVERT // Stack delta = +0 // Outputs[1] { @25DC revert(memory[0x00:0x00]); } // Block terminates label_25DD: // Incoming jump from 0x25D8, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x25ED, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Incoming jump from 0x2609, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffff // Inputs[3] // { // @25DE stack[-1] // @25DE stack[-3] // @25DF stack[-2] // } 25DD 5B JUMPDEST 25DE 91 SWAP2 25DF 90 SWAP1 25E0 50 POP 25E1 56 *JUMP // Stack delta = -2 // Outputs[1] { @25DE stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_25E2: // Incoming call from 0x273D, returns to 0x2653 // Incoming call from 0x27AC, returns to 0x120B // Inputs[2] // { // @25E3 stack[-1] // @25E4 msg.data[stack[-1]:stack[-1] + 0x20] // } 25E2 5B JUMPDEST 25E3 80 DUP1 25E4 35 CALLDATALOAD 25E5 80 DUP1 25E6 15 ISZERO 25E7 15 ISZERO 25E8 81 DUP2 25E9 14 EQ 25EA 61 PUSH2 0x25dd 25ED 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25E4 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x25dd, if msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] label_25EE: // Incoming jump from 0x25ED, if not msg.data[stack[-1]:stack[-1] + 0x20] == !!msg.data[stack[-1]:stack[-1] + 0x20] // Inputs[1] { @25F1 memory[0x00:0x00] } 25EE 60 PUSH1 0x00 25F0 80 DUP1 25F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @25F1 revert(memory[0x00:0x00]); } // Block terminates label_25F2: // Incoming call from 0x2791, returns to 0x2653 // Incoming call from 0x28B7, returns to 0x28B8 // Inputs[2] // { // @25F3 stack[-1] // @25F4 msg.data[stack[-1]:stack[-1] + 0x20] // } 25F2 5B JUMPDEST 25F3 80 DUP1 25F4 35 CALLDATALOAD 25F5 6B PUSH12 0xffffffffffffffffffffffff 2602 81 DUP2 2603 16 AND 2604 81 DUP2 2605 14 EQ 2606 61 PUSH2 0x25dd 2609 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25F4 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x25dd, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffff label_260A: // Incoming jump from 0x2609, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffff // Inputs[1] { @260D memory[0x00:0x00] } 260A 60 PUSH1 0x00 260C 80 DUP1 260D FD *REVERT // Stack delta = +0 // Outputs[1] { @260D revert(memory[0x00:0x00]); } // Block terminates label_260E: // Incoming call from 0x0489, returns to 0x048A // Incoming call from 0x0622, returns to 0x0623 // Inputs[2] // { // @2613 stack[-1] // @2614 stack[-2] // } 260E 5B JUMPDEST 260F 60 PUSH1 0x00 2611 60 PUSH1 0x20 2613 82 DUP3 2614 84 DUP5 2615 03 SUB 2616 12 SLT 2617 15 ISZERO 2618 61 PUSH2 0x2620 261B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @260F stack[0] = 0x00 } // Block ends with conditional jump to 0x2620, if !(stack[-2] - stack[-1] i< 0x20) label_261C: // Incoming jump from 0x261B, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @261F memory[0x00:0x00] } 261C 60 PUSH1 0x00 261E 80 DUP1 261F FD *REVERT // Stack delta = +0 // Outputs[1] { @261F revert(memory[0x00:0x00]); } // Block terminates label_2620: // Incoming jump from 0x261B, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2624 stack[-2] } 2620 5B JUMPDEST 2621 61 PUSH2 0x120b 2624 82 DUP3 2625 61 PUSH2 0x25c6 2628 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2621 stack[0] = 0x120b // @2624 stack[1] = stack[-2] // } // Block ends with call to 0x25c6, returns to 0x120B label_2629: // Incoming jump from 0x05E6 // Inputs[2] // { // @262F stack[-1] // @2630 stack[-2] // } 2629 5B JUMPDEST 262A 60 PUSH1 0x00 262C 80 DUP1 262D 60 PUSH1 0x40 262F 83 DUP4 2630 85 DUP6 2631 03 SUB 2632 12 SLT 2633 15 ISZERO 2634 61 PUSH2 0x263c 2637 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @262A stack[0] = 0x00 // @262C stack[1] = 0x00 // } // Block ends with conditional jump to 0x263c, if !(stack[-2] - stack[-1] i< 0x40) label_2638: // Incoming jump from 0x2637, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @263B memory[0x00:0x00] } 2638 60 PUSH1 0x00 263A 80 DUP1 263B FD *REVERT // Stack delta = +0 // Outputs[1] { @263B revert(memory[0x00:0x00]); } // Block terminates label_263C: // Incoming jump from 0x2637, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2640 stack[-3] } 263C 5B JUMPDEST 263D 61 PUSH2 0x2645 2640 83 DUP4 2641 61 PUSH2 0x25c6 2644 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @263D stack[0] = 0x2645 // @2640 stack[1] = stack[-3] // } // Block ends with call to 0x25c6, returns to 0x2645 label_2645: // Incoming return from call to 0x25C6 at 0x2644 // Inputs[3] // { // @2646 stack[-1] // @2646 stack[-3] // @264D stack[-4] // } 2645 5B JUMPDEST 2646 91 SWAP2 2647 50 POP 2648 61 PUSH2 0x2653 264B 60 PUSH1 0x20 264D 84 DUP5 264E 01 ADD 264F 61 PUSH2 0x25c6 2652 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2646 stack[-3] = stack[-1] // @2648 stack[-1] = 0x2653 // @264E stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x25c6, returns to 0x2653 label_2653: // Incoming return from call to 0x25E2 at 0x273D // Incoming return from call to 0x25C6 at 0x27E8 // Incoming return from call to 0x25C6 at 0x2652 // Incoming return from call to 0x25F2 at 0x2791 // Inputs[6] // { // @2654 stack[-2] // @2654 stack[-1] // @2656 stack[-5] // @2658 stack[-3] // @2658 stack[-6] // @2659 stack[-4] // } 2653 5B JUMPDEST 2654 90 SWAP1 2655 50 POP 2656 92 SWAP3 2657 50 POP 2658 92 SWAP3 2659 90 SWAP1 265A 50 POP 265B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2656 stack[-5] = stack[-1] // @2658 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_265C: // Incoming call from 0x036D, returns to 0x036E // Incoming call from 0x0422, returns to 0x0423 // Inputs[2] // { // @2664 stack[-1] // @2665 stack[-2] // } 265C 5B JUMPDEST 265D 60 PUSH1 0x00 265F 80 DUP1 2660 60 PUSH1 0x00 2662 60 PUSH1 0x60 2664 84 DUP5 2665 86 DUP7 2666 03 SUB 2667 12 SLT 2668 15 ISZERO 2669 61 PUSH2 0x2671 266C 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @265D stack[0] = 0x00 // @265F stack[1] = 0x00 // @2660 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2671, if !(stack[-2] - stack[-1] i< 0x60) label_266D: // Incoming jump from 0x266C, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2670 memory[0x00:0x00] } 266D 60 PUSH1 0x00 266F 80 DUP1 2670 FD *REVERT // Stack delta = +0 // Outputs[1] { @2670 revert(memory[0x00:0x00]); } // Block terminates label_2671: // Incoming jump from 0x266C, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2675 stack[-4] } 2671 5B JUMPDEST 2672 61 PUSH2 0x267a 2675 84 DUP5 2676 61 PUSH2 0x25c6 2679 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2672 stack[0] = 0x267a // @2675 stack[1] = stack[-4] // } // Block ends with call to 0x25c6, returns to 0x267A label_267A: // Incoming return from call to 0x25C6 at 0x2679 // Inputs[3] // { // @267B stack[-4] // @267B stack[-1] // @2682 stack[-5] // } 267A 5B JUMPDEST 267B 92 SWAP3 267C 50 POP 267D 61 PUSH2 0x2688 2680 60 PUSH1 0x20 2682 85 DUP6 2683 01 ADD 2684 61 PUSH2 0x25c6 2687 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @267B stack[-4] = stack[-1] // @267D stack[-1] = 0x2688 // @2683 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x25c6, returns to 0x2688 label_2688: // Incoming return from call to 0x25C6 at 0x2687 // Inputs[8] // { // @2689 stack[-3] // @2689 stack[-1] // @268D stack[-5] // @268F msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2690 stack[-2] // @2694 stack[-6] // @2696 stack[-7] // @2696 stack[-4] // } 2688 5B JUMPDEST 2689 91 SWAP2 268A 50 POP 268B 60 PUSH1 0x40 268D 84 DUP5 268E 01 ADD 268F 35 CALLDATALOAD 2690 90 SWAP1 2691 50 POP 2692 92 SWAP3 2693 50 POP 2694 92 SWAP3 2695 50 POP 2696 92 SWAP3 2697 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2692 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2694 stack[-6] = stack[-1] // @2696 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_2698: // Incoming call from 0x05A0, returns to 0x05A1 // Inputs[2] // { // @26A1 stack[-1] // @26A2 stack[-2] // } 2698 5B JUMPDEST 2699 60 PUSH1 0x00 269B 80 DUP1 269C 60 PUSH1 0x00 269E 80 DUP1 269F 60 PUSH1 0x80 26A1 85 DUP6 26A2 87 DUP8 26A3 03 SUB 26A4 12 SLT 26A5 15 ISZERO 26A6 61 PUSH2 0x26ae 26A9 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2699 stack[0] = 0x00 // @269B stack[1] = 0x00 // @269C stack[2] = 0x00 // @269E stack[3] = 0x00 // } // Block ends with conditional jump to 0x26ae, if !(stack[-2] - stack[-1] i< 0x80) label_26AA: // Incoming jump from 0x26A9, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @26AD memory[0x00:0x00] } 26AA 60 PUSH1 0x00 26AC 80 DUP1 26AD FD *REVERT // Stack delta = +0 // Outputs[1] { @26AD revert(memory[0x00:0x00]); } // Block terminates label_26AE: // Incoming jump from 0x26A9, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @26B2 stack[-5] } 26AE 5B JUMPDEST 26AF 61 PUSH2 0x26b7 26B2 85 DUP6 26B3 61 PUSH2 0x25c6 26B6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @26AF stack[0] = 0x26b7 // @26B2 stack[1] = stack[-5] // } // Block ends with call to 0x25c6, returns to 0x26B7 label_26B7: // Incoming return from call to 0x25C6 at 0x26B6 // Inputs[3] // { // @26B8 stack[-1] // @26B8 stack[-5] // @26BF stack[-6] // } 26B7 5B JUMPDEST 26B8 93 SWAP4 26B9 50 POP 26BA 61 PUSH2 0x26c5 26BD 60 PUSH1 0x20 26BF 86 DUP7 26C0 01 ADD 26C1 61 PUSH2 0x25c6 26C4 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @26B8 stack[-5] = stack[-1] // @26BA stack[-1] = 0x26c5 // @26C0 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x25c6, returns to 0x26C5 label_26C5: // Incoming return from call to 0x25C6 at 0x26C4 // Inputs[6] // { // @26C6 stack[-1] // @26C6 stack[-4] // @26CA stack[-6] // @26CC msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @26CD stack[-3] // @26D3 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 26C5 5B JUMPDEST 26C6 92 SWAP3 26C7 50 POP 26C8 60 PUSH1 0x40 26CA 85 DUP6 26CB 01 ADD 26CC 35 CALLDATALOAD 26CD 91 SWAP2 26CE 50 POP 26CF 60 PUSH1 0x60 26D1 85 DUP6 26D2 01 ADD 26D3 35 CALLDATALOAD 26D4 67 PUSH8 0xffffffffffffffff 26DD 81 DUP2 26DE 11 GT 26DF 15 ISZERO 26E0 61 PUSH2 0x26e8 26E3 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @26C6 stack[-4] = stack[-1] // @26CD stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @26D3 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x26e8, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_26E4: // Incoming jump from 0x26E3, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @26E7 memory[0x00:0x00] } 26E4 60 PUSH1 0x00 26E6 80 DUP1 26E7 FD *REVERT // Stack delta = +0 // Outputs[1] { @26E7 revert(memory[0x00:0x00]); } // Block terminates label_26E8: // Incoming jump from 0x26E3, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @26E9 stack[-6] // @26EA stack[-1] // @26EF stack[-7] // } 26E8 5B JUMPDEST 26E9 85 DUP6 26EA 01 ADD 26EB 60 PUSH1 0x1f 26ED 81 DUP2 26EE 01 ADD 26EF 87 DUP8 26F0 13 SGT 26F1 61 PUSH2 0x26f9 26F4 57 *JUMPI // Stack delta = +0 // Outputs[1] { @26EA stack[-1] = stack[-6] + stack[-1] } // Block ends with conditional jump to 0x26f9, if stack[-7] i> stack[-6] + stack[-1] + 0x1f label_26F5: // Incoming jump from 0x26F4, if not stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[1] { @26F8 memory[0x00:0x00] } 26F5 60 PUSH1 0x00 26F7 80 DUP1 26F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @26F8 revert(memory[0x00:0x00]); } // Block terminates label_26F9: // Incoming jump from 0x26F4, if stack[-7] i> stack[-6] + stack[-1] + 0x1f // Inputs[3] // { // @26FD stack[-7] // @26FE stack[-1] // @26FF msg.data[stack[-1]:stack[-1] + 0x20] // } 26F9 5B JUMPDEST 26FA 61 PUSH2 0x2708 26FD 87 DUP8 26FE 82 DUP3 26FF 35 CALLDATALOAD 2700 60 PUSH1 0x20 2702 84 DUP5 2703 01 ADD 2704 61 PUSH2 0x2550 2707 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @26FA stack[0] = 0x2708 // @26FD stack[1] = stack[-7] // @26FF stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2703 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2550, returns to 0x2708 label_2708: // Incoming return from call to 0x2550 at 0x2707 // Inputs[8] // { // @2709 stack[-1] // @2709 stack[-3] // @270C stack[-6] // @270D stack[-9] // @270E stack[-5] // @270F stack[-8] // @2711 stack[-4] // @2711 stack[-7] // } 2708 5B JUMPDEST 2709 91 SWAP2 270A 50 POP 270B 50 POP 270C 92 SWAP3 270D 95 SWAP6 270E 91 SWAP2 270F 94 SWAP5 2710 50 POP 2711 92 SWAP3 2712 50 POP 2713 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @270C stack[-6] = stack[-1] // @270D stack[-9] = stack[-6] // @270F stack[-8] = stack[-5] // @2711 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_2714: // Incoming jump from 0x0585 // Inputs[2] // { // @271A stack[-1] // @271B stack[-2] // } 2714 5B JUMPDEST 2715 60 PUSH1 0x00 2717 80 DUP1 2718 60 PUSH1 0x40 271A 83 DUP4 271B 85 DUP6 271C 03 SUB 271D 12 SLT 271E 15 ISZERO 271F 61 PUSH2 0x2727 2722 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2715 stack[0] = 0x00 // @2717 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2727, if !(stack[-2] - stack[-1] i< 0x40) label_2723: // Incoming jump from 0x2722, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2726 memory[0x00:0x00] } 2723 60 PUSH1 0x00 2725 80 DUP1 2726 FD *REVERT // Stack delta = +0 // Outputs[1] { @2726 revert(memory[0x00:0x00]); } // Block terminates label_2727: // Incoming jump from 0x2722, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @272B stack[-3] } 2727 5B JUMPDEST 2728 61 PUSH2 0x2730 272B 83 DUP4 272C 61 PUSH2 0x25c6 272F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2728 stack[0] = 0x2730 // @272B stack[1] = stack[-3] // } // Block ends with call to 0x25c6, returns to 0x2730 label_2730: // Incoming return from call to 0x25C6 at 0x272F // Inputs[3] // { // @2731 stack[-3] // @2731 stack[-1] // @2738 stack[-4] // } 2730 5B JUMPDEST 2731 91 SWAP2 2732 50 POP 2733 61 PUSH2 0x2653 2736 60 PUSH1 0x20 2738 84 DUP5 2739 01 ADD 273A 61 PUSH2 0x25e2 273D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2731 stack[-3] = stack[-1] // @2733 stack[-1] = 0x2653 // @2739 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x25e2, returns to 0x2653 label_273E: // Incoming call from 0x033C, returns to 0x033D // Inputs[2] // { // @2744 stack[-1] // @2745 stack[-2] // } 273E 5B JUMPDEST 273F 60 PUSH1 0x00 2741 80 DUP1 2742 60 PUSH1 0x40 2744 83 DUP4 2745 85 DUP6 2746 03 SUB 2747 12 SLT 2748 15 ISZERO 2749 61 PUSH2 0x2751 274C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @273F stack[0] = 0x00 // @2741 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2751, if !(stack[-2] - stack[-1] i< 0x40) label_274D: // Incoming jump from 0x274C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2750 memory[0x00:0x00] } 274D 60 PUSH1 0x00 274F 80 DUP1 2750 FD *REVERT // Stack delta = +0 // Outputs[1] { @2750 revert(memory[0x00:0x00]); } // Block terminates label_2751: // Incoming jump from 0x274C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2755 stack[-3] } 2751 5B JUMPDEST 2752 61 PUSH2 0x275a 2755 83 DUP4 2756 61 PUSH2 0x25c6 2759 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2752 stack[0] = 0x275a // @2755 stack[1] = stack[-3] // } // Block ends with call to 0x25c6, returns to 0x275A label_275A: // Incoming return from call to 0x25C6 at 0x2759 // Inputs[5] // { // @275B stack[-6] // @275B stack[-1] // @275E stack[-4] // @2762 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2763 stack[-5] // } 275A 5B JUMPDEST 275B 94 SWAP5 275C 60 PUSH1 0x20 275E 93 SWAP4 275F 90 SWAP1 2760 93 SWAP4 2761 01 ADD 2762 35 CALLDATALOAD 2763 93 SWAP4 2764 50 POP 2765 50 POP 2766 50 POP 2767 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @275B stack[-6] = stack[-1] // @2763 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_2768: // Incoming jump from 0x02E7 // Inputs[2] // { // @276E stack[-1] // @276F stack[-2] // } 2768 5B JUMPDEST 2769 60 PUSH1 0x00 276B 80 DUP1 276C 60 PUSH1 0x40 276E 83 DUP4 276F 85 DUP6 2770 03 SUB 2771 12 SLT 2772 15 ISZERO 2773 61 PUSH2 0x277b 2776 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2769 stack[0] = 0x00 // @276B stack[1] = 0x00 // } // Block ends with conditional jump to 0x277b, if !(stack[-2] - stack[-1] i< 0x40) label_2777: // Incoming jump from 0x2776, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @277A memory[0x00:0x00] } 2777 60 PUSH1 0x00 2779 80 DUP1 277A FD *REVERT // Stack delta = +0 // Outputs[1] { @277A revert(memory[0x00:0x00]); } // Block terminates label_277B: // Incoming jump from 0x2776, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @277F stack[-3] } 277B 5B JUMPDEST 277C 61 PUSH2 0x2784 277F 83 DUP4 2780 61 PUSH2 0x25c6 2783 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @277C stack[0] = 0x2784 // @277F stack[1] = stack[-3] // } // Block ends with call to 0x25c6, returns to 0x2784 label_2784: // Incoming return from call to 0x25C6 at 0x2783 // Inputs[3] // { // @2785 stack[-1] // @2785 stack[-3] // @278C stack[-4] // } 2784 5B JUMPDEST 2785 91 SWAP2 2786 50 POP 2787 61 PUSH2 0x2653 278A 60 PUSH1 0x20 278C 84 DUP5 278D 01 ADD 278E 61 PUSH2 0x25f2 2791 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @2785 stack[-3] = stack[-1] // @2787 stack[-1] = 0x2653 // @278D stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x25f2, returns to 0x2653 label_2792: // Incoming call from 0x04A4, returns to 0x04A5 // Inputs[2] // { // @2797 stack[-1] // @2798 stack[-2] // } 2792 5B JUMPDEST 2793 60 PUSH1 0x00 2795 60 PUSH1 0x20 2797 82 DUP3 2798 84 DUP5 2799 03 SUB 279A 12 SLT 279B 15 ISZERO 279C 61 PUSH2 0x27a4 279F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2793 stack[0] = 0x00 } // Block ends with conditional jump to 0x27a4, if !(stack[-2] - stack[-1] i< 0x20) label_27A0: // Incoming jump from 0x279F, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @27A3 memory[0x00:0x00] } 27A0 60 PUSH1 0x00 27A2 80 DUP1 27A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @27A3 revert(memory[0x00:0x00]); } // Block terminates label_27A4: // Incoming jump from 0x279F, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @27A8 stack[-2] } 27A4 5B JUMPDEST 27A5 61 PUSH2 0x120b 27A8 82 DUP3 27A9 61 PUSH2 0x25e2 27AC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @27A5 stack[0] = 0x120b // @27A8 stack[1] = stack[-2] // } // Block ends with call to 0x25e2, returns to 0x120B label_27AD: // Incoming call from 0x0435, returns to 0x0436 // Incoming call from 0x05B3, returns to 0x05B4 // Incoming call from 0x0311, returns to 0x0312 // Incoming call from 0x056A, returns to 0x056B // Incoming call from 0x04B7, returns to 0x04B8 // Incoming call from 0x0476, returns to 0x0477 // Incoming call from 0x0380, returns to 0x0381 // Inputs[2] // { // @27B2 stack[-1] // @27B3 stack[-2] // } 27AD 5B JUMPDEST 27AE 60 PUSH1 0x00 27B0 60 PUSH1 0x20 27B2 82 DUP3 27B3 84 DUP5 27B4 03 SUB 27B5 12 SLT 27B6 15 ISZERO 27B7 61 PUSH2 0x27bf 27BA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27AE stack[0] = 0x00 } // Block ends with conditional jump to 0x27bf, if !(stack[-2] - stack[-1] i< 0x20) label_27BB: // Incoming jump from 0x27BA, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @27BE memory[0x00:0x00] } 27BB 60 PUSH1 0x00 27BD 80 DUP1 27BE FD *REVERT // Stack delta = +0 // Outputs[1] { @27BE revert(memory[0x00:0x00]); } // Block terminates label_27BF: // Incoming jump from 0x27BA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @27C1 msg.data[stack[-2]:stack[-2] + 0x20] // @27C1 stack[-2] // @27C2 stack[-4] // @27C3 stack[-3] // } 27BF 5B JUMPDEST 27C0 50 POP 27C1 35 CALLDATALOAD 27C2 91 SWAP2 27C3 90 SWAP1 27C4 50 POP 27C5 56 *JUMP // Stack delta = -3 // Outputs[1] { @27C2 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_27C6: // Incoming call from 0x0502, returns to 0x0503 // Incoming call from 0x040F, returns to 0x0410 // Incoming call from 0x03FC, returns to 0x03FD // Incoming call from 0x05D3, returns to 0x05D4 // Inputs[2] // { // @27CC stack[-1] // @27CD stack[-2] // } 27C6 5B JUMPDEST 27C7 60 PUSH1 0x00 27C9 80 DUP1 27CA 60 PUSH1 0x40 27CC 83 DUP4 27CD 85 DUP6 27CE 03 SUB 27CF 12 SLT 27D0 15 ISZERO 27D1 61 PUSH2 0x27d9 27D4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @27C7 stack[0] = 0x00 // @27C9 stack[1] = 0x00 // } // Block ends with conditional jump to 0x27d9, if !(stack[-2] - stack[-1] i< 0x40) label_27D5: // Incoming jump from 0x27D4, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @27D8 memory[0x00:0x00] } 27D5 60 PUSH1 0x00 27D7 80 DUP1 27D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @27D8 revert(memory[0x00:0x00]); } // Block terminates label_27D9: // Incoming jump from 0x27D4, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[3] // { // @27DA stack[-3] // @27DB msg.data[stack[-3]:stack[-3] + 0x20] // @27DC stack[-2] // } 27D9 5B JUMPDEST 27DA 82 DUP3 27DB 35 CALLDATALOAD 27DC 91 SWAP2 27DD 50 POP 27DE 61 PUSH2 0x2653 27E1 60 PUSH1 0x20 27E3 84 DUP5 27E4 01 ADD 27E5 61 PUSH2 0x25c6 27E8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @27DC stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @27DE stack[0] = 0x2653 // @27E4 stack[1] = stack[-3] + 0x20 // } // Block ends with call to 0x25c6, returns to 0x2653 label_27E9: // Incoming call from 0x02BF, returns to 0x02C0 // Inputs[2] // { // @27EE stack[-1] // @27EF stack[-2] // } 27E9 5B JUMPDEST 27EA 60 PUSH1 0x00 27EC 60 PUSH1 0x20 27EE 82 DUP3 27EF 84 DUP5 27F0 03 SUB 27F1 12 SLT 27F2 15 ISZERO 27F3 61 PUSH2 0x27fb 27F6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27EA stack[0] = 0x00 } // Block ends with conditional jump to 0x27fb, if !(stack[-2] - stack[-1] i< 0x20) label_27F7: // Incoming jump from 0x27F6, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @27FA memory[0x00:0x00] } 27F7 60 PUSH1 0x00 27F9 80 DUP1 27FA FD *REVERT // Stack delta = +0 // Outputs[1] { @27FA revert(memory[0x00:0x00]); } // Block terminates label_27FB: // Incoming jump from 0x27F6, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @27FC stack[-2] // @27FD msg.data[stack[-2]:stack[-2] + 0x20] // } 27FB 5B JUMPDEST 27FC 81 DUP2 27FD 35 CALLDATALOAD 27FE 61 PUSH2 0x120b 2801 81 DUP2 2802 61 PUSH2 0x2b75 2805 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @27FD stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @27FE stack[1] = 0x120b // @2801 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2b75, returns to 0x120B label_2806: // Incoming jump from 0x1E08 // Inputs[2] // { // @280B stack[-1] // @280C stack[-2] // } 2806 5B JUMPDEST 2807 60 PUSH1 0x00 2809 60 PUSH1 0x20 280B 82 DUP3 280C 84 DUP5 280D 03 SUB 280E 12 SLT 280F 15 ISZERO 2810 61 PUSH2 0x2818 2813 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2807 stack[0] = 0x00 } // Block ends with conditional jump to 0x2818, if !(stack[-2] - stack[-1] i< 0x20) label_2814: // Incoming jump from 0x2813, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2817 memory[0x00:0x00] } 2814 60 PUSH1 0x00 2816 80 DUP1 2817 FD *REVERT // Stack delta = +0 // Outputs[1] { @2817 revert(memory[0x00:0x00]); } // Block terminates label_2818: // Incoming jump from 0x2813, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2819 stack[-2] // @281A memory[stack[-2]:stack[-2] + 0x20] // } 2818 5B JUMPDEST 2819 81 DUP2 281A 51 MLOAD 281B 61 PUSH2 0x120b 281E 81 DUP2 281F 61 PUSH2 0x2b75 2822 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @281A stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @281B stack[1] = 0x120b // @281E stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2b75, returns to 0x120B label_2823: // Incoming call from 0x0450, returns to 0x0451 // Incoming call from 0x0635, returns to 0x0636 // Inputs[2] // { // @2828 stack[-1] // @2829 stack[-2] // } 2823 5B JUMPDEST 2824 60 PUSH1 0x00 2826 60 PUSH1 0x20 2828 82 DUP3 2829 84 DUP5 282A 03 SUB 282B 12 SLT 282C 15 ISZERO 282D 61 PUSH2 0x2835 2830 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2824 stack[0] = 0x00 } // Block ends with conditional jump to 0x2835, if !(stack[-2] - stack[-1] i< 0x20) label_2831: // Incoming jump from 0x2830, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2834 memory[0x00:0x00] } 2831 60 PUSH1 0x00 2833 80 DUP1 2834 FD *REVERT // Stack delta = +0 // Outputs[1] { @2834 revert(memory[0x00:0x00]); } // Block terminates label_2835: // Incoming jump from 0x2830, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2836 stack[-2] // @2837 msg.data[stack[-2]:stack[-2] + 0x20] // } 2835 5B JUMPDEST 2836 81 DUP2 2837 35 CALLDATALOAD 2838 67 PUSH8 0xffffffffffffffff 2841 81 DUP2 2842 11 GT 2843 15 ISZERO 2844 61 PUSH2 0x284c 2847 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2837 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x284c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2848: // Incoming jump from 0x2847, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @284B memory[0x00:0x00] } 2848 60 PUSH1 0x00 284A 80 DUP1 284B FD *REVERT // Stack delta = +0 // Outputs[1] { @284B revert(memory[0x00:0x00]); } // Block terminates label_284C: // Incoming jump from 0x2847, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @284D stack[-3] // @284E stack[-1] // @2853 stack[-4] // } 284C 5B JUMPDEST 284D 82 DUP3 284E 01 ADD 284F 60 PUSH1 0x1f 2851 81 DUP2 2852 01 ADD 2853 84 DUP5 2854 13 SGT 2855 61 PUSH2 0x285d 2858 57 *JUMPI // Stack delta = +0 // Outputs[1] { @284E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x285d, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_2859: // Incoming jump from 0x2858, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @285C memory[0x00:0x00] } 2859 60 PUSH1 0x00 285B 80 DUP1 285C FD *REVERT // Stack delta = +0 // Outputs[1] { @285C revert(memory[0x00:0x00]); } // Block terminates label_285D: // Incoming jump from 0x2858, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2861 stack[-4] // @2862 stack[-1] // @2863 msg.data[stack[-1]:stack[-1] + 0x20] // } 285D 5B JUMPDEST 285E 61 PUSH2 0x1e7d 2861 84 DUP5 2862 82 DUP3 2863 35 CALLDATALOAD 2864 60 PUSH1 0x20 2866 84 DUP5 2867 01 ADD 2868 61 PUSH2 0x2550 286B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @285E stack[0] = 0x1e7d // @2861 stack[1] = stack[-4] // @2863 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2867 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x2550, returns to 0x1E7D label_286C: // Incoming call from 0x0DD4, returns to 0x0DD5 // Incoming call from 0x0C58, returns to 0x0C59 // Incoming call from 0x0D2C, returns to 0x0D2D // Incoming call from 0x0BB0, returns to 0x0BB1 // 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[4] // { // @2880 memory[stack[-2]:stack[-2] + 0x20] // @2880 stack[-2] // @2881 stack[-4] // @2882 stack[-3] // } 287E 5B JUMPDEST 287F 50 POP 2880 51 MLOAD 2881 91 SWAP2 2882 90 SWAP1 2883 50 POP 2884 56 *JUMP // Stack delta = -3 // Outputs[1] { @2881 stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2885: // Incoming call from 0x0463, returns to 0x0464 // Inputs[2] // { // @288D stack[-1] // @288E stack[-2] // } 2885 5B JUMPDEST 2886 60 PUSH1 0x00 2888 80 DUP1 2889 60 PUSH1 0x00 288B 60 PUSH1 0x60 288D 84 DUP5 288E 86 DUP7 288F 03 SUB 2890 12 SLT 2891 15 ISZERO 2892 61 PUSH2 0x289a 2895 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2886 stack[0] = 0x00 // @2888 stack[1] = 0x00 // @2889 stack[2] = 0x00 // } // Block ends with conditional jump to 0x289a, if !(stack[-2] - stack[-1] i< 0x60) label_2896: // Incoming jump from 0x2895, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2899 memory[0x00:0x00] } 2896 60 PUSH1 0x00 2898 80 DUP1 2899 FD *REVERT // Stack delta = +0 // Outputs[1] { @2899 revert(memory[0x00:0x00]); } // Block terminates label_289A: // Incoming jump from 0x2895, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[3] // { // @289B stack[-4] // @289C msg.data[stack[-4]:stack[-4] + 0x20] // @289D stack[-3] // } 289A 5B JUMPDEST 289B 83 DUP4 289C 35 CALLDATALOAD 289D 92 SWAP3 289E 50 POP 289F 61 PUSH2 0x28aa 28A2 60 PUSH1 0x20 28A4 85 DUP6 28A5 01 ADD 28A6 61 PUSH2 0x25c6 28A9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @289D stack[-3] = msg.data[stack[-4]:stack[-4] + 0x20] // @289F stack[0] = 0x28aa // @28A5 stack[1] = stack[-4] + 0x20 // } // Block ends with call to 0x25c6, returns to 0x28AA label_28AA: // Incoming return from call to 0x25C6 at 0x28A9 // Inputs[3] // { // @28AB stack[-1] // @28AB stack[-3] // @28B2 stack[-5] // } 28AA 5B JUMPDEST 28AB 91 SWAP2 28AC 50 POP 28AD 61 PUSH2 0x28b8 28B0 60 PUSH1 0x40 28B2 85 DUP6 28B3 01 ADD 28B4 61 PUSH2 0x25f2 28B7 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @28AB stack[-3] = stack[-1] // @28AD stack[-1] = 0x28b8 // @28B3 stack[0] = stack[-5] + 0x40 // } // Block ends with call to 0x25f2, returns to 0x28B8 label_28B8: // Incoming return from call to 0x25F2 at 0x28B7 // Inputs[7] // { // @28B9 stack[-2] // @28B9 stack[-1] // @28BB stack[-5] // @28BD stack[-6] // @28BD stack[-3] // @28BF stack[-4] // @28BF stack[-7] // } 28B8 5B JUMPDEST 28B9 90 SWAP1 28BA 50 POP 28BB 92 SWAP3 28BC 50 POP 28BD 92 SWAP3 28BE 50 POP 28BF 92 SWAP3 28C0 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @28BB stack[-5] = stack[-1] // @28BD stack[-6] = stack[-3] // @28BF stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_28C1: // Incoming call from 0x03A3, returns to 0x03A4 // Inputs[2] // { // @28C7 stack[-1] // @28C8 stack[-2] // } 28C1 5B JUMPDEST 28C2 60 PUSH1 0x00 28C4 80 DUP1 28C5 60 PUSH1 0x40 28C7 83 DUP4 28C8 85 DUP6 28C9 03 SUB 28CA 12 SLT 28CB 15 ISZERO 28CC 61 PUSH2 0x28d4 28CF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @28C2 stack[0] = 0x00 // @28C4 stack[1] = 0x00 // } // Block ends with conditional jump to 0x28d4, if !(stack[-2] - stack[-1] i< 0x40) label_28D0: // Incoming jump from 0x28CF, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @28D3 memory[0x00:0x00] } 28D0 60 PUSH1 0x00 28D2 80 DUP1 28D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @28D3 revert(memory[0x00:0x00]); } // Block terminates label_28D4: // Incoming jump from 0x28CF, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @28D7 stack[-3] // @28D8 msg.data[stack[-3]:stack[-3] + 0x20] // @28D9 stack[-5] // @28DF msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @28E0 stack[-4] // } 28D4 5B JUMPDEST 28D5 50 POP 28D6 50 POP 28D7 80 DUP1 28D8 35 CALLDATALOAD 28D9 92 SWAP3 28DA 60 PUSH1 0x20 28DC 90 SWAP1 28DD 91 SWAP2 28DE 01 ADD 28DF 35 CALLDATALOAD 28E0 91 SWAP2 28E1 50 POP 28E2 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @28D9 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @28E0 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_28E3: // Incoming call from 0x29F0, returns to 0x29F1 // Incoming call from 0x2A0D, returns to 0x120B // Inputs[3] // { // @28E6 stack[-1] // @28E7 memory[stack[-1]:stack[-1] + 0x20] // @28E9 stack[-2] // } 28E3 5B JUMPDEST 28E4 60 PUSH1 0x00 28E6 81 DUP2 28E7 51 MLOAD 28E8 80 DUP1 28E9 84 DUP5 28EA 52 MSTORE 28EB 61 PUSH2 0x28fb 28EE 81 DUP2 28EF 60 PUSH1 0x20 28F1 86 DUP7 28F2 01 ADD 28F3 60 PUSH1 0x20 28F5 86 DUP7 28F6 01 ADD 28F7 61 PUSH2 0x2a70 28FA 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @28E4 stack[0] = 0x00 // @28E7 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @28EA memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @28EB stack[2] = 0x28fb // @28EE stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @28F2 stack[4] = stack[-2] + 0x20 // @28F6 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x2a70, returns to 0x28FB label_28FB: // Incoming return from call to 0x2A70 at 0x28FA // Inputs[4] // { // @28FE stack[-1] // @2903 stack[-4] // @2904 stack[-2] // @290A stack[-5] // } 28FB 5B JUMPDEST 28FC 60 PUSH1 0x1f 28FE 01 ADD 28FF 60 PUSH1 0x1f 2901 19 NOT 2902 16 AND 2903 92 SWAP3 2904 90 SWAP1 2905 92 SWAP3 2906 01 ADD 2907 60 PUSH1 0x20 2909 01 ADD 290A 92 SWAP3 290B 91 SWAP2 290C 50 POP 290D 50 POP 290E 56 *JUMP // Stack delta = -4 // Outputs[1] { @290A stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 290F 5B JUMPDEST 2910 60 PUSH1 0x00 2912 83 DUP4 2913 51 MLOAD 2914 61 PUSH2 0x2921 2917 81 DUP2 2918 84 DUP5 2919 60 PUSH1 0x20 291B 88 DUP9 291C 01 ADD 291D 61 PUSH2 0x2a70 2920 56 *JUMP 2921 5B JUMPDEST 2922 83 DUP4 2923 51 MLOAD 2924 90 SWAP1 2925 83 DUP4 2926 01 ADD 2927 90 SWAP1 2928 61 PUSH2 0x2935 292B 81 DUP2 292C 83 DUP4 292D 60 PUSH1 0x20 292F 88 DUP9 2930 01 ADD 2931 61 PUSH2 0x2a70 2934 56 *JUMP 2935 5B JUMPDEST 2936 01 ADD 2937 94 SWAP5 2938 93 SWAP4 2939 50 POP 293A 50 POP 293B 50 POP 293C 50 POP 293D 56 *JUMP label_293E: // Incoming call from 0x2029, returns to 0x202A // Inputs[3] // { // @2960 stack[-1] // @2964 stack[-3] // @2965 memory[stack[-3]:stack[-3] + 0x20] // } 293E 5B JUMPDEST 293F 7F PUSH32 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 2960 81 DUP2 2961 52 MSTORE 2962 60 PUSH1 0x00 2964 83 DUP4 2965 51 MLOAD 2966 61 PUSH2 0x2976 2969 81 DUP2 296A 60 PUSH1 0x17 296C 85 DUP6 296D 01 ADD 296E 60 PUSH1 0x20 2970 88 DUP9 2971 01 ADD 2972 61 PUSH2 0x2a70 2975 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2961 memory[stack[-1]:stack[-1] + 0x20] = 0x416363657373436f6e74726f6c3a206163636f756e7420000000000000000000 // @2962 stack[0] = 0x00 // @2965 stack[1] = memory[stack[-3]:stack[-3] + 0x20] // @2966 stack[2] = 0x2976 // @2969 stack[3] = memory[stack[-3]:stack[-3] + 0x20] // @296D stack[4] = stack[-1] + 0x17 // @2971 stack[5] = stack[-3] + 0x20 // } // Block ends with call to 0x2a70, returns to 0x2976 label_2976: // Incoming return from call to 0x2A70 at 0x2975 // Inputs[4] // { // @299A stack[-1] // @299B stack[-3] // @29A1 stack[-4] // @29A2 memory[stack[-4]:stack[-4] + 0x20] // } 2976 5B JUMPDEST 2977 7F PUSH32 0x206973206d697373696e6720726f6c6520000000000000000000000000000000 2998 60 PUSH1 0x17 299A 91 SWAP2 299B 84 DUP5 299C 01 ADD 299D 91 SWAP2 299E 82 DUP3 299F 01 ADD 29A0 52 MSTORE 29A1 83 DUP4 29A2 51 MLOAD 29A3 61 PUSH2 0x29b3 29A6 81 DUP2 29A7 60 PUSH1 0x28 29A9 84 DUP5 29AA 01 ADD 29AB 60 PUSH1 0x20 29AD 88 DUP9 29AE 01 ADD 29AF 61 PUSH2 0x2a70 29B2 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @299D stack[-1] = stack[-3] + stack[-1] // @29A0 memory[stack[-3] + stack[-1] + 0x17:stack[-3] + stack[-1] + 0x17 + 0x20] = 0x206973206d697373696e6720726f6c6520000000000000000000000000000000 // @29A2 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @29A3 stack[1] = 0x29b3 // @29A6 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @29AA stack[3] = stack[-3] + stack[-1] + 0x28 // @29AE stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x2a70, returns to 0x29B3 label_29B3: // Incoming return from call to 0x2A70 at 0x29B2 // Inputs[4] // { // @29B4 stack[-1] // @29B4 stack[-2] // @29B8 stack[-7] // @29B9 stack[-6] // } 29B3 5B JUMPDEST 29B4 01 ADD 29B5 60 PUSH1 0x28 29B7 01 ADD 29B8 94 SWAP5 29B9 93 SWAP4 29BA 50 POP 29BB 50 POP 29BC 50 POP 29BD 50 POP 29BE 56 *JUMP // Stack delta = -6 // Outputs[1] { @29B8 stack[-7] = 0x28 + stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] label_29BF: // Incoming call from 0x1DC1, returns to 0x1DC2 // Inputs[5] // { // @29CB stack[-5] // @29CD stack[-1] // @29D0 stack[-4] // @29D8 stack[-3] // @29EC stack[-2] // } 29BF 5B JUMPDEST 29C0 60 PUSH1 0x00 29C2 60 PUSH1 0x01 29C4 60 PUSH1 0x01 29C6 60 PUSH1 0xa0 29C8 1B SHL 29C9 03 SUB 29CA 80 DUP1 29CB 87 DUP8 29CC 16 AND 29CD 83 DUP4 29CE 52 MSTORE 29CF 80 DUP1 29D0 86 DUP7 29D1 16 AND 29D2 60 PUSH1 0x20 29D4 84 DUP5 29D5 01 ADD 29D6 52 MSTORE 29D7 50 POP 29D8 83 DUP4 29D9 60 PUSH1 0x40 29DB 83 DUP4 29DC 01 ADD 29DD 52 MSTORE 29DE 60 PUSH1 0x80 29E0 60 PUSH1 0x60 29E2 83 DUP4 29E3 01 ADD 29E4 52 MSTORE 29E5 61 PUSH2 0x29f1 29E8 60 PUSH1 0x80 29EA 83 DUP4 29EB 01 ADD 29EC 84 DUP5 29ED 61 PUSH2 0x28e3 29F0 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @29C0 stack[0] = 0x00 // @29CE memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @29D6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @29DD memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @29E4 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @29E5 stack[1] = 0x29f1 // @29EB stack[2] = stack[-1] + 0x80 // @29EC stack[3] = stack[-2] // } // Block ends with call to 0x28e3, returns to 0x29F1 label_29F1: // Incoming return from call to 0x28E3 at 0x29F0 // Inputs[3] // { // @29F2 stack[-8] // @29F2 stack[-1] // @29F3 stack[-7] // } 29F1 5B JUMPDEST 29F2 96 SWAP7 29F3 95 SWAP6 29F4 50 POP 29F5 50 POP 29F6 50 POP 29F7 50 POP 29F8 50 POP 29F9 50 POP 29FA 56 *JUMP // Stack delta = -7 // Outputs[1] { @29F2 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_29FB: // Incoming call from 0x204F, returns to 0x0A1B // Incoming call from 0x0303, returns to 0x02D1 // Inputs[2] // { // @29FE stack[-1] // @2A09 stack[-2] // } 29FB 5B JUMPDEST 29FC 60 PUSH1 0x20 29FE 81 DUP2 29FF 52 MSTORE 2A00 60 PUSH1 0x00 2A02 61 PUSH2 0x120b 2A05 60 PUSH1 0x20 2A07 83 DUP4 2A08 01 ADD 2A09 84 DUP5 2A0A 61 PUSH2 0x28e3 2A0D 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @29FF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2A00 stack[0] = 0x00 // @2A02 stack[1] = 0x120b // @2A08 stack[2] = stack[-1] + 0x20 // @2A09 stack[3] = stack[-2] // } // Block ends with call to 0x28e3, returns to 0x120B label_2A0E: // Incoming call from 0x23E2, returns to 0x23E3 // Incoming call from 0x230B, returns to 0x230C // Inputs[2] // { // @2A11 stack[-2] // @2A13 stack[-1] // } 2A0E 5B JUMPDEST 2A0F 60 PUSH1 0x00 2A11 82 DUP3 2A12 19 NOT 2A13 82 DUP3 2A14 11 GT 2A15 15 ISZERO 2A16 61 PUSH2 0x2a21 2A19 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A0F stack[0] = 0x00 } // Block ends with conditional jump to 0x2a21, if !(stack[-1] > ~stack[-2]) label_2A1A: // Incoming jump from 0x2A19, if not !(stack[-1] > ~stack[-2]) 2A1A 61 PUSH2 0x2a21 2A1D 61 PUSH2 0x2b1d 2A20 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A1A stack[0] = 0x2a21 } // Block ends with unconditional jump to 0x2b1d label_2A21: // Incoming jump from 0x2A19, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @2A23 stack[-2] // @2A23 stack[-3] // @2A24 stack[-4] // } 2A21 5B JUMPDEST 2A22 50 POP 2A23 01 ADD 2A24 90 SWAP1 2A25 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A24 stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2A26: // Incoming call from 0x1010, returns to 0x1011 // Incoming call from 0x096D, returns to 0x096E // Incoming call from 0x1A80, returns to 0x1A81 // Inputs[1] { @2A29 stack[-2] } 2A26 5B JUMPDEST 2A27 60 PUSH1 0x00 2A29 82 DUP3 2A2A 61 PUSH2 0x2a35 2A2D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A27 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a35, if stack[-2] label_2A2E: // Incoming jump from 0x2A2D, if not stack[-2] 2A2E 61 PUSH2 0x2a35 2A31 61 PUSH2 0x2b33 2A34 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A2E stack[0] = 0x2a35 } // Block ends with unconditional jump to 0x2b33 label_2A35: // Incoming jump from 0x2A2D, if stack[-2] // Inputs[3] // { // @2A37 stack[-3] // @2A37 stack[-2] // @2A38 stack[-4] // } 2A35 5B JUMPDEST 2A36 50 POP 2A37 04 DIV 2A38 90 SWAP1 2A39 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A38 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2A3A: // Incoming call from 0x2300, returns to 0x2301 // Incoming call from 0x0963, returns to 0x0964 // Incoming call from 0x0963, returns to 0x0964 // Incoming call from 0x23D7, returns to 0x23D8 // Inputs[2] // { // @2A3D stack[-1] // @2A42 stack[-2] // } 2A3A 5B JUMPDEST 2A3B 60 PUSH1 0x00 2A3D 81 DUP2 2A3E 60 PUSH1 0x00 2A40 19 NOT 2A41 04 DIV 2A42 83 DUP4 2A43 11 GT 2A44 82 DUP3 2A45 15 ISZERO 2A46 15 ISZERO 2A47 16 AND 2A48 15 ISZERO 2A49 61 PUSH2 0x2a54 2A4C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A3B stack[0] = 0x00 } // Block ends with conditional jump to 0x2a54, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2A4D: // Incoming jump from 0x2A4C, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2A4D 61 PUSH2 0x2a54 2A50 61 PUSH2 0x2b1d 2A53 56 *JUMP // Stack delta = +1 // Outputs[1] { @2A4D stack[0] = 0x2a54 } // Block ends with unconditional jump to 0x2b1d label_2A54: // Incoming jump from 0x2A4C, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @2A56 stack[-3] // @2A56 stack[-2] // @2A57 stack[-4] // } 2A54 5B JUMPDEST 2A55 50 POP 2A56 02 MUL 2A57 90 SWAP1 2A58 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A57 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] 2A59 5B JUMPDEST 2A5A 60 PUSH1 0x00 2A5C 82 DUP3 2A5D 82 DUP3 2A5E 10 LT 2A5F 15 ISZERO 2A60 61 PUSH2 0x2a6b 2A63 57 *JUMPI 2A64 61 PUSH2 0x2a6b 2A67 61 PUSH2 0x2b1d 2A6A 56 *JUMP 2A6B 5B JUMPDEST 2A6C 50 POP 2A6D 03 SUB 2A6E 90 SWAP1 2A6F 56 *JUMP label_2A70: // Incoming call from 0x29B2, returns to 0x29B3 // Incoming call from 0x28FA, returns to 0x28FB // Incoming call from 0x2975, returns to 0x2976 // Inputs[1] { @2A74 stack[-3] } 2A70 5B JUMPDEST 2A71 60 PUSH1 0x00 2A73 5B JUMPDEST 2A74 83 DUP4 2A75 81 DUP2 2A76 10 LT 2A77 15 ISZERO 2A78 61 PUSH2 0x2a8b 2A7B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A71 stack[0] = 0x00 } // Block ends with conditional jump to 0x2a8b, if !(0x00 < stack[-3]) label_2A7C: // Incoming jump from 0x2A7B, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2A7B, if not !(0x00 < stack[-3]) // Inputs[4] // { // @2A7C stack[-2] // @2A7D stack[-1] // @2A7F memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2A80 stack[-3] // } 2A7C 81 DUP2 2A7D 81 DUP2 2A7E 01 ADD 2A7F 51 MLOAD 2A80 83 DUP4 2A81 82 DUP3 2A82 01 ADD 2A83 52 MSTORE 2A84 60 PUSH1 0x20 2A86 01 ADD 2A87 61 PUSH2 0x2a73 2A8A 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2A83 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2A86 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x2a73 label_2A8B: // Incoming jump from 0x2A7B, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2A7B, if !(0x00 < stack[-3]) // Inputs[2] // { // @2A8C stack[-4] // @2A8D stack[-1] // } 2A8B 5B JUMPDEST 2A8C 83 DUP4 2A8D 81 DUP2 2A8E 11 GT 2A8F 15 ISZERO 2A90 61 PUSH2 0x0e93 2A93 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e93, if !(stack[-1] > stack[-4]) label_2A94: // Incoming jump from 0x2A93, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2A98 stack[-4] // @2A99 stack[-3] // @2A9B stack[-5] // } 2A94 50 POP 2A95 50 POP 2A96 60 PUSH1 0x00 2A98 91 SWAP2 2A99 01 ADD 2A9A 52 MSTORE 2A9B 56 *JUMP // Stack delta = -5 // Outputs[1] { @2A9A memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2A9C: // Incoming call from 0x2460, returns to 0x2461 // Inputs[1] { @2A9F stack[-1] } 2A9C 5B JUMPDEST 2A9D 60 PUSH1 0x00 2A9F 81 DUP2 2AA0 61 PUSH2 0x2aab 2AA3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A9D stack[0] = 0x00 } // Block ends with conditional jump to 0x2aab, if stack[-1] label_2AA4: // Incoming jump from 0x2AA3, if not stack[-1] 2AA4 61 PUSH2 0x2aab 2AA7 61 PUSH2 0x2b1d 2AAA 56 *JUMP // Stack delta = +1 // Outputs[1] { @2AA4 stack[0] = 0x2aab } // Block ends with unconditional jump to 0x2b1d label_2AAB: // Incoming jump from 0x2AA3, if stack[-1] // Inputs[2] // { // @2AB0 stack[-2] // @2AB1 stack[-3] // } 2AAB 5B JUMPDEST 2AAC 50 POP 2AAD 60 PUSH1 0x00 2AAF 19 NOT 2AB0 01 ADD 2AB1 90 SWAP1 2AB2 56 *JUMP // Stack delta = -2 // Outputs[1] { @2AB1 stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2AB3: // Incoming call from 0x06BF, returns to 0x06C0 // Incoming call from 0x1001, returns to 0x0694 // Incoming call from 0x0860, returns to 0x0861 // Incoming call from 0x0834, returns to 0x0835 // Incoming call from 0x0693, returns to 0x0694 // Incoming call from 0x1E93, returns to 0x0694 // Inputs[1] { @2AB6 stack[-1] } 2AB3 5B JUMPDEST 2AB4 60 PUSH1 0x01 2AB6 81 DUP2 2AB7 81 DUP2 2AB8 1C SHR 2AB9 90 SWAP1 2ABA 82 DUP3 2ABB 16 AND 2ABC 80 DUP1 2ABD 61 PUSH2 0x2ac7 2AC0 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2AB9 stack[0] = stack[-1] >> 0x01 // @2ABB stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x2ac7, if stack[-1] & 0x01 label_2AC1: // Incoming jump from 0x2AC0, if not stack[-1] & 0x01 // Inputs[2] // { // @2AC3 stack[-2] // @2ACC stack[-1] // } 2AC1 60 PUSH1 0x7f 2AC3 82 DUP3 2AC4 16 AND 2AC5 91 SWAP2 2AC6 50 POP 2AC7 5B JUMPDEST 2AC8 60 PUSH1 0x20 2ACA 82 DUP3 2ACB 10 LT 2ACC 81 DUP2 2ACD 14 EQ 2ACE 15 ISZERO 2ACF 61 PUSH2 0x2ae8 2AD2 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2AC5 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x2ae8, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2AD3: // Incoming jump from 0x2AD2, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2AD2, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @2AE7 memory[0x00:0x24] } 2AD3 63 PUSH4 0x4e487b71 2AD8 60 PUSH1 0xe0 2ADA 1B SHL 2ADB 60 PUSH1 0x00 2ADD 52 MSTORE 2ADE 60 PUSH1 0x22 2AE0 60 PUSH1 0x04 2AE2 52 MSTORE 2AE3 60 PUSH1 0x24 2AE5 60 PUSH1 0x00 2AE7 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2ADD memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2AE2 memory[0x04:0x24] = 0x22 // @2AE7 revert(memory[0x00:0x24]); // } // Block terminates label_2AE8: // Incoming jump from 0x2AD2, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2AD2, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @2AEA stack[-4] // @2AEA stack[-2] // @2AEB stack[-3] // } 2AE8 5B JUMPDEST 2AE9 50 POP 2AEA 91 SWAP2 2AEB 90 SWAP1 2AEC 50 POP 2AED 56 *JUMP // Stack delta = -3 // Outputs[1] { @2AEA stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2AEE: // Incoming call from 0x0C89, returns to 0x0C8A // Incoming call from 0x0E05, returns to 0x0E06 // Incoming call from 0x0C7A, returns to 0x0C7B // Incoming call from 0x0DF6, returns to 0x0DF7 // Inputs[1] { @2AF4 stack[-1] } 2AEE 5B JUMPDEST 2AEF 60 PUSH1 0x00 2AF1 60 PUSH1 0x00 2AF3 19 NOT 2AF4 82 DUP3 2AF5 14 EQ 2AF6 15 ISZERO 2AF7 61 PUSH2 0x2b02 2AFA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2AEF stack[0] = 0x00 } // Block ends with conditional jump to 0x2b02, if !(stack[-1] == ~0x00) label_2AFB: // Incoming jump from 0x2AFA, if not !(stack[-1] == ~0x00) 2AFB 61 PUSH2 0x2b02 2AFE 61 PUSH2 0x2b1d 2B01 56 *JUMP // Stack delta = +1 // Outputs[1] { @2AFB stack[0] = 0x2b02 } // Block ends with unconditional jump to 0x2b1d label_2B02: // Incoming jump from 0x2AFA, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2B06 stack[-2] // @2B07 stack[-3] // } 2B02 5B JUMPDEST 2B03 50 POP 2B04 60 PUSH1 0x01 2B06 01 ADD 2B07 90 SWAP1 2B08 56 *JUMP // Stack delta = -2 // Outputs[1] { @2B07 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2B09: // Incoming call from 0x1020, returns to 0x1021 // Incoming call from 0x1A90, returns to 0x1A91 // Inputs[1] { @2B0C stack[-2] } 2B09 5B JUMPDEST 2B0A 60 PUSH1 0x00 2B0C 82 DUP3 2B0D 61 PUSH2 0x2b18 2B10 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2B0A stack[0] = 0x00 } // Block ends with conditional jump to 0x2b18, if stack[-2] label_2B11: // Incoming jump from 0x2B10, if not stack[-2] 2B11 61 PUSH2 0x2b18 2B14 61 PUSH2 0x2b33 2B17 56 *JUMP // Stack delta = +1 // Outputs[1] { @2B11 stack[0] = 0x2b18 } // Block ends with unconditional jump to 0x2b33 label_2B18: // Incoming jump from 0x2B10, if stack[-2] // Inputs[3] // { // @2B1A stack[-2] // @2B1A stack[-3] // @2B1B stack[-4] // } 2B18 5B JUMPDEST 2B19 50 POP 2B1A 06 MOD 2B1B 90 SWAP1 2B1C 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B1B stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_2B1D: // Incoming jump from 0x2AAA // Incoming jump from 0x2A20 // Incoming jump from 0x2A53 // Incoming jump from 0x2B01 // Inputs[1] { @2B32 memory[0x00:0x24] } 2B1D 5B JUMPDEST 2B1E 63 PUSH4 0x4e487b71 2B23 60 PUSH1 0xe0 2B25 1B SHL 2B26 60 PUSH1 0x00 2B28 52 MSTORE 2B29 60 PUSH1 0x11 2B2B 60 PUSH1 0x04 2B2D 52 MSTORE 2B2E 60 PUSH1 0x24 2B30 60 PUSH1 0x00 2B32 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B28 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2B2D memory[0x04:0x24] = 0x11 // @2B32 revert(memory[0x00:0x24]); // } // Block terminates label_2B33: // Incoming jump from 0x2B17 // Incoming jump from 0x2A34 // Inputs[1] { @2B48 memory[0x00:0x24] } 2B33 5B JUMPDEST 2B34 63 PUSH4 0x4e487b71 2B39 60 PUSH1 0xe0 2B3B 1B SHL 2B3C 60 PUSH1 0x00 2B3E 52 MSTORE 2B3F 60 PUSH1 0x12 2B41 60 PUSH1 0x04 2B43 52 MSTORE 2B44 60 PUSH1 0x24 2B46 60 PUSH1 0x00 2B48 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B3E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2B43 memory[0x04:0x24] = 0x12 // @2B48 revert(memory[0x00:0x24]); // } // Block terminates label_2B49: // Incoming jump from 0x2423 // Incoming jump from 0x1ABF // Incoming jump from 0x2368 // Incoming jump from 0x1037 // Incoming jump from 0x2439 // Incoming jump from 0x23B3 // Incoming jump from 0x1AA9 // Inputs[1] { @2B5E memory[0x00:0x24] } 2B49 5B JUMPDEST 2B4A 63 PUSH4 0x4e487b71 2B4F 60 PUSH1 0xe0 2B51 1B SHL 2B52 60 PUSH1 0x00 2B54 52 MSTORE 2B55 60 PUSH1 0x32 2B57 60 PUSH1 0x04 2B59 52 MSTORE 2B5A 60 PUSH1 0x24 2B5C 60 PUSH1 0x00 2B5E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B54 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2B59 memory[0x04:0x24] = 0x32 // @2B5E revert(memory[0x00:0x24]); // } // Block terminates label_2B5F: // Incoming jump from 0x2592 // Incoming jump from 0x256A // Incoming jump from 0x2323 // Inputs[1] { @2B74 memory[0x00:0x24] } 2B5F 5B JUMPDEST 2B60 63 PUSH4 0x4e487b71 2B65 60 PUSH1 0xe0 2B67 1B SHL 2B68 60 PUSH1 0x00 2B6A 52 MSTORE 2B6B 60 PUSH1 0x41 2B6D 60 PUSH1 0x04 2B6F 52 MSTORE 2B70 60 PUSH1 0x24 2B72 60 PUSH1 0x00 2B74 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2B6A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2B6F memory[0x04:0x24] = 0x41 // @2B74 revert(memory[0x00:0x24]); // } // Block terminates label_2B75: // Incoming call from 0x2805, returns to 0x120B // Incoming call from 0x2822, returns to 0x120B // Inputs[1] { @2B7F stack[-1] } 2B75 5B JUMPDEST 2B76 60 PUSH1 0x01 2B78 60 PUSH1 0x01 2B7A 60 PUSH1 0xe0 2B7C 1B SHL 2B7D 03 SUB 2B7E 19 NOT 2B7F 81 DUP2 2B80 16 AND 2B81 81 DUP2 2B82 14 EQ 2B83 61 PUSH2 0x0a69 2B86 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a69, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_2B87: // Incoming jump from 0x2B86, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @2B8A memory[0x00:0x00] } 2B87 60 PUSH1 0x00 2B89 80 DUP1 2B8A FD *REVERT // Stack delta = +0 // Outputs[1] { @2B8A revert(memory[0x00:0x00]); } // Block terminates 2B8B FE *ASSERT 2B8C A2 LOG2 2B8D 64 PUSH5 0x6970667358 2B93 22 22 2B94 12 SLT 2B95 20 SHA3 2B96 3C EXTCODECOPY 2B97 5F PUSH0 2B98 F3 *RETURN 2B99 C1 C1 2B9A 2B 2B 2B9B 63 PUSH4 0x41566aa4 2BA0 43 NUMBER 2BA1 B8 B8 2BA2 6D PUSH14 0x4322df9341a93897637f25efc9ca 2BB1 55 SSTORE 2BB2 EF EF 2BB3 A4 LOG4 2BB4 F0 CREATE 2BB5 2F 2F 2BB6 64 PUSH5 0x736f6c6343 2BBC 00 *STOP 2BBD 08 ADDMOD 2BBE 07 SMOD 2BBF 00 *STOP 2BC0 33 CALLER