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 0x0136 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0136, 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 0x8e3a7249 0026 11 GT 0027 61 PUSH2 0x00b8 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00b8, if 0x8e3a7249 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x8e3a7249 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xe61dc9b8 0031 11 GT 0032 61 PUSH2 0x007c 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x007c, if 0xe61dc9b8 > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xe61dc9b8 > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xe61dc9b8 003C 14 EQ 003D 61 PUSH2 0x027e 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x027e, if 0xe61dc9b8 == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xe61dc9b8 == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xe8f1868c 0047 14 EQ 0048 61 PUSH2 0x0291 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0291, if 0xe8f1868c == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xe8f1868c == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe985e9c5 0052 14 EQ 0053 61 PUSH2 0x02a4 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a4, 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 0xf242432a 005D 14 EQ 005E 61 PUSH2 0x02e0 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e0, if 0xf242432a == stack[-1] label_0062: // Incoming jump from 0x0061, if not 0xf242432a == stack[-1] // Inputs[1] { @0062 stack[-1] } 0062 80 DUP1 0063 63 PUSH4 0xf2fde38b 0068 14 EQ 0069 61 PUSH2 0x02f3 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02f3, if 0xf2fde38b == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf2fde38b == stack[-1] // Inputs[1] { @006D stack[-1] } 006D 80 DUP1 006E 63 PUSH4 0xf9132b1b 0073 14 EQ 0074 61 PUSH2 0x0306 0077 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0306, if 0xf9132b1b == stack[-1] label_0078: // Incoming jump from 0x0077, if not 0xf9132b1b == stack[-1] // Inputs[1] { @007B memory[0x00:0x00] } 0078 60 PUSH1 0x00 007A 80 DUP1 007B FD *REVERT // Stack delta = +0 // Outputs[1] { @007B revert(memory[0x00:0x00]); } // Block terminates label_007C: // Incoming jump from 0x0035, if 0xe61dc9b8 > stack[-1] // Inputs[1] { @007D stack[-1] } 007C 5B JUMPDEST 007D 80 DUP1 007E 63 PUSH4 0x8e3a7249 0083 14 EQ 0084 61 PUSH2 0x022a 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022a, if 0x8e3a7249 == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x8e3a7249 == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0xa22cb465 008E 14 EQ 008F 61 PUSH2 0x023d 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x023d, if 0xa22cb465 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xa7ecd37e 0099 14 EQ 009A 61 PUSH2 0x0250 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0250, if 0xa7ecd37e == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xa7ecd37e == stack[-1] // Inputs[1] { @009E stack[-1] } 009E 80 DUP1 009F 63 PUSH4 0xc124caaa 00A4 14 EQ 00A5 61 PUSH2 0x0263 00A8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0263, if 0xc124caaa == stack[-1] label_00A9: // Incoming jump from 0x00A8, if not 0xc124caaa == stack[-1] // Inputs[1] { @00A9 stack[-1] } 00A9 80 DUP1 00AA 63 PUSH4 0xdd3c6d5f 00AF 14 EQ 00B0 61 PUSH2 0x026b 00B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026b, if 0xdd3c6d5f == stack[-1] label_00B4: // Incoming jump from 0x00B3, if not 0xdd3c6d5f == stack[-1] // Inputs[1] { @00B7 memory[0x00:0x00] } 00B4 60 PUSH1 0x00 00B6 80 DUP1 00B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @00B7 revert(memory[0x00:0x00]); } // Block terminates label_00B8: // Incoming jump from 0x002A, if 0x8e3a7249 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00B9 stack[-1] } 00B8 5B JUMPDEST 00B9 80 DUP1 00BA 63 PUSH4 0x2eb2c2d6 00BF 11 GT 00C0 61 PUSH2 0x00ff 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ff, if 0x2eb2c2d6 > stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x2eb2c2d6 > stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x2eb2c2d6 00CA 14 EQ 00CB 61 PUSH2 0x01c1 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c1, if 0x2eb2c2d6 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x4e1273f4 00D5 14 EQ 00D6 61 PUSH2 0x01d4 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d4, if 0x4e1273f4 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x55f804b3 00E0 14 EQ 00E1 61 PUSH2 0x01f4 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f4, if 0x55f804b3 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x55f804b3 == stack[-1] // Inputs[1] { @00E5 stack[-1] } 00E5 80 DUP1 00E6 63 PUSH4 0x715018a6 00EB 14 EQ 00EC 61 PUSH2 0x0207 00EF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0207, if 0x715018a6 == stack[-1] label_00F0: // Incoming jump from 0x00EF, if not 0x715018a6 == stack[-1] // Inputs[1] { @00F0 stack[-1] } 00F0 80 DUP1 00F1 63 PUSH4 0x8da5cb5b 00F6 14 EQ 00F7 61 PUSH2 0x020f 00FA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x020f, if 0x8da5cb5b == stack[-1] label_00FB: // Incoming jump from 0x00FA, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00FE memory[0x00:0x00] } 00FB 60 PUSH1 0x00 00FD 80 DUP1 00FE FD *REVERT // Stack delta = +0 // Outputs[1] { @00FE revert(memory[0x00:0x00]); } // Block terminates label_00FF: // Incoming jump from 0x00C3, if 0x2eb2c2d6 > stack[-1] // Inputs[1] { @0100 stack[-1] } 00FF 5B JUMPDEST 0100 80 DUP1 0101 62 PUSH3 0xfdd58e 0105 14 EQ 0106 61 PUSH2 0x013b 0109 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013b, if 0xfdd58e == stack[-1] label_010A: // Incoming jump from 0x0109, if not 0xfdd58e == stack[-1] // Inputs[1] { @010A stack[-1] } 010A 80 DUP1 010B 63 PUSH4 0x01ffc9a7 0110 14 EQ 0111 61 PUSH2 0x0161 0114 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0161, if 0x01ffc9a7 == stack[-1] label_0115: // Incoming jump from 0x0114, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0115 stack[-1] } 0115 80 DUP1 0116 63 PUSH4 0x0e89341c 011B 14 EQ 011C 61 PUSH2 0x0184 011F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0184, if 0x0e89341c == stack[-1] label_0120: // Incoming jump from 0x011F, if not 0x0e89341c == stack[-1] // Inputs[1] { @0120 stack[-1] } 0120 80 DUP1 0121 63 PUSH4 0x24b3b58b 0126 14 EQ 0127 61 PUSH2 0x01a4 012A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a4, if 0x24b3b58b == stack[-1] label_012B: // Incoming jump from 0x012A, if not 0x24b3b58b == stack[-1] // Inputs[1] { @012B stack[-1] } 012B 80 DUP1 012C 63 PUSH4 0x28844ee3 0131 14 EQ 0132 61 PUSH2 0x01ac 0135 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ac, if 0x28844ee3 == stack[-1] label_0136: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0135, if not 0x28844ee3 == stack[-1] // Inputs[1] { @013A memory[0x00:0x00] } 0136 5B JUMPDEST 0137 60 PUSH1 0x00 0139 80 DUP1 013A FD *REVERT // Stack delta = +0 // Outputs[1] { @013A revert(memory[0x00:0x00]); } // Block terminates label_013B: // Incoming jump from 0x0109, if 0xfdd58e == stack[-1] // Inputs[1] { @0142 msg.data.length } 013B 5B JUMPDEST 013C 61 PUSH2 0x014e 013F 61 PUSH2 0x0149 0142 36 CALLDATASIZE 0143 60 PUSH1 0x04 0145 61 PUSH2 0x1e7a 0148 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @013C stack[0] = 0x014e // @013F stack[1] = 0x0149 // @0142 stack[2] = msg.data.length // @0143 stack[3] = 0x04 // } // Block ends with call to 0x1e7a, returns to 0x0149 label_0149: // Incoming return from call to 0x1E7A at 0x0148 0149 5B JUMPDEST 014A 61 PUSH2 0x030f 014D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x030f label_014E: // Incoming return from call to 0x0149 at 0x0148 // Incoming jump from 0x026A // Incoming jump from 0x01AB // Incoming jump from 0x030E // Inputs[4] // { // @0151 memory[0x40:0x60] // @0152 stack[-1] // @015B memory[0x40:0x60] // @0160 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 014E 5B JUMPDEST 014F 60 PUSH1 0x40 0151 51 MLOAD 0152 90 SWAP1 0153 81 DUP2 0154 52 MSTORE 0155 60 PUSH1 0x20 0157 01 ADD 0158 5B JUMPDEST 0159 60 PUSH1 0x40 015B 51 MLOAD 015C 80 DUP1 015D 91 SWAP2 015E 03 SUB 015F 90 SWAP1 0160 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0154 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0160 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0161: // Incoming jump from 0x0114, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0168 msg.data.length } 0161 5B JUMPDEST 0162 61 PUSH2 0x0174 0165 61 PUSH2 0x016f 0168 36 CALLDATASIZE 0169 60 PUSH1 0x04 016B 61 PUSH2 0x1fea 016E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0162 stack[0] = 0x0174 // @0165 stack[1] = 0x016f // @0168 stack[2] = msg.data.length // @0169 stack[3] = 0x04 // } // Block ends with call to 0x1fea, returns to 0x016F label_016F: // Incoming return from call to 0x1FEA at 0x016E 016F 5B JUMPDEST 0170 61 PUSH2 0x03a6 0173 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03a6 label_0174: // Incoming return from call to 0x016F at 0x016E // Incoming return from call to 0x02B2 at 0x02B1 // Inputs[2] // { // @0177 memory[0x40:0x60] // @0178 stack[-1] // } 0174 5B JUMPDEST 0175 60 PUSH1 0x40 0177 51 MLOAD 0178 90 SWAP1 0179 15 ISZERO 017A 15 ISZERO 017B 81 DUP2 017C 52 MSTORE 017D 60 PUSH1 0x20 017F 01 ADD 0180 61 PUSH2 0x0158 0183 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @017C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @017F stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0158 label_0184: // Incoming jump from 0x011F, if 0x0e89341c == stack[-1] // Inputs[1] { @018B msg.data.length } 0184 5B JUMPDEST 0185 61 PUSH2 0x0197 0188 61 PUSH2 0x0192 018B 36 CALLDATASIZE 018C 60 PUSH1 0x04 018E 61 PUSH2 0x208f 0191 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0185 stack[0] = 0x0197 // @0188 stack[1] = 0x0192 // @018B stack[2] = msg.data.length // @018C stack[3] = 0x04 // } // Block ends with call to 0x208f, returns to 0x0192 label_0192: // Incoming return from call to 0x208F at 0x0191 0192 5B JUMPDEST 0193 61 PUSH2 0x03f8 0196 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x03f8 label_0197: // Incoming return from call to 0x0192 at 0x0191 // Incoming return from call to 0x0192 at 0x0191 // Inputs[2] // { // @019A memory[0x40:0x60] // @019E stack[-1] // } 0197 5B JUMPDEST 0198 60 PUSH1 0x40 019A 51 MLOAD 019B 61 PUSH2 0x0158 019E 91 SWAP2 019F 90 SWAP1 01A0 61 PUSH2 0x231b 01A3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @019E stack[-1] = 0x0158 // @019F stack[1] = memory[0x40:0x60] // @019F stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x231b label_01A4: // Incoming jump from 0x012A, if 0x24b3b58b == stack[-1] 01A4 5B JUMPDEST 01A5 61 PUSH2 0x014e 01A8 60 PUSH1 0x45 01AA 81 DUP2 01AB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @01A5 stack[0] = 0x014e // @01A8 stack[1] = 0x45 // } // Block ends with unconditional jump to 0x014e label_01AC: // Incoming jump from 0x0135, if 0x28844ee3 == stack[-1] // Inputs[1] { @01B3 msg.data.length } 01AC 5B JUMPDEST 01AD 61 PUSH2 0x01bf 01B0 61 PUSH2 0x01ba 01B3 36 CALLDATASIZE 01B4 60 PUSH1 0x04 01B6 61 PUSH2 0x1ea3 01B9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01AD stack[0] = 0x01bf // @01B0 stack[1] = 0x01ba // @01B3 stack[2] = msg.data.length // @01B4 stack[3] = 0x04 // } // Block ends with call to 0x1ea3, returns to 0x01BA label_01BA: // Incoming return from call to 0x1EA3 at 0x01B9 01BA 5B JUMPDEST 01BB 61 PUSH2 0x0530 01BE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0530 label_01BF: // Incoming return from call to 0x024B at 0x024A // Incoming return from call to 0x0820 at 0x020E // Incoming return from call to 0x0301 at 0x0300 // Incoming return from call to 0x01BA at 0x01B9 // Incoming return from call to 0x028C at 0x028B // Incoming return from call to 0x025E at 0x025D 01BF 5B JUMPDEST 01C0 00 *STOP // Stack delta = +0 // Outputs[1] { @01C0 stop(); } // Block terminates label_01C1: // Incoming jump from 0x00CE, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @01C8 msg.data.length } 01C1 5B JUMPDEST 01C2 61 PUSH2 0x01bf 01C5 61 PUSH2 0x01cf 01C8 36 CALLDATASIZE 01C9 60 PUSH1 0x04 01CB 61 PUSH2 0x1d37 01CE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01C2 stack[0] = 0x01bf // @01C5 stack[1] = 0x01cf // @01C8 stack[2] = msg.data.length // @01C9 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1d37 01CF 5B JUMPDEST 01D0 61 PUSH2 0x05f1 01D3 56 *JUMP label_01D4: // Incoming jump from 0x00D9, if 0x4e1273f4 == stack[-1] // Inputs[1] { @01DB msg.data.length } 01D4 5B JUMPDEST 01D5 61 PUSH2 0x01e7 01D8 61 PUSH2 0x01e2 01DB 36 CALLDATASIZE 01DC 60 PUSH1 0x04 01DE 61 PUSH2 0x1ed5 01E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01D5 stack[0] = 0x01e7 // @01D8 stack[1] = 0x01e2 // @01DB stack[2] = msg.data.length // @01DC stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1ed5 01E2 5B JUMPDEST 01E3 61 PUSH2 0x0688 01E6 56 *JUMP 01E7 5B JUMPDEST 01E8 60 PUSH1 0x40 01EA 51 MLOAD 01EB 61 PUSH2 0x0158 01EE 91 SWAP2 01EF 90 SWAP1 01F0 61 PUSH2 0x22da 01F3 56 *JUMP label_01F4: // Incoming jump from 0x00E4, if 0x55f804b3 == stack[-1] // Inputs[1] { @01FB msg.data.length } 01F4 5B JUMPDEST 01F5 61 PUSH2 0x01bf 01F8 61 PUSH2 0x0202 01FB 36 CALLDATASIZE 01FC 60 PUSH1 0x04 01FE 61 PUSH2 0x2022 0201 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01F5 stack[0] = 0x01bf // @01F8 stack[1] = 0x0202 // @01FB stack[2] = msg.data.length // @01FC stack[3] = 0x04 // } // Block ends with call to 0x2022, returns to 0x0202 label_0202: // Incoming return from call to 0x2022 at 0x0201 0202 5B JUMPDEST 0203 61 PUSH2 0x07ea 0206 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07ea label_0207: // Incoming jump from 0x00EF, if 0x715018a6 == stack[-1] 0207 5B JUMPDEST 0208 61 PUSH2 0x01bf 020B 61 PUSH2 0x0820 020E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0208 stack[0] = 0x01bf } // Block ends with call to 0x0820, returns to 0x01BF label_020F: // Incoming jump from 0x00FA, if 0x8da5cb5b == stack[-1] // Inputs[2] // { // @0212 storage[0x03] // @0215 memory[0x40:0x60] // } 020F 5B JUMPDEST 0210 60 PUSH1 0x03 0212 54 SLOAD 0213 60 PUSH1 0x40 0215 51 MLOAD 0216 60 PUSH1 0x01 0218 60 PUSH1 0x01 021A 60 PUSH1 0xa0 021C 1B SHL 021D 03 SUB 021E 90 SWAP1 021F 91 SWAP2 0220 16 AND 0221 81 DUP2 0222 52 MSTORE 0223 60 PUSH1 0x20 0225 01 ADD 0226 61 PUSH2 0x0158 0229 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0222 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @0225 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0158 label_022A: // Incoming jump from 0x0087, if 0x8e3a7249 == stack[-1] // Inputs[1] { @0231 msg.data.length } 022A 5B JUMPDEST 022B 61 PUSH2 0x01bf 022E 61 PUSH2 0x0238 0231 36 CALLDATASIZE 0232 60 PUSH1 0x04 0234 61 PUSH2 0x2022 0237 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @022B stack[0] = 0x01bf // @022E stack[1] = 0x0238 // @0231 stack[2] = msg.data.length // @0232 stack[3] = 0x04 // } // Block ends with call to 0x2022, returns to 0x0238 label_0238: // Incoming return from call to 0x2022 at 0x0237 0238 5B JUMPDEST 0239 61 PUSH2 0x0856 023C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0856 label_023D: // Incoming jump from 0x0092, if 0xa22cb465 == stack[-1] // Inputs[1] { @0244 msg.data.length } 023D 5B JUMPDEST 023E 61 PUSH2 0x01bf 0241 61 PUSH2 0x024b 0244 36 CALLDATASIZE 0245 60 PUSH1 0x04 0247 61 PUSH2 0x1e40 024A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @023E stack[0] = 0x01bf // @0241 stack[1] = 0x024b // @0244 stack[2] = msg.data.length // @0245 stack[3] = 0x04 // } // Block ends with call to 0x1e40, returns to 0x024B label_024B: // Incoming return from call to 0x1E40 at 0x024A 024B 5B JUMPDEST 024C 61 PUSH2 0x088c 024F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x088c label_0250: // Incoming jump from 0x009D, if 0xa7ecd37e == stack[-1] // Inputs[1] { @0257 msg.data.length } 0250 5B JUMPDEST 0251 61 PUSH2 0x01bf 0254 61 PUSH2 0x025e 0257 36 CALLDATASIZE 0258 60 PUSH1 0x04 025A 61 PUSH2 0x1ce4 025D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0251 stack[0] = 0x01bf // @0254 stack[1] = 0x025e // @0257 stack[2] = msg.data.length // @0258 stack[3] = 0x04 // } // Block ends with call to 0x1ce4, returns to 0x025E label_025E: // Incoming return from call to 0x1CE4 at 0x025D 025E 5B JUMPDEST 025F 61 PUSH2 0x0963 0262 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0963 label_0263: // Incoming jump from 0x00A8, if 0xc124caaa == stack[-1] 0263 5B JUMPDEST 0264 61 PUSH2 0x014e 0267 60 PUSH1 0x01 0269 81 DUP2 026A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0264 stack[0] = 0x014e // @0267 stack[1] = 0x01 // } // Block ends with unconditional jump to 0x014e label_026B: // Incoming jump from 0x00B3, if 0xdd3c6d5f == stack[-1] // Inputs[1] { @0272 msg.data.length } 026B 5B JUMPDEST 026C 61 PUSH2 0x01bf 026F 61 PUSH2 0x0279 0272 36 CALLDATASIZE 0273 60 PUSH1 0x04 0275 61 PUSH2 0x1fa0 0278 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @026C stack[0] = 0x01bf // @026F stack[1] = 0x0279 // @0272 stack[2] = msg.data.length // @0273 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1fa0 0279 5B JUMPDEST 027A 61 PUSH2 0x09af 027D 56 *JUMP label_027E: // Incoming jump from 0x0040, if 0xe61dc9b8 == stack[-1] // Inputs[1] { @0285 msg.data.length } 027E 5B JUMPDEST 027F 61 PUSH2 0x01bf 0282 61 PUSH2 0x028c 0285 36 CALLDATASIZE 0286 60 PUSH1 0x04 0288 61 PUSH2 0x1ce4 028B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @027F stack[0] = 0x01bf // @0282 stack[1] = 0x028c // @0285 stack[2] = msg.data.length // @0286 stack[3] = 0x04 // } // Block ends with call to 0x1ce4, returns to 0x028C label_028C: // Incoming return from call to 0x1CE4 at 0x028B 028C 5B JUMPDEST 028D 61 PUSH2 0x0a09 0290 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a09 label_0291: // Incoming jump from 0x004B, if 0xe8f1868c == stack[-1] // Inputs[1] { @0298 msg.data.length } 0291 5B JUMPDEST 0292 61 PUSH2 0x01bf 0295 61 PUSH2 0x029f 0298 36 CALLDATASIZE 0299 60 PUSH1 0x04 029B 61 PUSH2 0x20a7 029E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0292 stack[0] = 0x01bf // @0295 stack[1] = 0x029f // @0298 stack[2] = msg.data.length // @0299 stack[3] = 0x04 // } // Block ends with call to 0x20a7, returns to 0x029F label_029F: // Incoming return from call to 0x20A7 at 0x029E 029F 5B JUMPDEST 02A0 61 PUSH2 0x0a55 02A3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a55 label_02A4: // Incoming jump from 0x0056, if 0xe985e9c5 == stack[-1] // Inputs[1] { @02AB msg.data.length } 02A4 5B JUMPDEST 02A5 61 PUSH2 0x0174 02A8 61 PUSH2 0x02b2 02AB 36 CALLDATASIZE 02AC 60 PUSH1 0x04 02AE 61 PUSH2 0x1d05 02B1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A5 stack[0] = 0x0174 // @02A8 stack[1] = 0x02b2 // @02AB stack[2] = msg.data.length // @02AC stack[3] = 0x04 // } // Block ends with call to 0x1d05, returns to 0x02B2 label_02B2: // Incoming return from call to 0x1D05 at 0x02B1 // Incoming call from 0x0B6C, returns to 0x0B6D // Inputs[6] // { // @02BB stack[-2] // @02CE memory[0x00:0x40] // @02CF stack[-1] // @02D9 memory[0x00:0x40] // @02DA storage[keccak256(memory[0x00:0x40])] // @02DE stack[-3] // } 02B2 5B JUMPDEST 02B3 60 PUSH1 0x01 02B5 60 PUSH1 0x01 02B7 60 PUSH1 0xa0 02B9 1B SHL 02BA 03 SUB 02BB 91 SWAP2 02BC 82 DUP3 02BD 16 AND 02BE 60 PUSH1 0x00 02C0 90 SWAP1 02C1 81 DUP2 02C2 52 MSTORE 02C3 60 PUSH1 0x01 02C5 60 PUSH1 0x20 02C7 90 SWAP1 02C8 81 DUP2 02C9 52 MSTORE 02CA 60 PUSH1 0x40 02CC 80 DUP1 02CD 83 DUP4 02CE 20 SHA3 02CF 93 SWAP4 02D0 90 SWAP1 02D1 94 SWAP5 02D2 16 AND 02D3 82 DUP3 02D4 52 MSTORE 02D5 91 SWAP2 02D6 90 SWAP1 02D7 91 SWAP2 02D8 52 MSTORE 02D9 20 SHA3 02DA 54 SLOAD 02DB 60 PUSH1 0xff 02DD 16 AND 02DE 90 SWAP1 02DF 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @02C2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @02C9 memory[0x20:0x40] = 0x01 // @02D4 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @02D8 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @02DE stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_02E0: // Incoming jump from 0x0061, if 0xf242432a == stack[-1] // Inputs[1] { @02E7 msg.data.length } 02E0 5B JUMPDEST 02E1 61 PUSH2 0x01bf 02E4 61 PUSH2 0x02ee 02E7 36 CALLDATASIZE 02E8 60 PUSH1 0x04 02EA 61 PUSH2 0x1ddd 02ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E1 stack[0] = 0x01bf // @02E4 stack[1] = 0x02ee // @02E7 stack[2] = msg.data.length // @02E8 stack[3] = 0x04 // } // Block ends with call to 0x1ddd, returns to 0x02EE label_02EE: // Incoming return from call to 0x1DDD at 0x02ED 02EE 5B JUMPDEST 02EF 61 PUSH2 0x0b51 02F2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b51 label_02F3: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @02FA msg.data.length } 02F3 5B JUMPDEST 02F4 61 PUSH2 0x01bf 02F7 61 PUSH2 0x0301 02FA 36 CALLDATASIZE 02FB 60 PUSH1 0x04 02FD 61 PUSH2 0x1ce4 0300 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02F4 stack[0] = 0x01bf // @02F7 stack[1] = 0x0301 // @02FA stack[2] = msg.data.length // @02FB stack[3] = 0x04 // } // Block ends with call to 0x1ce4, returns to 0x0301 label_0301: // Incoming return from call to 0x1CE4 at 0x0300 0301 5B JUMPDEST 0302 61 PUSH2 0x0bd8 0305 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bd8 label_0306: // Incoming jump from 0x0077, if 0xf9132b1b == stack[-1] 0306 5B JUMPDEST 0307 61 PUSH2 0x014e 030A 61 PUSH2 0x01a4 030D 81 DUP2 030E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0307 stack[0] = 0x014e // @030A stack[1] = 0x01a4 // } // Block ends with unconditional jump to 0x014e label_030F: // Incoming jump from 0x014D // Inputs[1] { @031A stack[-2] } 030F 5B JUMPDEST 0310 60 PUSH1 0x00 0312 60 PUSH1 0x01 0314 60 PUSH1 0x01 0316 60 PUSH1 0xa0 0318 1B SHL 0319 03 SUB 031A 83 DUP4 031B 16 AND 031C 61 PUSH2 0x0380 031F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0310 stack[0] = 0x00 } // Block ends with conditional jump to 0x0380, if stack[-2] & (0x01 << 0xa0) - 0x01 label_0320: // Incoming jump from 0x031F, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0322 memory[0x40:0x60] } 0320 60 PUSH1 0x40 0322 51 MLOAD 0323 62 PUSH3 0x461bcd 0327 60 PUSH1 0xe5 0329 1B SHL 032A 81 DUP2 032B 52 MSTORE 032C 60 PUSH1 0x20 032E 60 PUSH1 0x04 0330 82 DUP3 0331 01 ADD 0332 52 MSTORE 0333 60 PUSH1 0x2b 0335 60 PUSH1 0x24 0337 82 DUP3 0338 01 ADD 0339 52 MSTORE 033A 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 035B 60 PUSH1 0x44 035D 82 DUP3 035E 01 ADD 035F 52 MSTORE 0360 6A PUSH11 0x65726f2061646472657373 036C 60 PUSH1 0xa8 036E 1B SHL 036F 60 PUSH1 0x64 0371 82 DUP3 0372 01 ADD 0373 52 MSTORE 0374 60 PUSH1 0x84 0376 01 ADD // Stack delta = +1 // Outputs[6] // { // @032B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0332 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0339 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @035F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @0373 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373 << 0xa8 // @0376 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0377: // Incoming jump from 0x0EA3 // Incoming return from call to 0x232E at 0x17BE // Incoming jump from 0x0BCA // Incoming jump from 0x16A8 // Incoming return from call to 0x23BB at 0x146E // Incoming jump from 0x0AC2 // Incoming return from call to 0x2405 at 0x0849 // Incoming jump from 0x1939 // Incoming jump from 0x05E0 // Incoming jump from 0x16A8 // Incoming return from call to 0x2376 at 0x141D // Incoming return from call to 0x2405 at 0x0813 // Incoming return from call to 0x2482 at 0x134D // Incoming jump from 0x1A2F // Incoming jump from 0x0582 // Incoming return from call to 0x2405 at 0x098C // Incoming jump from 0x18C9 // Incoming jump from 0x08F6 // Incoming jump from 0x19B4 // Incoming jump from 0x0376 // Incoming jump from 0x0458 // Incoming jump from 0x0B19 // Incoming return from call to 0x2405 at 0x087F // Incoming return from call to 0x2405 at 0x0C01 // Incoming jump from 0x0C66 // Incoming jump from 0x0DF6 // Incoming return from call to 0x2405 at 0x0A32 // Inputs[3] // { // @037A memory[0x40:0x60] // @037C stack[-1] // @037F memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0377 5B JUMPDEST 0378 60 PUSH1 0x40 037A 51 MLOAD 037B 80 DUP1 037C 91 SWAP2 037D 03 SUB 037E 90 SWAP1 037F FD *REVERT // Stack delta = -1 // Outputs[1] { @037F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0380: // Incoming jump from 0x031F, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @0384 stack[-2] // @0390 memory[0x00:0x40] // @0399 stack[-3] // @03A2 memory[0x00:0x40] // @03A3 storage[keccak256(memory[0x00:0x40])] // @03A4 stack[-4] // } 0380 5B JUMPDEST 0381 50 POP 0382 60 PUSH1 0x00 0384 90 SWAP1 0385 81 DUP2 0386 52 MSTORE 0387 60 PUSH1 0x20 0389 81 DUP2 038A 81 DUP2 038B 52 MSTORE 038C 60 PUSH1 0x40 038E 80 DUP1 038F 83 DUP4 0390 20 SHA3 0391 60 PUSH1 0x01 0393 60 PUSH1 0x01 0395 60 PUSH1 0xa0 0397 1B SHL 0398 03 SUB 0399 94 SWAP5 039A 90 SWAP1 039B 94 SWAP5 039C 16 AND 039D 83 DUP4 039E 52 MSTORE 039F 92 SWAP3 03A0 90 SWAP1 03A1 52 MSTORE 03A2 20 SHA3 03A3 54 SLOAD 03A4 90 SWAP1 03A5 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0386 memory[0x00:0x20] = stack[-2] // @038B memory[0x20:0x40] = 0x00 // @039E memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @03A1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @03A4 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_03A6: // Incoming jump from 0x0173 // Inputs[1] { @03B2 stack[-1] } 03A6 5B JUMPDEST 03A7 60 PUSH1 0x00 03A9 60 PUSH1 0x01 03AB 60 PUSH1 0x01 03AD 60 PUSH1 0xe0 03AF 1B SHL 03B0 03 SUB 03B1 19 NOT 03B2 82 DUP3 03B3 16 AND 03B4 63 PUSH4 0x6cdb3d13 03B9 60 PUSH1 0xe1 03BB 1B SHL 03BC 14 EQ 03BD 80 DUP1 03BE 61 PUSH2 0x03d7 03C1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @03A7 stack[0] = 0x00 // @03BC stack[1] = 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x03d7, if 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_03C2: // Incoming jump from 0x03C1, if not 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @03CC stack[-3] } 03C2 50 POP 03C3 60 PUSH1 0x01 03C5 60 PUSH1 0x01 03C7 60 PUSH1 0xe0 03C9 1B SHL 03CA 03 SUB 03CB 19 NOT 03CC 82 DUP3 03CD 16 AND 03CE 63 PUSH4 0x03a24d07 03D3 60 PUSH1 0xe2 03D5 1B SHL 03D6 14 EQ 03D7 5B JUMPDEST 03D8 80 DUP1 03D9 61 PUSH2 0x03f2 03DC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @03D6 stack[-1] = 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x03f2, if 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_03DD: // Incoming jump from 0x03DC, if not stack[-1] // Incoming jump from 0x03DC, if not 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[2] // { // @03EF stack[-3] // @03F3 stack[-4] // } 03DD 50 POP 03DE 63 PUSH4 0x01ffc9a7 03E3 60 PUSH1 0xe0 03E5 1B SHL 03E6 60 PUSH1 0x01 03E8 60 PUSH1 0x01 03EA 60 PUSH1 0xe0 03EC 1B SHL 03ED 03 SUB 03EE 19 NOT 03EF 83 DUP4 03F0 16 AND 03F1 14 EQ 03F2 5B JUMPDEST 03F3 92 SWAP3 03F4 91 SWAP2 03F5 50 POP 03F6 50 POP 03F7 56 *JUMP // Stack delta = -3 // Outputs[1] { @03F3 stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to stack[-4] label_03F8: // Incoming jump from 0x0196 // Inputs[3] // { // @03FB stack[-1] // @0406 memory[0x00:0x40] // @0407 storage[keccak256(memory[0x00:0x40])] // } 03F8 5B JUMPDEST 03F9 60 PUSH1 0x00 03FB 81 DUP2 03FC 81 DUP2 03FD 52 MSTORE 03FE 60 PUSH1 0x07 0400 60 PUSH1 0x20 0402 52 MSTORE 0403 60 PUSH1 0x40 0405 90 SWAP1 0406 20 SHA3 0407 54 SLOAD 0408 60 PUSH1 0x60 040A 90 SWAP1 040B 60 PUSH1 0xff 040D 16 AND 040E 61 PUSH2 0x0459 0411 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @03FD memory[0x00:0x20] = stack[-1] // @0402 memory[0x20:0x40] = 0x07 // @040A stack[0] = 0x60 // } // Block ends with conditional jump to 0x0459, if 0xff & storage[keccak256(memory[0x00:0x40])] label_0412: // Incoming jump from 0x0411, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0414 memory[0x40:0x60] } 0412 60 PUSH1 0x40 0414 51 MLOAD 0415 62 PUSH3 0x461bcd 0419 60 PUSH1 0xe5 041B 1B SHL 041C 81 DUP2 041D 52 MSTORE 041E 60 PUSH1 0x20 0420 60 PUSH1 0x04 0422 82 DUP3 0423 01 ADD 0424 52 MSTORE 0425 60 PUSH1 0x1d 0427 60 PUSH1 0x24 0429 82 DUP3 042A 01 ADD 042B 52 MSTORE 042C 7F PUSH32 0x54686973206b6579207479706520646f6573206e6f742065786973742e000000 044D 60 PUSH1 0x44 044F 82 DUP3 0450 01 ADD 0451 52 MSTORE 0452 60 PUSH1 0x64 0454 01 ADD 0455 61 PUSH2 0x0377 0458 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @041D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0424 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @042B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1d // @0451 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x54686973206b6579207479706520646f6573206e6f742065786973742e000000 // @0454 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_0459: // Incoming jump from 0x0411, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @045F storage[0x04] } 0459 5B JUMPDEST 045A 60 PUSH1 0x00 045C 60 PUSH1 0x04 045E 80 DUP1 045F 54 SLOAD 0460 61 PUSH2 0x0468 0463 90 SWAP1 0464 61 PUSH2 0x255a 0467 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @045A stack[0] = 0x00 // @045C stack[1] = 0x04 // @0463 stack[2] = 0x0468 // @0463 stack[3] = storage[0x04] // } // Block ends with call to 0x255a, returns to 0x0468 label_0468: // Incoming return from call to 0x255A at 0x0467 // Inputs[3] // { // @0469 stack[-2] // @0469 stack[-1] // @046B stack[-3] // } 0468 5B JUMPDEST 0469 90 SWAP1 046A 50 POP 046B 11 GT 046C 61 PUSH2 0x04ff 046F 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x04ff, if stack[-1] > stack[-3] label_0470: // Incoming jump from 0x046F, if not stack[-1] > stack[-3] // Inputs[1] { @0473 storage[0x04] } 0470 60 PUSH1 0x04 0472 80 DUP1 0473 54 SLOAD 0474 61 PUSH2 0x047c 0477 90 SWAP1 0478 61 PUSH2 0x255a 047B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0470 stack[0] = 0x04 // @0477 stack[1] = 0x047c // @0477 stack[2] = storage[0x04] // } // Block ends with call to 0x255a, returns to 0x047C label_047C: // Incoming return from call to 0x255A at 0x047B // Inputs[4] // { // @047D stack[-1] // @048C memory[0x40:0x60] // @0494 stack[-2] // @049F storage[stack[-2]] // } 047C 5B JUMPDEST 047D 80 DUP1 047E 60 PUSH1 0x1f 0480 01 ADD 0481 60 PUSH1 0x20 0483 80 DUP1 0484 91 SWAP2 0485 04 DIV 0486 02 MUL 0487 60 PUSH1 0x20 0489 01 ADD 048A 60 PUSH1 0x40 048C 51 MLOAD 048D 90 SWAP1 048E 81 DUP2 048F 01 ADD 0490 60 PUSH1 0x40 0492 52 MSTORE 0493 80 DUP1 0494 92 SWAP3 0495 91 SWAP2 0496 90 SWAP1 0497 81 DUP2 0498 81 DUP2 0499 52 MSTORE 049A 60 PUSH1 0x20 049C 01 ADD 049D 82 DUP3 049E 80 DUP1 049F 54 SLOAD 04A0 61 PUSH2 0x04a8 04A3 90 SWAP1 04A4 61 PUSH2 0x255a 04A7 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0492 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0494 stack[-2] = memory[0x40:0x60] // @0495 stack[-1] = stack[-2] // @0496 stack[0] = stack[-1] // @0499 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @049C stack[1] = 0x20 + memory[0x40:0x60] // @049D stack[2] = stack[-2] // @04A3 stack[4] = storage[stack[-2]] // @04A3 stack[3] = 0x04a8 // } // Block ends with call to 0x255a, returns to 0x04A8 label_04A8: // Incoming return from call to 0x255A at 0x04A7 // Inputs[1] { @04A9 stack[-1] } 04A8 5B JUMPDEST 04A9 80 DUP1 04AA 15 ISZERO 04AB 61 PUSH2 0x04f5 04AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f5, if !stack[-1] label_04AF: // Incoming jump from 0x04AE, if not !stack[-1] // Inputs[1] { @04AF stack[-1] } 04AF 80 DUP1 04B0 60 PUSH1 0x1f 04B2 10 LT 04B3 61 PUSH2 0x04ca 04B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ca, if 0x1f < stack[-1] label_04B7: // Incoming jump from 0x04B6, if not 0x1f < stack[-1] // Inputs[4] // { // @04BB stack[-2] // @04BC storage[stack[-2]] // @04BF stack[-3] // @04C1 stack[-1] // } 04B7 61 PUSH2 0x0100 04BA 80 DUP1 04BB 83 DUP4 04BC 54 SLOAD 04BD 04 DIV 04BE 02 MUL 04BF 83 DUP4 04C0 52 MSTORE 04C1 91 SWAP2 04C2 60 PUSH1 0x20 04C4 01 ADD 04C5 91 SWAP2 04C6 61 PUSH2 0x04f5 04C9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04C0 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @04C5 stack[-1] = stack[-1] // @04C5 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04f5 label_04CA: // Incoming jump from 0x04B6, if 0x1f < stack[-1] // Inputs[5] // { // @04CB stack[-3] // @04CC stack[-1] // @04CE stack[-2] // @04D6 memory[0x00:0x20] // @04DA storage[keccak256(memory[0x00:0x20])] // } 04CA 5B JUMPDEST 04CB 82 DUP3 04CC 01 ADD 04CD 91 SWAP2 04CE 90 SWAP1 04CF 60 PUSH1 0x00 04D1 52 MSTORE 04D2 60 PUSH1 0x20 04D4 60 PUSH1 0x00 04D6 20 SHA3 04D7 90 SWAP1 04D8 5B JUMPDEST 04D9 81 DUP2 04DA 54 SLOAD 04DB 81 DUP2 04DC 52 MSTORE 04DD 90 SWAP1 04DE 60 PUSH1 0x01 04E0 01 ADD 04E1 90 SWAP1 04E2 60 PUSH1 0x20 04E4 01 ADD 04E5 80 DUP1 04E6 83 DUP4 04E7 11 GT 04E8 61 PUSH2 0x04d8 04EB 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @04CD stack[-3] = stack[-3] + stack[-1] // @04D1 memory[0x00:0x20] = stack[-2] // @04DC memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04E1 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04E4 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04d8, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04EC: // Incoming jump from 0x04EB, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x04EB, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @04EC stack[-3] // @04ED stack[-1] // } 04EC 82 DUP3 04ED 90 SWAP1 04EE 03 SUB 04EF 60 PUSH1 0x1f 04F1 16 AND 04F2 82 DUP3 04F3 01 ADD 04F4 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04F4 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04F4 stack[-1] = stack[-3] // } // Block continues label_04F5: // Incoming jump from 0x04AE, if !stack[-1] // Incoming jump from 0x04C9 // Incoming jump from 0x04F4 04F5 5B JUMPDEST 04F6 50 POP 04F7 50 POP 04F8 50 POP 04F9 50 POP 04FA 50 POP 04FB 61 PUSH2 0x03f2 04FE 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to 0x03f2 label_04FF: // Incoming jump from 0x046F, if stack[-1] > stack[-3] // Inputs[1] { @0505 stack[-2] } 04FF 5B JUMPDEST 0500 60 PUSH1 0x04 0502 61 PUSH2 0x050a 0505 83 DUP4 0506 61 PUSH2 0x0c73 0509 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0500 stack[0] = 0x04 // @0502 stack[1] = 0x050a // @0505 stack[2] = stack[-2] // } // Block ends with call to 0x0c73, returns to 0x050A label_050A: // Incoming return from call to 0x0C73 at 0x0509 // Inputs[3] // { // @050D memory[0x40:0x60] // @0514 stack[-2] // @0515 stack[-1] // } 050A 5B JUMPDEST 050B 60 PUSH1 0x40 050D 51 MLOAD 050E 60 PUSH1 0x20 0510 01 ADD 0511 61 PUSH2 0x051b 0514 92 SWAP3 0515 91 SWAP2 0516 90 SWAP1 0517 61 PUSH2 0x2212 051A 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0514 stack[-2] = 0x051b // @0515 stack[-1] = stack[-2] // @0516 stack[1] = 0x20 + memory[0x40:0x60] // @0516 stack[0] = stack[-1] // } // Block ends with call to 0x2212, returns to 0x051B label_051B: // Incoming return from call to 0x2212 at 0x051A // Inputs[4] // { // @051E memory[0x40:0x60] // @0522 stack[-1] // @052B stack[-4] // @052C stack[-3] // } 051B 5B JUMPDEST 051C 60 PUSH1 0x40 051E 51 MLOAD 051F 60 PUSH1 0x20 0521 81 DUP2 0522 83 DUP4 0523 03 SUB 0524 03 SUB 0525 81 DUP2 0526 52 MSTORE 0527 90 SWAP1 0528 60 PUSH1 0x40 052A 52 MSTORE 052B 92 SWAP3 052C 91 SWAP2 052D 50 POP 052E 50 POP 052F 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @0526 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @052A memory[0x40:0x60] = stack[-1] // @052B stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_0530: // Incoming jump from 0x01BE // Inputs[2] // { // @0533 storage[0x05] // @053D msg.sender // } 0530 5B JUMPDEST 0531 60 PUSH1 0x05 0533 54 SLOAD 0534 60 PUSH1 0x01 0536 60 PUSH1 0x01 0538 60 PUSH1 0xa0 053A 1B SHL 053B 03 SUB 053C 16 AND 053D 33 CALLER 053E 14 EQ 053F 61 PUSH2 0x0583 0542 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0583, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] label_0543: // Incoming jump from 0x0542, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[1] { @0545 memory[0x40:0x60] } 0543 60 PUSH1 0x40 0545 51 MLOAD 0546 62 PUSH3 0x461bcd 054A 60 PUSH1 0xe5 054C 1B SHL 054D 81 DUP2 054E 52 MSTORE 054F 60 PUSH1 0x20 0551 60 PUSH1 0x04 0553 82 DUP3 0554 01 ADD 0555 52 MSTORE 0556 60 PUSH1 0x16 0558 60 PUSH1 0x24 055A 82 DUP3 055B 01 ADD 055C 52 MSTORE 055D 75 PUSH22 0x496e76616c6964206275726e65722061646472657373 0574 60 PUSH1 0x50 0576 1B SHL 0577 60 PUSH1 0x44 0579 82 DUP3 057A 01 ADD 057B 52 MSTORE 057C 60 PUSH1 0x64 057E 01 ADD 057F 61 PUSH2 0x0377 0582 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @054E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0555 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @055C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x16 // @057B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e76616c6964206275726e65722061646472657373 << 0x50 // @057E stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_0583: // Incoming jump from 0x0542, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x05] // Inputs[3] // { // @0586 stack[-2] // @0591 memory[0x00:0x40] // @0592 storage[keccak256(memory[0x00:0x40])] // } 0583 5B JUMPDEST 0584 60 PUSH1 0x00 0586 82 DUP3 0587 81 DUP2 0588 52 MSTORE 0589 60 PUSH1 0x07 058B 60 PUSH1 0x20 058D 52 MSTORE 058E 60 PUSH1 0x40 0590 90 SWAP1 0591 20 SHA3 0592 54 SLOAD 0593 60 PUSH1 0xff 0595 16 AND 0596 61 PUSH2 0x05e1 0599 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0588 memory[0x00:0x20] = stack[-2] // @058D memory[0x20:0x40] = 0x07 // } // Block ends with conditional jump to 0x05e1, if 0xff & storage[keccak256(memory[0x00:0x40])] label_059A: // Incoming jump from 0x0599, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @059C memory[0x40:0x60] } 059A 60 PUSH1 0x40 059C 51 MLOAD 059D 62 PUSH3 0x461bcd 05A1 60 PUSH1 0xe5 05A3 1B SHL 05A4 81 DUP2 05A5 52 MSTORE 05A6 60 PUSH1 0x20 05A8 60 PUSH1 0x04 05AA 82 DUP3 05AB 01 ADD 05AC 52 MSTORE 05AD 60 PUSH1 0x1e 05AF 60 PUSH1 0x24 05B1 82 DUP3 05B2 01 ADD 05B3 52 MSTORE 05B4 7F PUSH32 0x596f75206d6179206e6f74206275726e2074686973206b657920747970650000 05D5 60 PUSH1 0x44 05D7 82 DUP3 05D8 01 ADD 05D9 52 MSTORE 05DA 60 PUSH1 0x64 05DC 01 ADD 05DD 61 PUSH2 0x0377 05E0 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @05A5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05AC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @05B3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @05D9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x596f75206d6179206e6f74206275726e2074686973206b657920747970650000 // @05DC stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_05E1: // Incoming jump from 0x0599, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @05E5 stack[-3] // @05E6 stack[-2] // @05E7 stack[-1] // } 05E1 5B JUMPDEST 05E2 61 PUSH2 0x05ec 05E5 83 DUP4 05E6 83 DUP4 05E7 83 DUP4 05E8 61 PUSH2 0x0d95 05EB 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05E2 stack[0] = 0x05ec // @05E5 stack[1] = stack[-3] // @05E6 stack[2] = stack[-2] // @05E7 stack[3] = stack[-1] // } // Block ends with call to 0x0d95, returns to 0x05EC label_05EC: // Incoming return from call to 0x0D95 at 0x05EB // Inputs[1] { @05F0 stack[-4] } 05EC 5B JUMPDEST 05ED 50 POP 05EE 50 POP 05EF 50 POP 05F0 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] 05F1 5B JUMPDEST 05F2 60 PUSH1 0x01 05F4 60 PUSH1 0x01 05F6 60 PUSH1 0xa0 05F8 1B SHL 05F9 03 SUB 05FA 85 DUP6 05FB 16 AND 05FC 33 CALLER 05FD 14 EQ 05FE 80 DUP1 05FF 61 PUSH2 0x060d 0602 57 *JUMPI 0603 50 POP 0604 61 PUSH2 0x060d 0607 85 DUP6 0608 33 CALLER 0609 61 PUSH2 0x02b2 060C 56 *JUMP 060D 5B JUMPDEST 060E 61 PUSH2 0x0674 0611 57 *JUMPI 0612 60 PUSH1 0x40 0614 51 MLOAD 0615 62 PUSH3 0x461bcd 0619 60 PUSH1 0xe5 061B 1B SHL 061C 81 DUP2 061D 52 MSTORE 061E 60 PUSH1 0x20 0620 60 PUSH1 0x04 0622 82 DUP3 0623 01 ADD 0624 52 MSTORE 0625 60 PUSH1 0x32 0627 60 PUSH1 0x24 0629 82 DUP3 062A 01 ADD 062B 52 MSTORE 062C 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 064D 60 PUSH1 0x44 064F 82 DUP3 0650 01 ADD 0651 52 MSTORE 0652 71 PUSH18 0x1bdddb995c881b9bdc88185c1c1c9bdd9959 0665 60 PUSH1 0x72 0667 1B SHL 0668 60 PUSH1 0x64 066A 82 DUP3 066B 01 ADD 066C 52 MSTORE 066D 60 PUSH1 0x84 066F 01 ADD 0670 61 PUSH2 0x0377 0673 56 *JUMP 0674 5B JUMPDEST 0675 61 PUSH2 0x0681 0678 85 DUP6 0679 85 DUP6 067A 85 DUP6 067B 85 DUP6 067C 85 DUP6 067D 61 PUSH2 0x0f0f 0680 56 *JUMP label_0681: // Incoming return from call to 0x16F5 at 0x13F7 // Incoming return from call to 0x1515 at 0x1367 // Incoming return from call to 0x13F8 at 0x0BD7 // Inputs[1] { @0687 stack[-6] } 0681 5B JUMPDEST 0682 50 POP 0683 50 POP 0684 50 POP 0685 50 POP 0686 50 POP 0687 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] 0688 5B JUMPDEST 0689 60 PUSH1 0x60 068B 81 DUP2 068C 51 MLOAD 068D 83 DUP4 068E 51 MLOAD 068F 14 EQ 0690 61 PUSH2 0x06ed 0693 57 *JUMPI 0694 60 PUSH1 0x40 0696 51 MLOAD 0697 62 PUSH3 0x461bcd 069B 60 PUSH1 0xe5 069D 1B SHL 069E 81 DUP2 069F 52 MSTORE 06A0 60 PUSH1 0x20 06A2 60 PUSH1 0x04 06A4 82 DUP3 06A5 01 ADD 06A6 52 MSTORE 06A7 60 PUSH1 0x29 06A9 60 PUSH1 0x24 06AB 82 DUP3 06AC 01 ADD 06AD 52 MSTORE 06AE 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 06CF 60 PUSH1 0x44 06D1 82 DUP3 06D2 01 ADD 06D3 52 MSTORE 06D4 68 PUSH9 0x040dad2e6dac2e8c6d 06DE 60 PUSH1 0xbb 06E0 1B SHL 06E1 60 PUSH1 0x64 06E3 82 DUP3 06E4 01 ADD 06E5 52 MSTORE 06E6 60 PUSH1 0x84 06E8 01 ADD 06E9 61 PUSH2 0x0377 06EC 56 *JUMP 06ED 5B JUMPDEST 06EE 60 PUSH1 0x00 06F0 83 DUP4 06F1 51 MLOAD 06F2 67 PUSH8 0xffffffffffffffff 06FB 81 DUP2 06FC 11 GT 06FD 15 ISZERO 06FE 61 PUSH2 0x0717 0701 57 *JUMPI 0702 63 PUSH4 0x4e487b71 0707 60 PUSH1 0xe0 0709 1B SHL 070A 60 PUSH1 0x00 070C 52 MSTORE 070D 60 PUSH1 0x41 070F 60 PUSH1 0x04 0711 52 MSTORE 0712 60 PUSH1 0x24 0714 60 PUSH1 0x00 0716 FD *REVERT 0717 5B JUMPDEST 0718 60 PUSH1 0x40 071A 51 MLOAD 071B 90 SWAP1 071C 80 DUP1 071D 82 DUP3 071E 52 MSTORE 071F 80 DUP1 0720 60 PUSH1 0x20 0722 02 MUL 0723 60 PUSH1 0x20 0725 01 ADD 0726 82 DUP3 0727 01 ADD 0728 60 PUSH1 0x40 072A 52 MSTORE 072B 80 DUP1 072C 15 ISZERO 072D 61 PUSH2 0x0740 0730 57 *JUMPI 0731 81 DUP2 0732 60 PUSH1 0x20 0734 01 ADD 0735 60 PUSH1 0x20 0737 82 DUP3 0738 02 MUL 0739 80 DUP1 073A 36 CALLDATASIZE 073B 83 DUP4 073C 37 CALLDATACOPY 073D 01 ADD 073E 90 SWAP1 073F 50 POP 0740 5B JUMPDEST 0741 50 POP 0742 90 SWAP1 0743 50 POP 0744 60 PUSH1 0x00 0746 5B JUMPDEST 0747 84 DUP5 0748 51 MLOAD 0749 81 DUP2 074A 10 LT 074B 15 ISZERO 074C 61 PUSH2 0x07e2 074F 57 *JUMPI 0750 61 PUSH2 0x07a7 0753 85 DUP6 0754 82 DUP3 0755 81 DUP2 0756 51 MLOAD 0757 81 DUP2 0758 10 LT 0759 61 PUSH2 0x0772 075C 57 *JUMPI 075D 63 PUSH4 0x4e487b71 0762 60 PUSH1 0xe0 0764 1B SHL 0765 60 PUSH1 0x00 0767 52 MSTORE 0768 60 PUSH1 0x32 076A 60 PUSH1 0x04 076C 52 MSTORE 076D 60 PUSH1 0x24 076F 60 PUSH1 0x00 0771 FD *REVERT 0772 5B JUMPDEST 0773 60 PUSH1 0x20 0775 02 MUL 0776 60 PUSH1 0x20 0778 01 ADD 0779 01 ADD 077A 51 MLOAD 077B 85 DUP6 077C 83 DUP4 077D 81 DUP2 077E 51 MLOAD 077F 81 DUP2 0780 10 LT 0781 61 PUSH2 0x079a 0784 57 *JUMPI 0785 63 PUSH4 0x4e487b71 078A 60 PUSH1 0xe0 078C 1B SHL 078D 60 PUSH1 0x00 078F 52 MSTORE 0790 60 PUSH1 0x32 0792 60 PUSH1 0x04 0794 52 MSTORE 0795 60 PUSH1 0x24 0797 60 PUSH1 0x00 0799 FD *REVERT 079A 5B JUMPDEST 079B 60 PUSH1 0x20 079D 02 MUL 079E 60 PUSH1 0x20 07A0 01 ADD 07A1 01 ADD 07A2 51 MLOAD 07A3 61 PUSH2 0x030f 07A6 56 *JUMP 07A7 5B JUMPDEST 07A8 82 DUP3 07A9 82 DUP3 07AA 81 DUP2 07AB 51 MLOAD 07AC 81 DUP2 07AD 10 LT 07AE 61 PUSH2 0x07c7 07B1 57 *JUMPI 07B2 63 PUSH4 0x4e487b71 07B7 60 PUSH1 0xe0 07B9 1B SHL 07BA 60 PUSH1 0x00 07BC 52 MSTORE 07BD 60 PUSH1 0x32 07BF 60 PUSH1 0x04 07C1 52 MSTORE 07C2 60 PUSH1 0x24 07C4 60 PUSH1 0x00 07C6 FD *REVERT 07C7 5B JUMPDEST 07C8 60 PUSH1 0x20 07CA 90 SWAP1 07CB 81 DUP2 07CC 02 MUL 07CD 91 SWAP2 07CE 90 SWAP1 07CF 91 SWAP2 07D0 01 ADD 07D1 01 ADD 07D2 52 MSTORE 07D3 61 PUSH2 0x07db 07D6 81 DUP2 07D7 61 PUSH2 0x25c2 07DA 56 *JUMP 07DB 5B JUMPDEST 07DC 90 SWAP1 07DD 50 POP 07DE 61 PUSH2 0x0746 07E1 56 *JUMP label_07E2: // Incoming return from call to 0x182F at 0x16F4 // Inputs[3] // { // @07E4 stack[-6] // @07E4 stack[-2] // @07E5 stack[-5] // } 07E2 5B JUMPDEST 07E3 50 POP 07E4 93 SWAP4 07E5 92 SWAP3 07E6 50 POP 07E7 50 POP 07E8 50 POP 07E9 56 *JUMP // Stack delta = -5 // Outputs[1] { @07E4 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_07EA: // Incoming jump from 0x0206 // Inputs[2] // { // @07ED storage[0x03] // @07F7 msg.sender // } 07EA 5B JUMPDEST 07EB 60 PUSH1 0x03 07ED 54 SLOAD 07EE 60 PUSH1 0x01 07F0 60 PUSH1 0x01 07F2 60 PUSH1 0xa0 07F4 1B SHL 07F5 03 SUB 07F6 16 AND 07F7 33 CALLER 07F8 14 EQ 07F9 61 PUSH2 0x0814 07FC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0814, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_07FD: // Incoming jump from 0x07FC, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @07FF memory[0x40:0x60] } 07FD 60 PUSH1 0x40 07FF 51 MLOAD 0800 62 PUSH3 0x461bcd 0804 60 PUSH1 0xe5 0806 1B SHL 0807 81 DUP2 0808 52 MSTORE 0809 60 PUSH1 0x04 080B 01 ADD 080C 61 PUSH2 0x0377 080F 90 SWAP1 0810 61 PUSH2 0x2405 0813 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0808 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @080F stack[0] = 0x0377 // @080F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2405, returns to 0x0377 label_0814: // Incoming jump from 0x07FC, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[2] // { // @081A stack[-2] // @081B stack[-1] // } 0814 5B JUMPDEST 0815 61 PUSH2 0x05ec 0818 60 PUSH1 0x04 081A 83 DUP4 081B 83 DUP4 081C 61 PUSH2 0x1b4c 081F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0815 stack[0] = 0x05ec // @0818 stack[1] = 0x04 // @081A stack[2] = stack[-2] // @081B stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1b4c label_0820: // Incoming call from 0x020E, returns to 0x01BF // Inputs[2] // { // @0823 storage[0x03] // @082D msg.sender // } 0820 5B JUMPDEST 0821 60 PUSH1 0x03 0823 54 SLOAD 0824 60 PUSH1 0x01 0826 60 PUSH1 0x01 0828 60 PUSH1 0xa0 082A 1B SHL 082B 03 SUB 082C 16 AND 082D 33 CALLER 082E 14 EQ 082F 61 PUSH2 0x084a 0832 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x084a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0833: // Incoming jump from 0x0832, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0835 memory[0x40:0x60] } 0833 60 PUSH1 0x40 0835 51 MLOAD 0836 62 PUSH3 0x461bcd 083A 60 PUSH1 0xe5 083C 1B SHL 083D 81 DUP2 083E 52 MSTORE 083F 60 PUSH1 0x04 0841 01 ADD 0842 61 PUSH2 0x0377 0845 90 SWAP1 0846 61 PUSH2 0x2405 0849 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @083E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0845 stack[0] = 0x0377 // @0845 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2405, returns to 0x0377 label_084A: // Incoming jump from 0x0832, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] 084A 5B JUMPDEST 084B 61 PUSH2 0x0854 084E 60 PUSH1 0x00 0850 61 PUSH2 0x10c7 0853 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @084B stack[0] = 0x0854 // @084E stack[1] = 0x00 // } // Block ends with call to 0x10c7, returns to 0x0854 label_0854: // Incoming return from call to 0x10C7 at 0x0853 // Inputs[1] { @0855 stack[-1] } 0854 5B JUMPDEST 0855 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0856: // Incoming jump from 0x023C // Inputs[2] // { // @0859 storage[0x03] // @0863 msg.sender // } 0856 5B JUMPDEST 0857 60 PUSH1 0x03 0859 54 SLOAD 085A 60 PUSH1 0x01 085C 60 PUSH1 0x01 085E 60 PUSH1 0xa0 0860 1B SHL 0861 03 SUB 0862 16 AND 0863 33 CALLER 0864 14 EQ 0865 61 PUSH2 0x0880 0868 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0880, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0869: // Incoming jump from 0x0868, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @086B memory[0x40:0x60] } 0869 60 PUSH1 0x40 086B 51 MLOAD 086C 62 PUSH3 0x461bcd 0870 60 PUSH1 0xe5 0872 1B SHL 0873 81 DUP2 0874 52 MSTORE 0875 60 PUSH1 0x04 0877 01 ADD 0878 61 PUSH2 0x0377 087B 90 SWAP1 087C 61 PUSH2 0x2405 087F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0874 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @087B stack[0] = 0x0377 // @087B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2405, returns to 0x0377 label_0880: // Incoming jump from 0x0868, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[2] // { // @0886 stack[-2] // @0887 stack[-1] // } 0880 5B JUMPDEST 0881 61 PUSH2 0x05ec 0884 60 PUSH1 0x08 0886 83 DUP4 0887 83 DUP4 0888 61 PUSH2 0x1b4c 088B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0881 stack[0] = 0x05ec // @0884 stack[1] = 0x08 // @0886 stack[2] = stack[-2] // @0887 stack[3] = stack[-1] // } // Block ends with unconditional jump to 0x1b4c label_088C: // Incoming jump from 0x024F // Inputs[2] // { // @088D msg.sender // @0896 stack[-2] // } 088C 5B JUMPDEST 088D 33 CALLER 088E 60 PUSH1 0x01 0890 60 PUSH1 0x01 0892 60 PUSH1 0xa0 0894 1B SHL 0895 03 SUB 0896 83 DUP4 0897 16 AND 0898 14 EQ 0899 15 ISZERO 089A 61 PUSH2 0x08f7 089D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08f7, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) label_089E: // Incoming jump from 0x089D, if not !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[1] { @08A0 memory[0x40:0x60] } 089E 60 PUSH1 0x40 08A0 51 MLOAD 08A1 62 PUSH3 0x461bcd 08A5 60 PUSH1 0xe5 08A7 1B SHL 08A8 81 DUP2 08A9 52 MSTORE 08AA 60 PUSH1 0x20 08AC 60 PUSH1 0x04 08AE 82 DUP3 08AF 01 ADD 08B0 52 MSTORE 08B1 60 PUSH1 0x29 08B3 60 PUSH1 0x24 08B5 82 DUP3 08B6 01 ADD 08B7 52 MSTORE 08B8 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 08D9 60 PUSH1 0x44 08DB 82 DUP3 08DC 01 ADD 08DD 52 MSTORE 08DE 68 PUSH9 0x103337b91039b2b633 08E8 60 PUSH1 0xb9 08EA 1B SHL 08EB 60 PUSH1 0x64 08ED 82 DUP3 08EE 01 ADD 08EF 52 MSTORE 08F0 60 PUSH1 0x84 08F2 01 ADD 08F3 61 PUSH2 0x0377 08F6 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @08A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08B0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @08B7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @08DD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @08EF memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103337b91039b2b633 << 0xb9 // @08F2 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_08F7: // Incoming jump from 0x089D, if !(stack[-2] & (0x01 << 0xa0) - 0x01 == msg.sender) // Inputs[10] // { // @08F8 msg.sender // @0909 memory[0x00:0x40] // @0912 stack[-2] // @091D memory[0x00:0x40] // @091F storage[keccak256(memory[0x00:0x40])] // @0924 stack[-1] // @092E memory[0x40:0x60] // @095A memory[0x40:0x60] // @095F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0962 stack[-3] // } 08F7 5B JUMPDEST 08F8 33 CALLER 08F9 60 PUSH1 0x00 08FB 81 DUP2 08FC 81 DUP2 08FD 52 MSTORE 08FE 60 PUSH1 0x01 0900 60 PUSH1 0x20 0902 90 SWAP1 0903 81 DUP2 0904 52 MSTORE 0905 60 PUSH1 0x40 0907 80 DUP1 0908 83 DUP4 0909 20 SHA3 090A 60 PUSH1 0x01 090C 60 PUSH1 0x01 090E 60 PUSH1 0xa0 0910 1B SHL 0911 03 SUB 0912 87 DUP8 0913 16 AND 0914 80 DUP1 0915 85 DUP6 0916 52 MSTORE 0917 90 SWAP1 0918 83 DUP4 0919 52 MSTORE 091A 92 SWAP3 091B 81 DUP2 091C 90 SWAP1 091D 20 SHA3 091E 80 DUP1 091F 54 SLOAD 0920 60 PUSH1 0xff 0922 19 NOT 0923 16 AND 0924 86 DUP7 0925 15 ISZERO 0926 15 ISZERO 0927 90 SWAP1 0928 81 DUP2 0929 17 OR 092A 90 SWAP1 092B 91 SWAP2 092C 55 SSTORE 092D 90 SWAP1 092E 51 MLOAD 092F 90 SWAP1 0930 81 DUP2 0931 52 MSTORE 0932 91 SWAP2 0933 92 SWAP3 0934 91 SWAP2 0935 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0956 91 SWAP2 0957 01 ADD 0958 60 PUSH1 0x40 095A 51 MLOAD 095B 80 DUP1 095C 91 SWAP2 095D 03 SUB 095E 90 SWAP1 095F A3 LOG3 0960 50 POP 0961 50 POP 0962 56 *JUMP // Stack delta = -3 // Outputs[7] // { // @08FD memory[0x00:0x20] = msg.sender // @0904 memory[0x20:0x40] = 0x01 // @0916 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0919 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @092C storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0931 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @095F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, msg.sender, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-3] label_0963: // Incoming jump from 0x0262 // Inputs[2] // { // @0966 storage[0x03] // @0970 msg.sender // } 0963 5B JUMPDEST 0964 60 PUSH1 0x03 0966 54 SLOAD 0967 60 PUSH1 0x01 0969 60 PUSH1 0x01 096B 60 PUSH1 0xa0 096D 1B SHL 096E 03 SUB 096F 16 AND 0970 33 CALLER 0971 14 EQ 0972 61 PUSH2 0x098d 0975 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x098d, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0976: // Incoming jump from 0x0975, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0978 memory[0x40:0x60] } 0976 60 PUSH1 0x40 0978 51 MLOAD 0979 62 PUSH3 0x461bcd 097D 60 PUSH1 0xe5 097F 1B SHL 0980 81 DUP2 0981 52 MSTORE 0982 60 PUSH1 0x04 0984 01 ADD 0985 61 PUSH2 0x0377 0988 90 SWAP1 0989 61 PUSH2 0x2405 098C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0981 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0988 stack[0] = 0x0377 // @0988 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2405, returns to 0x0377 label_098D: // Incoming jump from 0x0975, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @0991 storage[0x09] // @09A4 stack[-1] // @09AE stack[-2] // } 098D 5B JUMPDEST 098E 60 PUSH1 0x09 0990 80 DUP1 0991 54 SLOAD 0992 60 PUSH1 0x01 0994 60 PUSH1 0x01 0996 60 PUSH1 0xa0 0998 1B SHL 0999 03 SUB 099A 19 NOT 099B 16 AND 099C 60 PUSH1 0x01 099E 60 PUSH1 0x01 09A0 60 PUSH1 0xa0 09A2 1B SHL 09A3 03 SUB 09A4 92 SWAP3 09A5 90 SWAP1 09A6 92 SWAP3 09A7 16 AND 09A8 91 SWAP2 09A9 90 SWAP1 09AA 91 SWAP2 09AB 17 OR 09AC 90 SWAP1 09AD 55 SSTORE 09AE 56 *JUMP // Stack delta = -2 // Outputs[1] { @09AD storage[0x09] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x09]) } // Block ends with unconditional jump to stack[-2] 09AF 5B JUMPDEST 09B0 60 PUSH1 0x03 09B2 54 SLOAD 09B3 60 PUSH1 0x01 09B5 60 PUSH1 0x01 09B7 60 PUSH1 0xa0 09B9 1B SHL 09BA 03 SUB 09BB 16 AND 09BC 33 CALLER 09BD 14 EQ 09BE 61 PUSH2 0x09d9 09C1 57 *JUMPI 09C2 60 PUSH1 0x40 09C4 51 MLOAD 09C5 62 PUSH3 0x461bcd 09C9 60 PUSH1 0xe5 09CB 1B SHL 09CC 81 DUP2 09CD 52 MSTORE 09CE 60 PUSH1 0x04 09D0 01 ADD 09D1 61 PUSH2 0x0377 09D4 90 SWAP1 09D5 61 PUSH2 0x2405 09D8 56 *JUMP 09D9 5B JUMPDEST 09DA 61 PUSH2 0x0a05 09DD 61 PUSH2 0x09ee 09E0 60 PUSH1 0x03 09E2 54 SLOAD 09E3 60 PUSH1 0x01 09E5 60 PUSH1 0x01 09E7 60 PUSH1 0xa0 09E9 1B SHL 09EA 03 SUB 09EB 16 AND 09EC 90 SWAP1 09ED 56 *JUMP 09EE 5B JUMPDEST 09EF 83 DUP4 09F0 83 DUP4 09F1 60 PUSH1 0x40 09F3 51 MLOAD 09F4 80 DUP1 09F5 60 PUSH1 0x20 09F7 01 ADD 09F8 60 PUSH1 0x40 09FA 52 MSTORE 09FB 80 DUP1 09FC 60 PUSH1 0x00 09FE 81 DUP2 09FF 52 MSTORE 0A00 50 POP 0A01 61 PUSH2 0x1119 0A04 56 *JUMP 0A05 5B JUMPDEST 0A06 50 POP 0A07 50 POP 0A08 56 *JUMP label_0A09: // Incoming jump from 0x0290 // Inputs[2] // { // @0A0C storage[0x03] // @0A16 msg.sender // } 0A09 5B JUMPDEST 0A0A 60 PUSH1 0x03 0A0C 54 SLOAD 0A0D 60 PUSH1 0x01 0A0F 60 PUSH1 0x01 0A11 60 PUSH1 0xa0 0A13 1B SHL 0A14 03 SUB 0A15 16 AND 0A16 33 CALLER 0A17 14 EQ 0A18 61 PUSH2 0x0a33 0A1B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a33, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0A1C: // Incoming jump from 0x0A1B, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0A1E memory[0x40:0x60] } 0A1C 60 PUSH1 0x40 0A1E 51 MLOAD 0A1F 62 PUSH3 0x461bcd 0A23 60 PUSH1 0xe5 0A25 1B SHL 0A26 81 DUP2 0A27 52 MSTORE 0A28 60 PUSH1 0x04 0A2A 01 ADD 0A2B 61 PUSH2 0x0377 0A2E 90 SWAP1 0A2F 61 PUSH2 0x2405 0A32 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A27 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A2E stack[0] = 0x0377 // @0A2E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2405, returns to 0x0377 label_0A33: // Incoming jump from 0x0A1B, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[3] // { // @0A37 storage[0x05] // @0A4A stack[-1] // @0A54 stack[-2] // } 0A33 5B JUMPDEST 0A34 60 PUSH1 0x05 0A36 80 DUP1 0A37 54 SLOAD 0A38 60 PUSH1 0x01 0A3A 60 PUSH1 0x01 0A3C 60 PUSH1 0xa0 0A3E 1B SHL 0A3F 03 SUB 0A40 19 NOT 0A41 16 AND 0A42 60 PUSH1 0x01 0A44 60 PUSH1 0x01 0A46 60 PUSH1 0xa0 0A48 1B SHL 0A49 03 SUB 0A4A 92 SWAP3 0A4B 90 SWAP1 0A4C 92 SWAP3 0A4D 16 AND 0A4E 91 SWAP2 0A4F 90 SWAP1 0A50 91 SWAP2 0A51 17 OR 0A52 90 SWAP1 0A53 55 SSTORE 0A54 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A53 storage[0x05] = ((0x01 << 0xa0) - 0x01 & stack[-1]) | (~((0x01 << 0xa0) - 0x01) & storage[0x05]) } // Block ends with unconditional jump to stack[-2] label_0A55: // Incoming jump from 0x02A3 // Inputs[3] // { // @0A56 msg.sender // @0A64 memory[0x00:0x40] // @0A65 storage[keccak256(memory[0x00:0x40])] // } 0A55 5B JUMPDEST 0A56 33 CALLER 0A57 60 PUSH1 0x00 0A59 90 SWAP1 0A5A 81 DUP2 0A5B 52 MSTORE 0A5C 60 PUSH1 0x06 0A5E 60 PUSH1 0x20 0A60 52 MSTORE 0A61 60 PUSH1 0x40 0A63 90 SWAP1 0A64 20 SHA3 0A65 54 SLOAD 0A66 60 PUSH1 0xff 0A68 16 AND 0A69 15 ISZERO 0A6A 61 PUSH2 0x0ac3 0A6D 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0A5B memory[0x00:0x20] = msg.sender // @0A60 memory[0x20:0x40] = 0x06 // } // Block ends with conditional jump to 0x0ac3, if !(0xff & storage[keccak256(memory[0x00:0x40])]) label_0A6E: // Incoming jump from 0x0A6D, if not !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[1] { @0A70 memory[0x40:0x60] } 0A6E 60 PUSH1 0x40 0A70 51 MLOAD 0A71 62 PUSH3 0x461bcd 0A75 60 PUSH1 0xe5 0A77 1B SHL 0A78 81 DUP2 0A79 52 MSTORE 0A7A 60 PUSH1 0x20 0A7C 60 PUSH1 0x04 0A7E 82 DUP3 0A7F 01 ADD 0A80 52 MSTORE 0A81 60 PUSH1 0x25 0A83 60 PUSH1 0x24 0A85 82 DUP3 0A86 01 ADD 0A87 52 MSTORE 0A88 7F PUSH32 0x5468657365206b657973206861766520616c7265616479206265656e20636c61 0AA9 60 PUSH1 0x44 0AAB 82 DUP3 0AAC 01 ADD 0AAD 52 MSTORE 0AAE 64 PUSH5 0x34b6b2b217 0AB4 60 PUSH1 0xd9 0AB6 1B SHL 0AB7 60 PUSH1 0x64 0AB9 82 DUP3 0ABA 01 ADD 0ABB 52 MSTORE 0ABC 60 PUSH1 0x84 0ABE 01 ADD 0ABF 61 PUSH2 0x0377 0AC2 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0A79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A80 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A87 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x25 // @0AAD memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5468657365206b657973206861766520616c7265616479206265656e20636c61 // @0ABB memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b6b2b217 << 0xd9 // @0ABE stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_0AC3: // Incoming jump from 0x0A6D, if !(0xff & storage[keccak256(memory[0x00:0x40])]) // Inputs[3] // { // @0AC7 msg.sender // @0AC8 stack[-2] // @0AC9 stack[-1] // } 0AC3 5B JUMPDEST 0AC4 61 PUSH2 0x0ace 0AC7 33 CALLER 0AC8 83 DUP4 0AC9 83 DUP4 0ACA 61 PUSH2 0x1280 0ACD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AC4 stack[0] = 0x0ace // @0AC7 stack[1] = msg.sender // @0AC8 stack[2] = stack[-2] // @0AC9 stack[3] = stack[-1] // } // Block ends with call to 0x1280, returns to 0x0ACE label_0ACE: // Incoming return from call to 0x1280 at 0x0ACD // Inputs[1] { @0AD2 stack[-1] } 0ACE 5B JUMPDEST 0ACF 61 PUSH2 0x0b1a 0AD2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b1a, if stack[-1] label_0AD3: // Incoming jump from 0x0AD2, if not stack[-1] // Inputs[1] { @0AD5 memory[0x40:0x60] } 0AD3 60 PUSH1 0x40 0AD5 51 MLOAD 0AD6 62 PUSH3 0x461bcd 0ADA 60 PUSH1 0xe5 0ADC 1B SHL 0ADD 81 DUP2 0ADE 52 MSTORE 0ADF 60 PUSH1 0x20 0AE1 60 PUSH1 0x04 0AE3 82 DUP3 0AE4 01 ADD 0AE5 52 MSTORE 0AE6 60 PUSH1 0x1e 0AE8 60 PUSH1 0x24 0AEA 82 DUP3 0AEB 01 ADD 0AEC 52 MSTORE 0AED 7F PUSH32 0x54686973206973206e6f7420612076616c6964207369676e61746972652e0000 0B0E 60 PUSH1 0x44 0B10 82 DUP3 0B11 01 ADD 0B12 52 MSTORE 0B13 60 PUSH1 0x64 0B15 01 ADD 0B16 61 PUSH2 0x0377 0B19 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0ADE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AE5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0AEC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1e // @0B12 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x54686973206973206e6f7420612076616c6964207369676e61746972652e0000 // @0B15 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_0B1A: // Incoming jump from 0x0AD2, if stack[-1] // Inputs[5] // { // @0B1B msg.sender // @0B2C memory[0x00:0x40] // @0B2E storage[keccak256(memory[0x00:0x40])] // @0B3C memory[0x40:0x60] // @0B4B stack[-2] // } 0B1A 5B JUMPDEST 0B1B 33 CALLER 0B1C 60 PUSH1 0x00 0B1E 81 DUP2 0B1F 81 DUP2 0B20 52 MSTORE 0B21 60 PUSH1 0x06 0B23 60 PUSH1 0x20 0B25 90 SWAP1 0B26 81 DUP2 0B27 52 MSTORE 0B28 60 PUSH1 0x40 0B2A 80 DUP1 0B2B 83 DUP4 0B2C 20 SHA3 0B2D 80 DUP1 0B2E 54 SLOAD 0B2F 60 PUSH1 0xff 0B31 19 NOT 0B32 16 AND 0B33 60 PUSH1 0x01 0B35 90 SWAP1 0B36 81 DUP2 0B37 17 OR 0B38 90 SWAP1 0B39 91 SWAP2 0B3A 55 SSTORE 0B3B 81 DUP2 0B3C 51 MLOAD 0B3D 92 SWAP3 0B3E 83 DUP4 0B3F 01 ADD 0B40 90 SWAP1 0B41 91 SWAP2 0B42 52 MSTORE 0B43 91 SWAP2 0B44 81 DUP2 0B45 52 MSTORE 0B46 61 PUSH2 0x0a05 0B49 92 SWAP3 0B4A 91 SWAP2 0B4B 85 DUP6 0B4C 91 SWAP2 0B4D 61 PUSH2 0x1328 0B50 56 *JUMP // Stack delta = +5 // Outputs[10] // { // @0B20 memory[0x00:0x20] = msg.sender // @0B27 memory[0x20:0x40] = 0x06 // @0B3A storage[keccak256(memory[0x00:0x40])] = 0x01 | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0B42 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0B45 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0B49 stack[0] = 0x0a05 // @0B4A stack[1] = msg.sender // @0B4A stack[3] = 0x01 // @0B4C stack[2] = stack[-2] // @0B4C stack[4] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1328 label_0B51: // Incoming jump from 0x02F2 // Inputs[2] // { // @0B5A stack[-5] // @0B5C msg.sender // } 0B51 5B JUMPDEST 0B52 60 PUSH1 0x01 0B54 60 PUSH1 0x01 0B56 60 PUSH1 0xa0 0B58 1B SHL 0B59 03 SUB 0B5A 85 DUP6 0B5B 16 AND 0B5C 33 CALLER 0B5D 14 EQ 0B5E 80 DUP1 0B5F 61 PUSH2 0x0b6d 0B62 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B5D stack[0] = msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x0b6d, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 label_0B63: // Incoming jump from 0x0B62, if not msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @0B67 stack[-6] // @0B68 msg.sender // } 0B63 50 POP 0B64 61 PUSH2 0x0b6d 0B67 85 DUP6 0B68 33 CALLER 0B69 61 PUSH2 0x02b2 0B6C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B64 stack[-1] = 0x0b6d // @0B67 stack[0] = stack[-6] // @0B68 stack[1] = msg.sender // } // Block ends with call to 0x02b2, returns to 0x0B6D label_0B6D: // Incoming jump from 0x0B62, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x02B2 at 0x0B6C // Inputs[1] { @0B71 stack[-1] } 0B6D 5B JUMPDEST 0B6E 61 PUSH2 0x0bcb 0B71 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0bcb, if stack[-1] label_0B72: // Incoming jump from 0x0B71, if not stack[-1] // Inputs[1] { @0B74 memory[0x40:0x60] } 0B72 60 PUSH1 0x40 0B74 51 MLOAD 0B75 62 PUSH3 0x461bcd 0B79 60 PUSH1 0xe5 0B7B 1B SHL 0B7C 81 DUP2 0B7D 52 MSTORE 0B7E 60 PUSH1 0x20 0B80 60 PUSH1 0x04 0B82 82 DUP3 0B83 01 ADD 0B84 52 MSTORE 0B85 60 PUSH1 0x29 0B87 60 PUSH1 0x24 0B89 82 DUP3 0B8A 01 ADD 0B8B 52 MSTORE 0B8C 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 0BAD 60 PUSH1 0x44 0BAF 82 DUP3 0BB0 01 ADD 0BB1 52 MSTORE 0BB2 68 PUSH9 0x08185c1c1c9bdd9959 0BBC 60 PUSH1 0xba 0BBE 1B SHL 0BBF 60 PUSH1 0x64 0BC1 82 DUP3 0BC2 01 ADD 0BC3 52 MSTORE 0BC4 60 PUSH1 0x84 0BC6 01 ADD 0BC7 61 PUSH2 0x0377 0BCA 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0B7D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B84 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B8B memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0BB1 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 // @0BC3 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x08185c1c1c9bdd9959 << 0xba // @0BC6 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_0BCB: // Incoming jump from 0x0B71, if stack[-1] // Inputs[5] // { // @0BCF stack[-5] // @0BD0 stack[-4] // @0BD1 stack[-3] // @0BD2 stack[-2] // @0BD3 stack[-1] // } 0BCB 5B JUMPDEST 0BCC 61 PUSH2 0x0681 0BCF 85 DUP6 0BD0 85 DUP6 0BD1 85 DUP6 0BD2 85 DUP6 0BD3 85 DUP6 0BD4 61 PUSH2 0x13f8 0BD7 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0BCC stack[0] = 0x0681 // @0BCF stack[1] = stack[-5] // @0BD0 stack[2] = stack[-4] // @0BD1 stack[3] = stack[-3] // @0BD2 stack[4] = stack[-2] // @0BD3 stack[5] = stack[-1] // } // Block ends with call to 0x13f8, returns to 0x0681 label_0BD8: // Incoming jump from 0x0305 // Inputs[2] // { // @0BDB storage[0x03] // @0BE5 msg.sender // } 0BD8 5B JUMPDEST 0BD9 60 PUSH1 0x03 0BDB 54 SLOAD 0BDC 60 PUSH1 0x01 0BDE 60 PUSH1 0x01 0BE0 60 PUSH1 0xa0 0BE2 1B SHL 0BE3 03 SUB 0BE4 16 AND 0BE5 33 CALLER 0BE6 14 EQ 0BE7 61 PUSH2 0x0c02 0BEA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c02, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0BEB: // Incoming jump from 0x0BEA, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0BED memory[0x40:0x60] } 0BEB 60 PUSH1 0x40 0BED 51 MLOAD 0BEE 62 PUSH3 0x461bcd 0BF2 60 PUSH1 0xe5 0BF4 1B SHL 0BF5 81 DUP2 0BF6 52 MSTORE 0BF7 60 PUSH1 0x04 0BF9 01 ADD 0BFA 61 PUSH2 0x0377 0BFD 90 SWAP1 0BFE 61 PUSH2 0x2405 0C01 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0BF6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0BFD stack[0] = 0x0377 // @0BFD stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2405, returns to 0x0377 label_0C02: // Incoming jump from 0x0BEA, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0C0B stack[-1] } 0C02 5B JUMPDEST 0C03 60 PUSH1 0x01 0C05 60 PUSH1 0x01 0C07 60 PUSH1 0xa0 0C09 1B SHL 0C0A 03 SUB 0C0B 81 DUP2 0C0C 16 AND 0C0D 61 PUSH2 0x0c67 0C10 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c67, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0C11: // Incoming jump from 0x0C10, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C13 memory[0x40:0x60] } 0C11 60 PUSH1 0x40 0C13 51 MLOAD 0C14 62 PUSH3 0x461bcd 0C18 60 PUSH1 0xe5 0C1A 1B SHL 0C1B 81 DUP2 0C1C 52 MSTORE 0C1D 60 PUSH1 0x20 0C1F 60 PUSH1 0x04 0C21 82 DUP3 0C22 01 ADD 0C23 52 MSTORE 0C24 60 PUSH1 0x26 0C26 60 PUSH1 0x24 0C28 82 DUP3 0C29 01 ADD 0C2A 52 MSTORE 0C2B 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0C4C 60 PUSH1 0x44 0C4E 82 DUP3 0C4F 01 ADD 0C50 52 MSTORE 0C51 65 PUSH6 0x646472657373 0C58 60 PUSH1 0xd0 0C5A 1B SHL 0C5B 60 PUSH1 0x64 0C5D 82 DUP3 0C5E 01 ADD 0C5F 52 MSTORE 0C60 60 PUSH1 0x84 0C62 01 ADD 0C63 61 PUSH2 0x0377 0C66 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C1C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C23 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C2A memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0C50 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0C5F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0C62 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_0C67: // Incoming jump from 0x0C10, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0C6B stack[-1] } 0C67 5B JUMPDEST 0C68 61 PUSH2 0x0c70 0C6B 81 DUP2 0C6C 61 PUSH2 0x10c7 0C6F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C68 stack[0] = 0x0c70 // @0C6B stack[1] = stack[-1] // } // Block ends with call to 0x10c7, returns to 0x0C70 label_0C70: // Incoming jump from 0x19DD, if !(stack[-1] == stack[-2]) // Incoming jump from 0x26E6, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x10C7 at 0x0C6F // Inputs[1] { @0C72 stack[-2] } 0C70 5B JUMPDEST 0C71 50 POP 0C72 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0C73: // Incoming call from 0x0509, returns to 0x050A // Inputs[1] { @0C76 stack[-1] } 0C73 5B JUMPDEST 0C74 60 PUSH1 0x60 0C76 81 DUP2 0C77 61 PUSH2 0x0c97 0C7A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C74 stack[0] = 0x60 } // Block ends with conditional jump to 0x0c97, if stack[-1] label_0C7B: // Incoming jump from 0x0C7A, if not stack[-1] // Inputs[2] // { // @0C80 memory[0x40:0x60] // @0C95 stack[-3] // } 0C7B 50 POP 0C7C 50 POP 0C7D 60 PUSH1 0x40 0C7F 80 DUP1 0C80 51 MLOAD 0C81 80 DUP1 0C82 82 DUP3 0C83 01 ADD 0C84 90 SWAP1 0C85 91 SWAP2 0C86 52 MSTORE 0C87 60 PUSH1 0x01 0C89 81 DUP2 0C8A 52 MSTORE 0C8B 60 PUSH1 0x03 0C8D 60 PUSH1 0xfc 0C8F 1B SHL 0C90 60 PUSH1 0x20 0C92 82 DUP3 0C93 01 ADD 0C94 52 MSTORE 0C95 90 SWAP1 0C96 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @0C86 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0C8A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @0C94 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @0C95 stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_0C97: // Incoming jump from 0x0C7A, if stack[-1] // Inputs[1] { @0C98 stack[-2] } 0C97 5B JUMPDEST 0C98 81 DUP2 0C99 60 PUSH1 0x00 0C9B 5B JUMPDEST 0C9C 81 DUP2 0C9D 15 ISZERO 0C9E 61 PUSH2 0x0cc1 0CA1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C98 stack[0] = stack[-2] // @0C99 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0cc1, if !stack[-2] label_0CA2: // Incoming jump from 0x0CA1, if not !stack[-2] // Incoming jump from 0x0CA1, if not !stack[-2] // Inputs[1] { @0CA2 stack[-1] } 0CA2 80 DUP1 0CA3 61 PUSH2 0x0cab 0CA6 81 DUP2 0CA7 61 PUSH2 0x25c2 0CAA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0CA2 stack[0] = stack[-1] // @0CA3 stack[1] = 0x0cab // @0CA6 stack[2] = stack[-1] // } // Block ends with call to 0x25c2, returns to 0x0CAB label_0CAB: // Incoming return from call to 0x25C2 at 0x0CAA // Inputs[4] // { // @0CAC stack[-3] // @0CAC stack[-1] // @0CB1 stack[-2] // @0CB5 stack[-4] // } 0CAB 5B JUMPDEST 0CAC 91 SWAP2 0CAD 50 POP 0CAE 61 PUSH2 0x0cba 0CB1 90 SWAP1 0CB2 50 POP 0CB3 60 PUSH1 0x0a 0CB5 83 DUP4 0CB6 61 PUSH2 0x24ff 0CB9 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @0CAC stack[-3] = stack[-1] // @0CB1 stack[-2] = 0x0cba // @0CB3 stack[-1] = 0x0a // @0CB5 stack[0] = stack[-4] // } // Block ends with call to 0x24ff, returns to 0x0CBA label_0CBA: // Incoming return from call to 0x24FF at 0x0CB9 // Inputs[2] // { // @0CBB stack[-1] // @0CBB stack[-3] // } 0CBA 5B JUMPDEST 0CBB 91 SWAP2 0CBC 50 POP 0CBD 61 PUSH2 0x0c9b 0CC0 56 *JUMP // Stack delta = -1 // Outputs[1] { @0CBB stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0c9b label_0CC1: // Incoming jump from 0x0CA1, if !stack[-2] // Incoming jump from 0x0CA1, if !stack[-2] // Inputs[1] { @0CC4 stack[-1] } 0CC1 5B JUMPDEST 0CC2 60 PUSH1 0x00 0CC4 81 DUP2 0CC5 67 PUSH8 0xffffffffffffffff 0CCE 81 DUP2 0CCF 11 GT 0CD0 15 ISZERO 0CD1 61 PUSH2 0x0cea 0CD4 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0CC2 stack[0] = 0x00 // @0CC4 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x0cea, if !(stack[-1] > 0xffffffffffffffff) label_0CD5: // Incoming jump from 0x0CD4, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @0CE9 memory[0x00:0x24] } 0CD5 63 PUSH4 0x4e487b71 0CDA 60 PUSH1 0xe0 0CDC 1B SHL 0CDD 60 PUSH1 0x00 0CDF 52 MSTORE 0CE0 60 PUSH1 0x41 0CE2 60 PUSH1 0x04 0CE4 52 MSTORE 0CE5 60 PUSH1 0x24 0CE7 60 PUSH1 0x00 0CE9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0CDF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0CE4 memory[0x04:0x24] = 0x41 // @0CE9 revert(memory[0x00:0x24]); // } // Block terminates label_0CEA: // Incoming jump from 0x0CD4, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0CED memory[0x40:0x60] // @0CEE stack[-1] // } 0CEA 5B JUMPDEST 0CEB 60 PUSH1 0x40 0CED 51 MLOAD 0CEE 90 SWAP1 0CEF 80 DUP1 0CF0 82 DUP3 0CF1 52 MSTORE 0CF2 80 DUP1 0CF3 60 PUSH1 0x1f 0CF5 01 ADD 0CF6 60 PUSH1 0x1f 0CF8 19 NOT 0CF9 16 AND 0CFA 60 PUSH1 0x20 0CFC 01 ADD 0CFD 82 DUP3 0CFE 01 ADD 0CFF 60 PUSH1 0x40 0D01 52 MSTORE 0D02 80 DUP1 0D03 15 ISZERO 0D04 61 PUSH2 0x0d14 0D07 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0CEE stack[-1] = memory[0x40:0x60] // @0CEE stack[0] = stack[-1] // @0CF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0D01 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x0d14, if !stack[-1] label_0D08: // Incoming jump from 0x0D07, if not !stack[-1] // Inputs[6] // { // @0D0A stack[-2] // @0D0C stack[-1] // @0D0E msg.data.length // @0D10 msg.data[msg.data.length:msg.data.length + stack[-1]] // @0D16 stack[-3] // @0D19 stack[-7] // } 0D08 60 PUSH1 0x20 0D0A 82 DUP3 0D0B 01 ADD 0D0C 81 DUP2 0D0D 80 DUP1 0D0E 36 CALLDATASIZE 0D0F 83 DUP4 0D10 37 CALLDATACOPY 0D11 01 ADD 0D12 90 SWAP1 0D13 50 POP 0D14 5B JUMPDEST 0D15 50 POP 0D16 90 SWAP1 0D17 50 POP 0D18 5B JUMPDEST 0D19 84 DUP5 0D1A 15 ISZERO 0D1B 61 PUSH2 0x0d8d 0D1E 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0D10 memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @0D16 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x0d8d, if !stack[-7] label_0D1F: // Incoming jump from 0x0D1E, if not !stack[-7] // Incoming jump from 0x0D1E, if not !stack[-5] // Incoming jump from 0x0D1E, if not !stack[-7] // Inputs[1] { @0D24 stack[-2] } 0D1F 61 PUSH2 0x0d29 0D22 60 PUSH1 0x01 0D24 83 DUP4 0D25 61 PUSH2 0x2513 0D28 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0D1F stack[0] = 0x0d29 // @0D22 stack[1] = 0x01 // @0D24 stack[2] = stack[-2] // } // Block ends with call to 0x2513, returns to 0x0D29 label_0D29: // Incoming return from call to 0x2513 at 0x0D28 // Inputs[3] // { // @0D2A stack[-3] // @0D2A stack[-1] // @0D31 stack[-6] // } 0D29 5B JUMPDEST 0D2A 91 SWAP2 0D2B 50 POP 0D2C 61 PUSH2 0x0d36 0D2F 60 PUSH1 0x0a 0D31 86 DUP7 0D32 61 PUSH2 0x25dd 0D35 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0D2A stack[-3] = stack[-1] // @0D2C stack[-1] = 0x0d36 // @0D2F stack[0] = 0x0a // @0D31 stack[1] = stack[-6] // } // Block ends with call to 0x25dd, returns to 0x0D36 label_0D36: // Incoming return from call to 0x25DD at 0x0D35 // Inputs[1] { @0D3A stack[-1] } 0D36 5B JUMPDEST 0D37 61 PUSH2 0x0d41 0D3A 90 SWAP1 0D3B 60 PUSH1 0x30 0D3D 61 PUSH2 0x24e7 0D40 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0D3A stack[0] = stack[-1] // @0D3A stack[-1] = 0x0d41 // @0D3B stack[1] = 0x30 // } // Block ends with call to 0x24e7, returns to 0x0D41 label_0D41: // Incoming return from call to 0x24E7 at 0x0D40 // Inputs[4] // { // @0D44 stack[-1] // @0D45 stack[-2] // @0D46 stack[-3] // @0D48 memory[stack[-2]:stack[-2] + 0x20] // } 0D41 5B JUMPDEST 0D42 60 PUSH1 0xf8 0D44 1B SHL 0D45 81 DUP2 0D46 83 DUP4 0D47 81 DUP2 0D48 51 MLOAD 0D49 81 DUP2 0D4A 10 LT 0D4B 61 PUSH2 0x0d64 0D4E 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0D44 stack[-1] = stack[-1] << 0xf8 // @0D45 stack[0] = stack[-2] // @0D46 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x0d64, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_0D4F: // Incoming jump from 0x0D4E, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @0D63 memory[0x00:0x24] } 0D4F 63 PUSH4 0x4e487b71 0D54 60 PUSH1 0xe0 0D56 1B SHL 0D57 60 PUSH1 0x00 0D59 52 MSTORE 0D5A 60 PUSH1 0x32 0D5C 60 PUSH1 0x04 0D5E 52 MSTORE 0D5F 60 PUSH1 0x24 0D61 60 PUSH1 0x00 0D63 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0D59 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0D5E memory[0x04:0x24] = 0x32 // @0D63 revert(memory[0x00:0x24]); // } // Block terminates label_0D64: // Incoming jump from 0x0D4E, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @0D67 stack[-1] // @0D68 stack[-2] // @0D69 stack[-3] // @0D81 stack[-8] // } 0D64 5B JUMPDEST 0D65 60 PUSH1 0x20 0D67 01 ADD 0D68 01 ADD 0D69 90 SWAP1 0D6A 60 PUSH1 0x01 0D6C 60 PUSH1 0x01 0D6E 60 PUSH1 0xf8 0D70 1B SHL 0D71 03 SUB 0D72 19 NOT 0D73 16 AND 0D74 90 SWAP1 0D75 81 DUP2 0D76 60 PUSH1 0x00 0D78 1A BYTE 0D79 90 SWAP1 0D7A 53 MSTORE8 0D7B 50 POP 0D7C 61 PUSH2 0x0d86 0D7F 60 PUSH1 0x0a 0D81 86 DUP7 0D82 61 PUSH2 0x24ff 0D85 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0D7A memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @0D7C stack[-3] = 0x0d86 // @0D7F stack[-2] = 0x0a // @0D81 stack[-1] = stack[-8] // } // Block ends with call to 0x24ff, returns to 0x0D86 label_0D86: // Incoming return from call to 0x24FF at 0x0D85 // Inputs[2] // { // @0D87 stack[-6] // @0D87 stack[-1] // } 0D86 5B JUMPDEST 0D87 94 SWAP5 0D88 50 POP 0D89 61 PUSH2 0x0d18 0D8C 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D87 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x0d18 label_0D8D: // Incoming jump from 0x0D1E, if !stack[-7] // Incoming jump from 0x0D1E, if !stack[-5] // Incoming jump from 0x0D1E, if !stack[-7] // Inputs[3] // { // @0D8E stack[-6] // @0D8E stack[-1] // @0D8F stack[-5] // } 0D8D 5B JUMPDEST 0D8E 94 SWAP5 0D8F 93 SWAP4 0D90 50 POP 0D91 50 POP 0D92 50 POP 0D93 50 POP 0D94 56 *JUMP // Stack delta = -5 // Outputs[1] { @0D8E stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0D95: // Incoming call from 0x05EB, returns to 0x05EC // Inputs[1] { @0D9E stack[-3] } 0D95 5B JUMPDEST 0D96 60 PUSH1 0x01 0D98 60 PUSH1 0x01 0D9A 60 PUSH1 0xa0 0D9C 1B SHL 0D9D 03 SUB 0D9E 83 DUP4 0D9F 16 AND 0DA0 61 PUSH2 0x0df7 0DA3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0df7, if stack[-3] & (0x01 << 0xa0) - 0x01 label_0DA4: // Incoming jump from 0x0DA3, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0DA6 memory[0x40:0x60] } 0DA4 60 PUSH1 0x40 0DA6 51 MLOAD 0DA7 62 PUSH3 0x461bcd 0DAB 60 PUSH1 0xe5 0DAD 1B SHL 0DAE 81 DUP2 0DAF 52 MSTORE 0DB0 60 PUSH1 0x20 0DB2 60 PUSH1 0x04 0DB4 82 DUP3 0DB5 01 ADD 0DB6 52 MSTORE 0DB7 60 PUSH1 0x23 0DB9 60 PUSH1 0x24 0DBB 82 DUP3 0DBC 01 ADD 0DBD 52 MSTORE 0DBE 7F PUSH32 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 0DDF 60 PUSH1 0x44 0DE1 82 DUP3 0DE2 01 ADD 0DE3 52 MSTORE 0DE4 62 PUSH3 0x657373 0DE8 60 PUSH1 0xe8 0DEA 1B SHL 0DEB 60 PUSH1 0x64 0DED 82 DUP3 0DEE 01 ADD 0DEF 52 MSTORE 0DF0 60 PUSH1 0x84 0DF2 01 ADD 0DF3 61 PUSH2 0x0377 0DF6 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0DAF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DB6 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DBD memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x23 // @0DE3 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e2066726f6d20746865207a65726f2061646472 // @0DEF memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x657373 << 0xe8 // @0DF2 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_0DF7: // Incoming jump from 0x0DA3, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0DF8 msg.sender // @0DFD stack[-3] // @0E03 stack[-2] // } 0DF7 5B JUMPDEST 0DF8 33 CALLER 0DF9 61 PUSH2 0x0e27 0DFC 81 DUP2 0DFD 85 DUP6 0DFE 60 PUSH1 0x00 0E00 61 PUSH2 0x0e08 0E03 87 DUP8 0E04 61 PUSH2 0x1515 0E07 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0DF8 stack[0] = msg.sender // @0DF9 stack[1] = 0x0e27 // @0DFC stack[2] = msg.sender // @0DFD stack[3] = stack[-3] // @0DFE stack[4] = 0x00 // @0E00 stack[5] = 0x0e08 // @0E03 stack[6] = stack[-2] // } // Block ends with call to 0x1515, returns to 0x0E08 label_0E08: // Incoming return from call to 0x1515 at 0x0E07 // Inputs[1] { @0E0C stack[-7] } 0E08 5B JUMPDEST 0E09 61 PUSH2 0x0e11 0E0C 87 DUP8 0E0D 61 PUSH2 0x1515 0E10 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E09 stack[0] = 0x0e11 // @0E0C stack[1] = stack[-7] // } // Block ends with call to 0x1515, returns to 0x0E11 label_0E11: // Incoming return from call to 0x1515 at 0x0E10 // Inputs[2] // { // @0E17 memory[0x40:0x60] // @0E26 stack[-6] // } 0E11 5B JUMPDEST 0E12 50 POP 0E13 50 POP 0E14 60 PUSH1 0x40 0E16 80 DUP1 0E17 51 MLOAD 0E18 60 PUSH1 0x20 0E1A 81 DUP2 0E1B 01 ADD 0E1C 90 SWAP1 0E1D 91 SWAP2 0E1E 52 MSTORE 0E1F 60 PUSH1 0x00 0E21 90 SWAP1 0E22 52 MSTORE 0E23 50 POP 0E24 50 POP 0E25 50 POP 0E26 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0E1E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @0E22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to stack[-6] label_0E27: // Incoming return from call to 0x0E08 at 0x0E07 // Inputs[6] // { // @0E2A stack[-3] // @0E36 memory[0x00:0x40] // @0E3F stack[-4] // @0E47 memory[0x00:0x40] // @0E48 storage[keccak256(memory[0x00:0x40])] // @0E49 stack[-2] // } 0E27 5B JUMPDEST 0E28 60 PUSH1 0x00 0E2A 83 DUP4 0E2B 81 DUP2 0E2C 52 MSTORE 0E2D 60 PUSH1 0x20 0E2F 81 DUP2 0E30 81 DUP2 0E31 52 MSTORE 0E32 60 PUSH1 0x40 0E34 80 DUP1 0E35 83 DUP4 0E36 20 SHA3 0E37 60 PUSH1 0x01 0E39 60 PUSH1 0x01 0E3B 60 PUSH1 0xa0 0E3D 1B SHL 0E3E 03 SUB 0E3F 88 DUP9 0E40 16 AND 0E41 84 DUP5 0E42 52 MSTORE 0E43 90 SWAP1 0E44 91 SWAP2 0E45 52 MSTORE 0E46 90 SWAP1 0E47 20 SHA3 0E48 54 SLOAD 0E49 82 DUP3 0E4A 81 DUP2 0E4B 10 LT 0E4C 15 ISZERO 0E4D 61 PUSH2 0x0ea4 0E50 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0E2C memory[0x00:0x20] = stack[-3] // @0E31 memory[0x20:0x40] = 0x00 // @0E42 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @0E45 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0E48 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0ea4, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) label_0E51: // Incoming jump from 0x0E50, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[1] { @0E53 memory[0x40:0x60] } 0E51 60 PUSH1 0x40 0E53 51 MLOAD 0E54 62 PUSH3 0x461bcd 0E58 60 PUSH1 0xe5 0E5A 1B SHL 0E5B 81 DUP2 0E5C 52 MSTORE 0E5D 60 PUSH1 0x20 0E5F 60 PUSH1 0x04 0E61 82 DUP3 0E62 01 ADD 0E63 52 MSTORE 0E64 60 PUSH1 0x24 0E66 80 DUP1 0E67 82 DUP3 0E68 01 ADD 0E69 52 MSTORE 0E6A 7F PUSH32 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c 0E8B 60 PUSH1 0x44 0E8D 82 DUP3 0E8E 01 ADD 0E8F 52 MSTORE 0E90 63 PUSH4 0x616e6365 0E95 60 PUSH1 0xe0 0E97 1B SHL 0E98 60 PUSH1 0x64 0E9A 82 DUP3 0E9B 01 ADD 0E9C 52 MSTORE 0E9D 60 PUSH1 0x84 0E9F 01 ADD 0EA0 61 PUSH2 0x0377 0EA3 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0E5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E63 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E69 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @0E8F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206275726e20616d6f756e7420657863656564732062616c // @0E9C memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x616e6365 << 0xe0 // @0E9F stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_0EA4: // Incoming jump from 0x0E50, if !(storage[keccak256(memory[0x00:0x40])] < stack[-2]) // Inputs[11] // { // @0EA7 stack[-4] // @0EB3 memory[0x00:0x40] // @0EBC stack[-5] // @0EC7 memory[0x00:0x40] // @0EC8 stack[-3] // @0EC9 stack[-1] // @0ECE memory[0x40:0x60] // @0EDB stack[-2] // @0F03 memory[0x40:0x60] // @0F08 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x40) - memory[0x40:0x60]] // @0F0E stack[-6] // } 0EA4 5B JUMPDEST 0EA5 60 PUSH1 0x00 0EA7 84 DUP5 0EA8 81 DUP2 0EA9 52 MSTORE 0EAA 60 PUSH1 0x20 0EAC 81 DUP2 0EAD 81 DUP2 0EAE 52 MSTORE 0EAF 60 PUSH1 0x40 0EB1 80 DUP1 0EB2 83 DUP4 0EB3 20 SHA3 0EB4 60 PUSH1 0x01 0EB6 60 PUSH1 0x01 0EB8 60 PUSH1 0xa0 0EBA 1B SHL 0EBB 03 SUB 0EBC 89 DUP10 0EBD 81 DUP2 0EBE 16 AND 0EBF 80 DUP1 0EC0 86 DUP7 0EC1 52 MSTORE 0EC2 91 SWAP2 0EC3 84 DUP5 0EC4 52 MSTORE 0EC5 82 DUP3 0EC6 85 DUP6 0EC7 20 SHA3 0EC8 88 DUP9 0EC9 87 DUP8 0ECA 03 SUB 0ECB 90 SWAP1 0ECC 55 SSTORE 0ECD 82 DUP3 0ECE 51 MLOAD 0ECF 89 DUP10 0ED0 81 DUP2 0ED1 52 MSTORE 0ED2 93 SWAP4 0ED3 84 DUP5 0ED4 01 ADD 0ED5 88 DUP9 0ED6 90 SWAP1 0ED7 52 MSTORE 0ED8 90 SWAP1 0ED9 92 SWAP3 0EDA 90 SWAP1 0EDB 86 DUP7 0EDC 16 AND 0EDD 91 SWAP2 0EDE 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 0EFF 91 SWAP2 0F00 01 ADD 0F01 60 PUSH1 0x40 0F03 51 MLOAD 0F04 80 DUP1 0F05 91 SWAP2 0F06 03 SUB 0F07 90 SWAP1 0F08 A4 LOG4 0F09 50 POP 0F0A 50 POP 0F0B 50 POP 0F0C 50 POP 0F0D 50 POP 0F0E 56 *JUMP // Stack delta = -6 // Outputs[8] // { // @0EA9 memory[0x00:0x20] = stack[-4] // @0EAE memory[0x20:0x40] = 0x00 // @0EC1 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0EC4 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0ECC storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-3] // @0ED1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @0ED7 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-3] // @0F08 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x40) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, stack[-2] & (0x01 << 0xa0) - 0x01, stack[-5] & (0x01 << 0xa0) - 0x01, 0x00]); // } // Block ends with unconditional jump to stack[-6] 0F0F 5B JUMPDEST 0F10 81 DUP2 0F11 51 MLOAD 0F12 83 DUP4 0F13 51 MLOAD 0F14 14 EQ 0F15 61 PUSH2 0x0f30 0F18 57 *JUMPI 0F19 60 PUSH1 0x40 0F1B 51 MLOAD 0F1C 62 PUSH3 0x461bcd 0F20 60 PUSH1 0xe5 0F22 1B SHL 0F23 81 DUP2 0F24 52 MSTORE 0F25 60 PUSH1 0x04 0F27 01 ADD 0F28 61 PUSH2 0x0377 0F2B 90 SWAP1 0F2C 61 PUSH2 0x243a 0F2F 56 *JUMP 0F30 5B JUMPDEST 0F31 60 PUSH1 0x01 0F33 60 PUSH1 0x01 0F35 60 PUSH1 0xa0 0F37 1B SHL 0F38 03 SUB 0F39 84 DUP5 0F3A 16 AND 0F3B 61 PUSH2 0x0f56 0F3E 57 *JUMPI 0F3F 60 PUSH1 0x40 0F41 51 MLOAD 0F42 62 PUSH3 0x461bcd 0F46 60 PUSH1 0xe5 0F48 1B SHL 0F49 81 DUP2 0F4A 52 MSTORE 0F4B 60 PUSH1 0x04 0F4D 01 ADD 0F4E 61 PUSH2 0x0377 0F51 90 SWAP1 0F52 61 PUSH2 0x2376 0F55 56 *JUMP 0F56 5B JUMPDEST 0F57 33 CALLER 0F58 60 PUSH1 0x00 0F5A 5B JUMPDEST 0F5B 84 DUP5 0F5C 51 MLOAD 0F5D 81 DUP2 0F5E 10 LT 0F5F 15 ISZERO 0F60 61 PUSH2 0x1059 0F63 57 *JUMPI 0F64 60 PUSH1 0x00 0F66 85 DUP6 0F67 82 DUP3 0F68 81 DUP2 0F69 51 MLOAD 0F6A 81 DUP2 0F6B 10 LT 0F6C 61 PUSH2 0x0f85 0F6F 57 *JUMPI 0F70 63 PUSH4 0x4e487b71 0F75 60 PUSH1 0xe0 0F77 1B SHL 0F78 60 PUSH1 0x00 0F7A 52 MSTORE 0F7B 60 PUSH1 0x32 0F7D 60 PUSH1 0x04 0F7F 52 MSTORE 0F80 60 PUSH1 0x24 0F82 60 PUSH1 0x00 0F84 FD *REVERT 0F85 5B JUMPDEST 0F86 60 PUSH1 0x20 0F88 02 MUL 0F89 60 PUSH1 0x20 0F8B 01 ADD 0F8C 01 ADD 0F8D 51 MLOAD 0F8E 90 SWAP1 0F8F 50 POP 0F90 60 PUSH1 0x00 0F92 85 DUP6 0F93 83 DUP4 0F94 81 DUP2 0F95 51 MLOAD 0F96 81 DUP2 0F97 10 LT 0F98 61 PUSH2 0x0fb1 0F9B 57 *JUMPI 0F9C 63 PUSH4 0x4e487b71 0FA1 60 PUSH1 0xe0 0FA3 1B SHL 0FA4 60 PUSH1 0x00 0FA6 52 MSTORE 0FA7 60 PUSH1 0x32 0FA9 60 PUSH1 0x04 0FAB 52 MSTORE 0FAC 60 PUSH1 0x24 0FAE 60 PUSH1 0x00 0FB0 FD *REVERT 0FB1 5B JUMPDEST 0FB2 60 PUSH1 0x20 0FB4 90 SWAP1 0FB5 81 DUP2 0FB6 02 MUL 0FB7 91 SWAP2 0FB8 90 SWAP1 0FB9 91 SWAP2 0FBA 01 ADD 0FBB 81 DUP2 0FBC 01 ADD 0FBD 51 MLOAD 0FBE 60 PUSH1 0x00 0FC0 84 DUP5 0FC1 81 DUP2 0FC2 52 MSTORE 0FC3 80 DUP1 0FC4 83 DUP4 0FC5 52 MSTORE 0FC6 60 PUSH1 0x40 0FC8 80 DUP1 0FC9 82 DUP3 0FCA 20 SHA3 0FCB 60 PUSH1 0x01 0FCD 60 PUSH1 0x01 0FCF 60 PUSH1 0xa0 0FD1 1B SHL 0FD2 03 SUB 0FD3 8E DUP15 0FD4 16 AND 0FD5 83 DUP4 0FD6 52 MSTORE 0FD7 90 SWAP1 0FD8 93 SWAP4 0FD9 52 MSTORE 0FDA 91 SWAP2 0FDB 90 SWAP1 0FDC 91 SWAP2 0FDD 20 SHA3 0FDE 54 SLOAD 0FDF 90 SWAP1 0FE0 91 SWAP2 0FE1 50 POP 0FE2 81 DUP2 0FE3 81 DUP2 0FE4 10 LT 0FE5 15 ISZERO 0FE6 61 PUSH2 0x1001 0FE9 57 *JUMPI 0FEA 60 PUSH1 0x40 0FEC 51 MLOAD 0FED 62 PUSH3 0x461bcd 0FF1 60 PUSH1 0xe5 0FF3 1B SHL 0FF4 81 DUP2 0FF5 52 MSTORE 0FF6 60 PUSH1 0x04 0FF8 01 ADD 0FF9 61 PUSH2 0x0377 0FFC 90 SWAP1 0FFD 61 PUSH2 0x23bb 1000 56 *JUMP 1001 5B JUMPDEST 1002 60 PUSH1 0x00 1004 83 DUP4 1005 81 DUP2 1006 52 MSTORE 1007 60 PUSH1 0x20 1009 81 DUP2 100A 81 DUP2 100B 52 MSTORE 100C 60 PUSH1 0x40 100E 80 DUP1 100F 83 DUP4 1010 20 SHA3 1011 60 PUSH1 0x01 1013 60 PUSH1 0x01 1015 60 PUSH1 0xa0 1017 1B SHL 1018 03 SUB 1019 8E DUP15 101A 81 DUP2 101B 16 AND 101C 85 DUP6 101D 52 MSTORE 101E 92 SWAP3 101F 52 MSTORE 1020 80 DUP1 1021 83 DUP4 1022 20 SHA3 1023 85 DUP6 1024 85 DUP6 1025 03 SUB 1026 90 SWAP1 1027 55 SSTORE 1028 90 SWAP1 1029 8B DUP12 102A 16 AND 102B 82 DUP3 102C 52 MSTORE 102D 81 DUP2 102E 20 SHA3 102F 80 DUP1 1030 54 SLOAD 1031 84 DUP5 1032 92 SWAP3 1033 90 SWAP1 1034 61 PUSH2 0x103e 1037 90 SWAP1 1038 84 DUP5 1039 90 SWAP1 103A 61 PUSH2 0x24e7 103D 56 *JUMP 103E 5B JUMPDEST 103F 92 SWAP3 1040 50 POP 1041 50 POP 1042 81 DUP2 1043 90 SWAP1 1044 55 SSTORE 1045 50 POP 1046 50 POP 1047 50 POP 1048 50 POP 1049 80 DUP1 104A 61 PUSH2 0x1052 104D 90 SWAP1 104E 61 PUSH2 0x25c2 1051 56 *JUMP 1052 5B JUMPDEST 1053 90 SWAP1 1054 50 POP 1055 61 PUSH2 0x0f5a 1058 56 *JUMP 1059 5B JUMPDEST 105A 50 POP 105B 84 DUP5 105C 60 PUSH1 0x01 105E 60 PUSH1 0x01 1060 60 PUSH1 0xa0 1062 1B SHL 1063 03 SUB 1064 16 AND 1065 86 DUP7 1066 60 PUSH1 0x01 1068 60 PUSH1 0x01 106A 60 PUSH1 0xa0 106C 1B SHL 106D 03 SUB 106E 16 AND 106F 82 DUP3 1070 60 PUSH1 0x01 1072 60 PUSH1 0x01 1074 60 PUSH1 0xa0 1076 1B SHL 1077 03 SUB 1078 16 AND 1079 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 109A 87 DUP8 109B 87 DUP8 109C 60 PUSH1 0x40 109E 51 MLOAD 109F 61 PUSH2 0x10a9 10A2 92 SWAP3 10A3 91 SWAP2 10A4 90 SWAP1 10A5 61 PUSH2 0x22ed 10A8 56 *JUMP 10A9 5B JUMPDEST 10AA 60 PUSH1 0x40 10AC 51 MLOAD 10AD 80 DUP1 10AE 91 SWAP2 10AF 03 SUB 10B0 90 SWAP1 10B1 A4 LOG4 10B2 61 PUSH2 0x10bf 10B5 81 DUP2 10B6 87 DUP8 10B7 87 DUP8 10B8 87 DUP8 10B9 87 DUP8 10BA 87 DUP8 10BB 61 PUSH2 0x156e 10BE 56 *JUMP label_10BF: // Incoming jump from 0x1705, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @10C6 stack[-7] } 10BF 5B JUMPDEST 10C0 50 POP 10C1 50 POP 10C2 50 POP 10C3 50 POP 10C4 50 POP 10C5 50 POP 10C6 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_10C7: // Incoming call from 0x0853, returns to 0x0854 // Incoming call from 0x0C6F, returns to 0x0C70 // Inputs[5] // { // @10CB storage[0x03] // @10D4 stack[-1] // @10E9 memory[0x40:0x60] // @1115 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1118 stack[-2] // } 10C7 5B JUMPDEST 10C8 60 PUSH1 0x03 10CA 80 DUP1 10CB 54 SLOAD 10CC 60 PUSH1 0x01 10CE 60 PUSH1 0x01 10D0 60 PUSH1 0xa0 10D2 1B SHL 10D3 03 SUB 10D4 83 DUP4 10D5 81 DUP2 10D6 16 AND 10D7 60 PUSH1 0x01 10D9 60 PUSH1 0x01 10DB 60 PUSH1 0xa0 10DD 1B SHL 10DE 03 SUB 10DF 19 NOT 10E0 83 DUP4 10E1 16 AND 10E2 81 DUP2 10E3 17 OR 10E4 90 SWAP1 10E5 93 SWAP4 10E6 55 SSTORE 10E7 60 PUSH1 0x40 10E9 51 MLOAD 10EA 91 SWAP2 10EB 16 AND 10EC 91 SWAP2 10ED 90 SWAP1 10EE 82 DUP3 10EF 90 SWAP1 10F0 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1111 90 SWAP1 1112 60 PUSH1 0x00 1114 90 SWAP1 1115 A3 LOG3 1116 50 POP 1117 50 POP 1118 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @10E6 storage[0x03] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x03] & ~((0x01 << 0xa0) - 0x01)) // @1115 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x03] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] 1119 5B JUMPDEST 111A 60 PUSH1 0x01 111C 60 PUSH1 0x01 111E 60 PUSH1 0xa0 1120 1B SHL 1121 03 SUB 1122 84 DUP5 1123 16 AND 1124 61 PUSH2 0x113f 1127 57 *JUMPI 1128 60 PUSH1 0x40 112A 51 MLOAD 112B 62 PUSH3 0x461bcd 112F 60 PUSH1 0xe5 1131 1B SHL 1132 81 DUP2 1133 52 MSTORE 1134 60 PUSH1 0x04 1136 01 ADD 1137 61 PUSH2 0x0377 113A 90 SWAP1 113B 61 PUSH2 0x2482 113E 56 *JUMP 113F 5B JUMPDEST 1140 81 DUP2 1141 51 MLOAD 1142 83 DUP4 1143 51 MLOAD 1144 14 EQ 1145 61 PUSH2 0x1160 1148 57 *JUMPI 1149 60 PUSH1 0x40 114B 51 MLOAD 114C 62 PUSH3 0x461bcd 1150 60 PUSH1 0xe5 1152 1B SHL 1153 81 DUP2 1154 52 MSTORE 1155 60 PUSH1 0x04 1157 01 ADD 1158 61 PUSH2 0x0377 115B 90 SWAP1 115C 61 PUSH2 0x243a 115F 56 *JUMP 1160 5B JUMPDEST 1161 33 CALLER 1162 60 PUSH1 0x00 1164 5B JUMPDEST 1165 84 DUP5 1166 51 MLOAD 1167 81 DUP2 1168 10 LT 1169 15 ISZERO 116A 61 PUSH2 0x1218 116D 57 *JUMPI 116E 83 DUP4 116F 81 DUP2 1170 81 DUP2 1171 51 MLOAD 1172 81 DUP2 1173 10 LT 1174 61 PUSH2 0x118d 1177 57 *JUMPI 1178 63 PUSH4 0x4e487b71 117D 60 PUSH1 0xe0 117F 1B SHL 1180 60 PUSH1 0x00 1182 52 MSTORE 1183 60 PUSH1 0x32 1185 60 PUSH1 0x04 1187 52 MSTORE 1188 60 PUSH1 0x24 118A 60 PUSH1 0x00 118C FD *REVERT 118D 5B JUMPDEST 118E 60 PUSH1 0x20 1190 02 MUL 1191 60 PUSH1 0x20 1193 01 ADD 1194 01 ADD 1195 51 MLOAD 1196 60 PUSH1 0x00 1198 80 DUP1 1199 87 DUP8 119A 84 DUP5 119B 81 DUP2 119C 51 MLOAD 119D 81 DUP2 119E 10 LT 119F 61 PUSH2 0x11b8 11A2 57 *JUMPI 11A3 63 PUSH4 0x4e487b71 11A8 60 PUSH1 0xe0 11AA 1B SHL 11AB 60 PUSH1 0x00 11AD 52 MSTORE 11AE 60 PUSH1 0x32 11B0 60 PUSH1 0x04 11B2 52 MSTORE 11B3 60 PUSH1 0x24 11B5 60 PUSH1 0x00 11B7 FD *REVERT 11B8 5B JUMPDEST 11B9 60 PUSH1 0x20 11BB 02 MUL 11BC 60 PUSH1 0x20 11BE 01 ADD 11BF 01 ADD 11C0 51 MLOAD 11C1 81 DUP2 11C2 52 MSTORE 11C3 60 PUSH1 0x20 11C5 01 ADD 11C6 90 SWAP1 11C7 81 DUP2 11C8 52 MSTORE 11C9 60 PUSH1 0x20 11CB 01 ADD 11CC 60 PUSH1 0x00 11CE 20 SHA3 11CF 60 PUSH1 0x00 11D1 88 DUP9 11D2 60 PUSH1 0x01 11D4 60 PUSH1 0x01 11D6 60 PUSH1 0xa0 11D8 1B SHL 11D9 03 SUB 11DA 16 AND 11DB 60 PUSH1 0x01 11DD 60 PUSH1 0x01 11DF 60 PUSH1 0xa0 11E1 1B SHL 11E2 03 SUB 11E3 16 AND 11E4 81 DUP2 11E5 52 MSTORE 11E6 60 PUSH1 0x20 11E8 01 ADD 11E9 90 SWAP1 11EA 81 DUP2 11EB 52 MSTORE 11EC 60 PUSH1 0x20 11EE 01 ADD 11EF 60 PUSH1 0x00 11F1 20 SHA3 11F2 60 PUSH1 0x00 11F4 82 DUP3 11F5 82 DUP3 11F6 54 SLOAD 11F7 61 PUSH2 0x1200 11FA 91 SWAP2 11FB 90 SWAP1 11FC 61 PUSH2 0x24e7 11FF 56 *JUMP 1200 5B JUMPDEST 1201 90 SWAP1 1202 91 SWAP2 1203 55 SSTORE 1204 50 POP 1205 81 DUP2 1206 90 SWAP1 1207 50 POP 1208 61 PUSH2 0x1210 120B 81 DUP2 120C 61 PUSH2 0x25c2 120F 56 *JUMP 1210 5B JUMPDEST 1211 91 SWAP2 1212 50 POP 1213 50 POP 1214 61 PUSH2 0x1164 1217 56 *JUMP 1218 5B JUMPDEST 1219 50 POP 121A 84 DUP5 121B 60 PUSH1 0x01 121D 60 PUSH1 0x01 121F 60 PUSH1 0xa0 1221 1B SHL 1222 03 SUB 1223 16 AND 1224 60 PUSH1 0x00 1226 60 PUSH1 0x01 1228 60 PUSH1 0x01 122A 60 PUSH1 0xa0 122C 1B SHL 122D 03 SUB 122E 16 AND 122F 82 DUP3 1230 60 PUSH1 0x01 1232 60 PUSH1 0x01 1234 60 PUSH1 0xa0 1236 1B SHL 1237 03 SUB 1238 16 AND 1239 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 125A 87 DUP8 125B 87 DUP8 125C 60 PUSH1 0x40 125E 51 MLOAD 125F 61 PUSH2 0x1269 1262 92 SWAP3 1263 91 SWAP2 1264 90 SWAP1 1265 61 PUSH2 0x22ed 1268 56 *JUMP 1269 5B JUMPDEST 126A 60 PUSH1 0x40 126C 51 MLOAD 126D 80 DUP1 126E 91 SWAP2 126F 03 SUB 1270 90 SWAP1 1271 A4 LOG4 1272 61 PUSH2 0x0681 1275 81 DUP2 1276 60 PUSH1 0x00 1278 87 DUP8 1279 87 DUP8 127A 87 DUP8 127B 87 DUP8 127C 61 PUSH2 0x156e 127F 56 *JUMP label_1280: // Incoming call from 0x0ACD, returns to 0x0ACE // Inputs[5] // { // @1283 storage[0x09] // @1286 memory[0x40:0x60] // @1298 stack[-1] // @12A2 stack[-3] // @12A7 stack[-2] // } 1280 5B JUMPDEST 1281 60 PUSH1 0x09 1283 54 SLOAD 1284 60 PUSH1 0x40 1286 51 MLOAD 1287 60 PUSH1 0x00 1289 91 SWAP2 128A 60 PUSH1 0x01 128C 60 PUSH1 0x01 128E 60 PUSH1 0xa0 1290 1B SHL 1291 03 SUB 1292 16 AND 1293 90 SWAP1 1294 61 PUSH2 0x1316 1297 90 SWAP1 1298 84 DUP5 1299 90 SWAP1 129A 61 PUSH2 0x1310 129D 90 SWAP1 129E 61 PUSH2 0x12b0 12A1 90 SWAP1 12A2 89 DUP10 12A3 90 SWAP1 12A4 60 PUSH1 0x08 12A6 90 SWAP1 12A7 8A DUP11 12A8 90 SWAP1 12A9 60 PUSH1 0x20 12AB 01 ADD 12AC 61 PUSH2 0x21e0 12AF 56 *JUMP // Stack delta = +10 // Outputs[10] // { // @1289 stack[0] = 0x00 // @1293 stack[1] = (0x01 << 0xa0) - 0x01 & storage[0x09] // @1297 stack[2] = 0x1316 // @1299 stack[3] = stack[-1] // @129D stack[4] = 0x1310 // @12A1 stack[5] = 0x12b0 // @12A3 stack[6] = stack[-3] // @12A6 stack[7] = 0x08 // @12A8 stack[8] = stack[-2] // @12AB stack[9] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x21e0, returns to 0x12B0 label_12B0: // Incoming return from call to 0x21E0 at 0x12AF // Inputs[8] // { // @12B4 memory[0x40:0x60] // @12B9 stack[-1] // @12C2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @12C8 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @12F8 memory[0x40:0x60] // @130A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @130D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @130E stack[-2] // } 12B0 5B JUMPDEST 12B1 60 PUSH1 0x40 12B3 80 DUP1 12B4 51 MLOAD 12B5 60 PUSH1 0x1f 12B7 19 NOT 12B8 81 DUP2 12B9 84 DUP5 12BA 03 SUB 12BB 01 ADD 12BC 81 DUP2 12BD 52 MSTORE 12BE 82 DUP3 12BF 82 DUP3 12C0 52 MSTORE 12C1 80 DUP1 12C2 51 MLOAD 12C3 60 PUSH1 0x20 12C5 91 SWAP2 12C6 82 DUP3 12C7 01 ADD 12C8 20 SHA3 12C9 7F PUSH32 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 12EA 84 DUP5 12EB 83 DUP4 12EC 01 ADD 12ED 52 MSTORE 12EE 60 PUSH1 0x3c 12F0 80 DUP1 12F1 85 DUP6 12F2 01 ADD 12F3 91 SWAP2 12F4 90 SWAP1 12F5 91 SWAP2 12F6 52 MSTORE 12F7 82 DUP3 12F8 51 MLOAD 12F9 80 DUP1 12FA 85 DUP6 12FB 03 SUB 12FC 90 SWAP1 12FD 91 SWAP2 12FE 01 ADD 12FF 81 DUP2 1300 52 MSTORE 1301 60 PUSH1 0x5c 1303 90 SWAP1 1304 93 SWAP4 1305 01 ADD 1306 90 SWAP1 1307 91 SWAP2 1308 52 MSTORE 1309 81 DUP2 130A 51 MLOAD 130B 91 SWAP2 130C 01 ADD 130D 20 SHA3 130E 90 SWAP1 130F 56 *JUMP // Stack delta = -1 // Outputs[7] // { // @12BD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + ~0x1f // @12C0 memory[0x40:0x60] = stack[-1] // @12ED memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000 // @12F6 memory[stack[-1] + 0x3c:stack[-1] + 0x3c + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @1300 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3c + (stack[-1] - memory[0x40:0x60]) // @1308 memory[0x40:0x60] = stack[-1] + 0x5c // @130E stack[-2] = keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to stack[-2] label_1310: // Incoming return from call to 0x12B0 at 0x12AF // Inputs[2] // { // @1311 stack[-1] // @1311 stack[-2] // } 1310 5B JUMPDEST 1311 90 SWAP1 1312 61 PUSH2 0x16d9 1315 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1311 stack[-1] = stack[-2] // @1311 stack[-2] = stack[-1] // } // Block ends with unconditional jump to 0x16d9 label_1316: // Incoming return from call to 0x1310 at 0x12AF // Inputs[4] // { // @131F stack[-1] // @1320 stack[-2] // @1321 stack[-7] // @1322 stack[-6] // } 1316 5B JUMPDEST 1317 60 PUSH1 0x01 1319 60 PUSH1 0x01 131B 60 PUSH1 0xa0 131D 1B SHL 131E 03 SUB 131F 16 AND 1320 14 EQ 1321 94 SWAP5 1322 93 SWAP4 1323 50 POP 1324 50 POP 1325 50 POP 1326 50 POP 1327 56 *JUMP // Stack delta = -6 // Outputs[1] { @1321 stack[-7] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1328: // Incoming jump from 0x0B50 // Inputs[1] { @1331 stack[-4] } 1328 5B JUMPDEST 1329 60 PUSH1 0x01 132B 60 PUSH1 0x01 132D 60 PUSH1 0xa0 132F 1B SHL 1330 03 SUB 1331 84 DUP5 1332 16 AND 1333 61 PUSH2 0x134e 1336 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x134e, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1337: // Incoming jump from 0x1336, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1339 memory[0x40:0x60] } 1337 60 PUSH1 0x40 1339 51 MLOAD 133A 62 PUSH3 0x461bcd 133E 60 PUSH1 0xe5 1340 1B SHL 1341 81 DUP2 1342 52 MSTORE 1343 60 PUSH1 0x04 1345 01 ADD 1346 61 PUSH2 0x0377 1349 90 SWAP1 134A 61 PUSH2 0x2482 134D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1342 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1349 stack[0] = 0x0377 // @1349 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2482, returns to 0x0377 label_134E: // Incoming jump from 0x1336, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @134F msg.sender // @1356 stack[-4] // @135A stack[-3] // } 134E 5B JUMPDEST 134F 33 CALLER 1350 61 PUSH2 0x1368 1353 81 DUP2 1354 60 PUSH1 0x00 1356 87 DUP8 1357 61 PUSH2 0x135f 135A 88 DUP9 135B 61 PUSH2 0x1515 135E 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @134F stack[0] = msg.sender // @1350 stack[1] = 0x1368 // @1353 stack[2] = msg.sender // @1354 stack[3] = 0x00 // @1356 stack[4] = stack[-4] // @1357 stack[5] = 0x135f // @135A stack[6] = stack[-3] // } // Block ends with call to 0x1515, returns to 0x135F label_135F: // Incoming return from call to 0x1515 at 0x142D // Incoming return from call to 0x1515 at 0x135E // Inputs[1] { @1363 stack[-8] } 135F 5B JUMPDEST 1360 61 PUSH2 0x0681 1363 88 DUP9 1364 61 PUSH2 0x1515 1367 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1360 stack[0] = 0x0681 // @1363 stack[1] = stack[-8] // } // Block ends with call to 0x1515, returns to 0x0681 label_1368: // Incoming return from call to 0x135F at 0x135E // Inputs[6] // { // @136B stack[-4] // @1377 memory[0x00:0x40] // @1380 stack[-5] // @1388 memory[0x00:0x40] // @138A storage[keccak256(memory[0x00:0x40])] // @138B stack[-3] // } 1368 5B JUMPDEST 1369 60 PUSH1 0x00 136B 84 DUP5 136C 81 DUP2 136D 52 MSTORE 136E 60 PUSH1 0x20 1370 81 DUP2 1371 81 DUP2 1372 52 MSTORE 1373 60 PUSH1 0x40 1375 80 DUP1 1376 83 DUP4 1377 20 SHA3 1378 60 PUSH1 0x01 137A 60 PUSH1 0x01 137C 60 PUSH1 0xa0 137E 1B SHL 137F 03 SUB 1380 89 DUP10 1381 16 AND 1382 84 DUP5 1383 52 MSTORE 1384 90 SWAP1 1385 91 SWAP2 1386 52 MSTORE 1387 81 DUP2 1388 20 SHA3 1389 80 DUP1 138A 54 SLOAD 138B 85 DUP6 138C 92 SWAP3 138D 90 SWAP1 138E 61 PUSH2 0x1398 1391 90 SWAP1 1392 84 DUP5 1393 90 SWAP1 1394 61 PUSH2 0x24e7 1397 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @136D memory[0x00:0x20] = stack[-4] // @1372 memory[0x20:0x40] = 0x00 // @1383 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1386 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1388 stack[1] = keccak256(memory[0x00:0x40]) // @138C stack[0] = stack[-3] // @138D stack[2] = 0x00 // @1391 stack[3] = 0x1398 // @1393 stack[4] = stack[-3] // @1393 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x24e7, returns to 0x1398 label_1398: // Incoming return from call to 0x24E7 at 0x1397 // Inputs[11] // { // @1399 stack[-2] // @1399 stack[-1] // @139A stack[-3] // @13A1 memory[0x40:0x60] // @13A2 stack[-8] // @13A9 stack[-7] // @13B5 stack[-9] // @13BC stack[-5] // @13E4 memory[0x40:0x60] // @13E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @13F3 stack[-6] // } 1398 5B JUMPDEST 1399 90 SWAP1 139A 91 SWAP2 139B 55 SSTORE 139C 50 POP 139D 50 POP 139E 60 PUSH1 0x40 13A0 80 DUP1 13A1 51 MLOAD 13A2 85 DUP6 13A3 81 DUP2 13A4 52 MSTORE 13A5 60 PUSH1 0x20 13A7 81 DUP2 13A8 01 ADD 13A9 85 DUP6 13AA 90 SWAP1 13AB 52 MSTORE 13AC 60 PUSH1 0x01 13AE 60 PUSH1 0x01 13B0 60 PUSH1 0xa0 13B2 1B SHL 13B3 03 SUB 13B4 80 DUP1 13B5 88 DUP9 13B6 16 AND 13B7 92 SWAP3 13B8 60 PUSH1 0x00 13BA 92 SWAP3 13BB 91 SWAP2 13BC 85 DUP6 13BD 16 AND 13BE 91 SWAP2 13BF 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 13E0 91 SWAP2 13E1 01 ADD 13E2 60 PUSH1 0x40 13E4 51 MLOAD 13E5 80 DUP1 13E6 91 SWAP2 13E7 03 SUB 13E8 90 SWAP1 13E9 A4 LOG4 13EA 61 PUSH2 0x0681 13ED 81 DUP2 13EE 60 PUSH1 0x00 13F0 87 DUP8 13F1 87 DUP8 13F2 87 DUP8 13F3 87 DUP8 13F4 61 PUSH2 0x16f5 13F7 56 *JUMP // Stack delta = +3 // Outputs[11] // { // @139B storage[stack[-3]] = stack[-1] // @13A4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-8] // @13AB memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-7] // @13E9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, stack[-5] & (0x01 << 0xa0) - 0x01, 0x00, stack[-9] & (0x01 << 0xa0) - 0x01]); // @13EA stack[-4] = 0x0681 // @13ED stack[-3] = stack[-5] // @13EE stack[-2] = 0x00 // @13F0 stack[-1] = stack[-9] // @13F1 stack[0] = stack[-8] // @13F2 stack[1] = stack[-7] // @13F3 stack[2] = stack[-6] // } // Block ends with call to 0x16f5, returns to 0x0681 label_13F8: // Incoming call from 0x0BD7, returns to 0x0681 // Inputs[1] { @1401 stack[-4] } 13F8 5B JUMPDEST 13F9 60 PUSH1 0x01 13FB 60 PUSH1 0x01 13FD 60 PUSH1 0xa0 13FF 1B SHL 1400 03 SUB 1401 84 DUP5 1402 16 AND 1403 61 PUSH2 0x141e 1406 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x141e, if stack[-4] & (0x01 << 0xa0) - 0x01 label_1407: // Incoming jump from 0x1406, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1409 memory[0x40:0x60] } 1407 60 PUSH1 0x40 1409 51 MLOAD 140A 62 PUSH3 0x461bcd 140E 60 PUSH1 0xe5 1410 1B SHL 1411 81 DUP2 1412 52 MSTORE 1413 60 PUSH1 0x04 1415 01 ADD 1416 61 PUSH2 0x0377 1419 90 SWAP1 141A 61 PUSH2 0x2376 141D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1412 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1419 stack[0] = 0x0377 // @1419 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2376, returns to 0x0377 label_141E: // Incoming jump from 0x1406, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @141F msg.sender // @1424 stack[-5] // @1425 stack[-4] // @1429 stack[-3] // } 141E 5B JUMPDEST 141F 33 CALLER 1420 61 PUSH2 0x142e 1423 81 DUP2 1424 87 DUP8 1425 87 DUP8 1426 61 PUSH2 0x135f 1429 88 DUP9 142A 61 PUSH2 0x1515 142D 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @141F stack[0] = msg.sender // @1420 stack[1] = 0x142e // @1423 stack[2] = msg.sender // @1424 stack[3] = stack[-5] // @1425 stack[4] = stack[-4] // @1426 stack[5] = 0x135f // @1429 stack[6] = stack[-3] // } // Block ends with call to 0x1515, returns to 0x135F label_142E: // Incoming return from call to 0x135F at 0x142D // Inputs[6] // { // @1431 stack[-4] // @143D memory[0x00:0x40] // @1446 stack[-6] // @144E memory[0x00:0x40] // @144F storage[keccak256(memory[0x00:0x40])] // @1450 stack[-3] // } 142E 5B JUMPDEST 142F 60 PUSH1 0x00 1431 84 DUP5 1432 81 DUP2 1433 52 MSTORE 1434 60 PUSH1 0x20 1436 81 DUP2 1437 81 DUP2 1438 52 MSTORE 1439 60 PUSH1 0x40 143B 80 DUP1 143C 83 DUP4 143D 20 SHA3 143E 60 PUSH1 0x01 1440 60 PUSH1 0x01 1442 60 PUSH1 0xa0 1444 1B SHL 1445 03 SUB 1446 8A DUP11 1447 16 AND 1448 84 DUP5 1449 52 MSTORE 144A 90 SWAP1 144B 91 SWAP2 144C 52 MSTORE 144D 90 SWAP1 144E 20 SHA3 144F 54 SLOAD 1450 83 DUP4 1451 81 DUP2 1452 10 LT 1453 15 ISZERO 1454 61 PUSH2 0x146f 1457 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @1433 memory[0x00:0x20] = stack[-4] // @1438 memory[0x20:0x40] = 0x00 // @1449 memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @144C memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @144F stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x146f, if !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) label_1458: // Incoming jump from 0x1457, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[1] { @145A memory[0x40:0x60] } 1458 60 PUSH1 0x40 145A 51 MLOAD 145B 62 PUSH3 0x461bcd 145F 60 PUSH1 0xe5 1461 1B SHL 1462 81 DUP2 1463 52 MSTORE 1464 60 PUSH1 0x04 1466 01 ADD 1467 61 PUSH2 0x0377 146A 90 SWAP1 146B 61 PUSH2 0x23bb 146E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1463 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @146A stack[0] = 0x0377 // @146A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x23bb, returns to 0x0377 label_146F: // Incoming jump from 0x1457, if !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[9] // { // @1472 stack[-5] // @147E memory[0x00:0x40] // @1487 stack[-7] // @1490 memory[0x00:0x40] // @1491 stack[-4] // @1492 stack[-1] // @1497 stack[-6] // @149C memory[0x00:0x40] // @149E storage[keccak256(memory[0x00:0x40])] // } 146F 5B JUMPDEST 1470 60 PUSH1 0x00 1472 85 DUP6 1473 81 DUP2 1474 52 MSTORE 1475 60 PUSH1 0x20 1477 81 DUP2 1478 81 DUP2 1479 52 MSTORE 147A 60 PUSH1 0x40 147C 80 DUP1 147D 83 DUP4 147E 20 SHA3 147F 60 PUSH1 0x01 1481 60 PUSH1 0x01 1483 60 PUSH1 0xa0 1485 1B SHL 1486 03 SUB 1487 8B DUP12 1488 81 DUP2 1489 16 AND 148A 85 DUP6 148B 52 MSTORE 148C 92 SWAP3 148D 52 MSTORE 148E 80 DUP1 148F 83 DUP4 1490 20 SHA3 1491 87 DUP8 1492 85 DUP6 1493 03 SUB 1494 90 SWAP1 1495 55 SSTORE 1496 90 SWAP1 1497 88 DUP9 1498 16 AND 1499 82 DUP3 149A 52 MSTORE 149B 81 DUP2 149C 20 SHA3 149D 80 DUP1 149E 54 SLOAD 149F 86 DUP7 14A0 92 SWAP3 14A1 90 SWAP1 14A2 61 PUSH2 0x14ac 14A5 90 SWAP1 14A6 84 DUP5 14A7 90 SWAP1 14A8 61 PUSH2 0x24e7 14AB 56 *JUMP // Stack delta = +6 // Outputs[12] // { // @1474 memory[0x00:0x20] = stack[-5] // @1479 memory[0x20:0x40] = 0x00 // @148B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-7] // @148D memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1495 storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-4] // @149A memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @149C stack[1] = keccak256(memory[0x00:0x40]) // @14A0 stack[0] = stack[-4] // @14A1 stack[2] = 0x00 // @14A5 stack[3] = 0x14ac // @14A7 stack[4] = stack[-4] // @14A7 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x24e7, returns to 0x14AC label_14AC: // Incoming return from call to 0x24E7 at 0x14AB // Inputs[12] // { // @14AD stack[-2] // @14AD stack[-1] // @14AE stack[-3] // @14B5 memory[0x40:0x60] // @14B6 stack[-9] // @14BD stack[-8] // @14C9 stack[-10] // @14CC stack[-11] // @14D1 stack[-6] // @14F9 memory[0x40:0x60] // @14FE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1507 stack[-7] // } 14AC 5B JUMPDEST 14AD 90 SWAP1 14AE 91 SWAP2 14AF 55 SSTORE 14B0 50 POP 14B1 50 POP 14B2 60 PUSH1 0x40 14B4 80 DUP1 14B5 51 MLOAD 14B6 86 DUP7 14B7 81 DUP2 14B8 52 MSTORE 14B9 60 PUSH1 0x20 14BB 81 DUP2 14BC 01 ADD 14BD 86 DUP7 14BE 90 SWAP1 14BF 52 MSTORE 14C0 60 PUSH1 0x01 14C2 60 PUSH1 0x01 14C4 60 PUSH1 0xa0 14C6 1B SHL 14C7 03 SUB 14C8 80 DUP1 14C9 89 DUP10 14CA 16 AND 14CB 92 SWAP3 14CC 8A DUP11 14CD 82 DUP3 14CE 16 AND 14CF 92 SWAP3 14D0 91 SWAP2 14D1 86 DUP7 14D2 16 AND 14D3 91 SWAP2 14D4 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 14F5 91 SWAP2 14F6 01 ADD 14F7 60 PUSH1 0x40 14F9 51 MLOAD 14FA 80 DUP1 14FB 91 SWAP2 14FC 03 SUB 14FD 90 SWAP1 14FE A4 LOG4 14FF 61 PUSH2 0x150c 1502 82 DUP3 1503 88 DUP9 1504 88 DUP9 1505 88 DUP9 1506 88 DUP9 1507 88 DUP9 1508 61 PUSH2 0x16f5 150B 56 *JUMP // Stack delta = +3 // Outputs[11] // { // @14AF storage[stack[-3]] = stack[-1] // @14B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-9] // @14BF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-8] // @14FE log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]], [0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-11] & (0x01 << 0xa0) - 0x01, stack[-10] & (0x01 << 0xa0) - 0x01]); // @14FF stack[-4] = 0x150c // @1502 stack[-3] = stack[-6] // @1503 stack[-2] = stack[-11] // @1504 stack[-1] = stack[-10] // @1505 stack[0] = stack[-9] // @1506 stack[1] = stack[-8] // @1507 stack[2] = stack[-7] // } // Block ends with call to 0x16f5, returns to 0x150C label_150C: // Incoming return from call to 0x16F5 at 0x150B // Incoming jump from 0x17A7, if 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1514 stack[-8] } 150C 5B JUMPDEST 150D 50 POP 150E 50 POP 150F 50 POP 1510 50 POP 1511 50 POP 1512 50 POP 1513 50 POP 1514 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_1515: // Incoming call from 0x0E07, returns to 0x0E08 // Incoming call from 0x142D, returns to 0x135F // Incoming call from 0x1367, returns to 0x0681 // Incoming call from 0x0E10, returns to 0x0E11 // Incoming call from 0x135E, returns to 0x135F // Inputs[5] // { // @1519 memory[0x40:0x60] // @1533 msg.data.length // @1535 msg.data[msg.data.length:msg.data.length + 0x20] // @153C stack[-1] // @1541 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1515 5B JUMPDEST 1516 60 PUSH1 0x40 1518 80 DUP1 1519 51 MLOAD 151A 60 PUSH1 0x01 151C 80 DUP1 151D 82 DUP3 151E 52 MSTORE 151F 81 DUP2 1520 83 DUP4 1521 01 ADD 1522 90 SWAP1 1523 92 SWAP3 1524 52 MSTORE 1525 60 PUSH1 0x60 1527 91 SWAP2 1528 60 PUSH1 0x00 152A 91 SWAP2 152B 90 SWAP1 152C 60 PUSH1 0x20 152E 80 DUP1 152F 83 DUP4 1530 01 ADD 1531 90 SWAP1 1532 80 DUP1 1533 36 CALLDATASIZE 1534 83 DUP4 1535 37 CALLDATACOPY 1536 01 ADD 1537 90 SWAP1 1538 50 POP 1539 50 POP 153A 90 SWAP1 153B 50 POP 153C 82 DUP3 153D 81 DUP2 153E 60 PUSH1 0x00 1540 81 DUP2 1541 51 MLOAD 1542 81 DUP2 1543 10 LT 1544 61 PUSH2 0x155d 1547 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @151E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1524 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1527 stack[0] = 0x60 // @1535 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[msg.data.length:msg.data.length + 0x20] // @153A stack[1] = memory[0x40:0x60] // @153C stack[2] = stack[-1] // @153D stack[3] = memory[0x40:0x60] // @153E stack[4] = 0x00 // } // Block ends with conditional jump to 0x155d, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_1548: // Incoming jump from 0x1547, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[1] { @155C memory[0x00:0x24] } 1548 63 PUSH4 0x4e487b71 154D 60 PUSH1 0xe0 154F 1B SHL 1550 60 PUSH1 0x00 1552 52 MSTORE 1553 60 PUSH1 0x32 1555 60 PUSH1 0x04 1557 52 MSTORE 1558 60 PUSH1 0x24 155A 60 PUSH1 0x00 155C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1552 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1557 memory[0x04:0x24] = 0x32 // @155C revert(memory[0x00:0x24]); // } // Block terminates label_155D: // Incoming jump from 0x1547, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[6] // { // @1560 stack[-1] // @1563 stack[-2] // @1568 stack[-3] // @1569 stack[-7] // @1569 stack[-4] // @156A stack[-6] // } 155D 5B JUMPDEST 155E 60 PUSH1 0x20 1560 90 SWAP1 1561 81 DUP2 1562 02 MUL 1563 91 SWAP2 1564 90 SWAP1 1565 91 SWAP2 1566 01 ADD 1567 01 ADD 1568 52 MSTORE 1569 92 SWAP3 156A 91 SWAP2 156B 50 POP 156C 50 POP 156D 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @1568 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @1569 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] 156E 5B JUMPDEST 156F 60 PUSH1 0x01 1571 60 PUSH1 0x01 1573 60 PUSH1 0xa0 1575 1B SHL 1576 03 SUB 1577 84 DUP5 1578 16 AND 1579 3B EXTCODESIZE 157A 15 ISZERO 157B 61 PUSH2 0x10bf 157E 57 *JUMPI 157F 60 PUSH1 0x40 1581 51 MLOAD 1582 63 PUSH4 0xbc197c81 1587 60 PUSH1 0xe0 1589 1B SHL 158A 81 DUP2 158B 52 MSTORE 158C 60 PUSH1 0x01 158E 60 PUSH1 0x01 1590 60 PUSH1 0xa0 1592 1B SHL 1593 03 SUB 1594 85 DUP6 1595 16 AND 1596 90 SWAP1 1597 63 PUSH4 0xbc197c81 159C 90 SWAP1 159D 61 PUSH2 0x15b2 15A0 90 SWAP1 15A1 89 DUP10 15A2 90 SWAP1 15A3 89 DUP10 15A4 90 SWAP1 15A5 88 DUP9 15A6 90 SWAP1 15A7 88 DUP9 15A8 90 SWAP1 15A9 88 DUP9 15AA 90 SWAP1 15AB 60 PUSH1 0x04 15AD 01 ADD 15AE 61 PUSH2 0x2237 15B1 56 *JUMP 15B2 5B JUMPDEST 15B3 60 PUSH1 0x20 15B5 60 PUSH1 0x40 15B7 51 MLOAD 15B8 80 DUP1 15B9 83 DUP4 15BA 03 SUB 15BB 81 DUP2 15BC 60 PUSH1 0x00 15BE 87 DUP8 15BF 80 DUP1 15C0 3B EXTCODESIZE 15C1 15 ISZERO 15C2 80 DUP1 15C3 15 ISZERO 15C4 61 PUSH2 0x15cc 15C7 57 *JUMPI 15C8 60 PUSH1 0x00 15CA 80 DUP1 15CB FD *REVERT 15CC 5B JUMPDEST 15CD 50 POP 15CE 5A GAS 15CF F1 CALL 15D0 92 SWAP3 15D1 50 POP 15D2 50 POP 15D3 50 POP 15D4 80 DUP1 15D5 15 ISZERO 15D6 61 PUSH2 0x15fc 15D9 57 *JUMPI 15DA 50 POP 15DB 60 PUSH1 0x40 15DD 80 DUP1 15DE 51 MLOAD 15DF 60 PUSH1 0x1f 15E1 3D RETURNDATASIZE 15E2 90 SWAP1 15E3 81 DUP2 15E4 01 ADD 15E5 60 PUSH1 0x1f 15E7 19 NOT 15E8 16 AND 15E9 82 DUP3 15EA 01 ADD 15EB 90 SWAP1 15EC 92 SWAP3 15ED 52 MSTORE 15EE 61 PUSH2 0x15f9 15F1 91 SWAP2 15F2 81 DUP2 15F3 01 ADD 15F4 90 SWAP1 15F5 61 PUSH2 0x2006 15F8 56 *JUMP 15F9 5B JUMPDEST 15FA 60 PUSH1 0x01 15FC 5B JUMPDEST 15FD 61 PUSH2 0x16a9 1600 57 *JUMPI 1601 61 PUSH2 0x1608 1604 61 PUSH2 0x2633 1607 56 *JUMP label_1608: // Incoming return from call to 0x2633 at 0x178E // Inputs[1] { @1609 stack[-1] } 1608 5B JUMPDEST 1609 80 DUP1 160A 63 PUSH4 0x08c379a0 160F 14 EQ 1610 15 ISZERO 1611 61 PUSH2 0x1642 1614 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1642, if !(0x08c379a0 == stack[-1]) label_1615: // Incoming jump from 0x1614, if not !(0x08c379a0 == stack[-1]) 1615 50 POP 1616 61 PUSH2 0x161d 1619 61 PUSH2 0x264b 161C 56 *JUMP // Stack delta = +0 // Outputs[1] { @1616 stack[-1] = 0x161d } // Block ends with call to 0x264b, returns to 0x161D label_161D: // Incoming return from call to 0x264B at 0x161C // Incoming return from call to 0x264B at 0x161C // Inputs[1] { @161E stack[-1] } 161D 5B JUMPDEST 161E 80 DUP1 161F 61 PUSH2 0x1628 1622 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1628, if stack[-1] label_1623: // Incoming jump from 0x1622, if not stack[-1] 1623 50 POP 1624 61 PUSH2 0x1644 1627 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x1644 label_1628: // Incoming jump from 0x1622, if stack[-1] // Inputs[2] // { // @1629 stack[-1] // @162C memory[0x40:0x60] // } 1628 5B JUMPDEST 1629 80 DUP1 162A 60 PUSH1 0x40 162C 51 MLOAD 162D 62 PUSH3 0x461bcd 1631 60 PUSH1 0xe5 1633 1B SHL 1634 81 DUP2 1635 52 MSTORE 1636 60 PUSH1 0x04 1638 01 ADD 1639 61 PUSH2 0x0377 163C 91 SWAP2 163D 90 SWAP1 163E 61 PUSH2 0x231b 1641 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1635 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @163C stack[0] = 0x0377 // @163D stack[1] = stack[-1] // @163D stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x231b label_1642: // Incoming jump from 0x1614, if !(0x08c379a0 == stack[-1]) // Inputs[1] { @1647 memory[0x40:0x60] } 1642 5B JUMPDEST 1643 50 POP 1644 5B JUMPDEST 1645 60 PUSH1 0x40 1647 51 MLOAD 1648 62 PUSH3 0x461bcd 164C 60 PUSH1 0xe5 164E 1B SHL 164F 81 DUP2 1650 52 MSTORE 1651 60 PUSH1 0x20 1653 60 PUSH1 0x04 1655 82 DUP3 1656 01 ADD 1657 52 MSTORE 1658 60 PUSH1 0x34 165A 60 PUSH1 0x24 165C 82 DUP3 165D 01 ADD 165E 52 MSTORE 165F 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 1680 60 PUSH1 0x44 1682 82 DUP3 1683 01 ADD 1684 52 MSTORE 1685 73 PUSH20 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 169A 60 PUSH1 0x61 169C 1B SHL 169D 60 PUSH1 0x64 169F 82 DUP3 16A0 01 ADD 16A1 52 MSTORE 16A2 60 PUSH1 0x84 16A4 01 ADD 16A5 61 PUSH2 0x0377 16A8 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @1650 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1657 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @165E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x34 // @1684 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 // @16A1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x61 // @16A4 stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 16A9 5B JUMPDEST 16AA 60 PUSH1 0x01 16AC 60 PUSH1 0x01 16AE 60 PUSH1 0xe0 16B0 1B SHL 16B1 03 SUB 16B2 19 NOT 16B3 81 DUP2 16B4 16 AND 16B5 63 PUSH4 0xbc197c81 16BA 60 PUSH1 0xe0 16BC 1B SHL 16BD 14 EQ 16BE 61 PUSH2 0x150c 16C1 57 *JUMPI 16C2 60 PUSH1 0x40 16C4 51 MLOAD 16C5 62 PUSH3 0x461bcd 16C9 60 PUSH1 0xe5 16CB 1B SHL 16CC 81 DUP2 16CD 52 MSTORE 16CE 60 PUSH1 0x04 16D0 01 ADD 16D1 61 PUSH2 0x0377 16D4 90 SWAP1 16D5 61 PUSH2 0x232e 16D8 56 *JUMP label_16D9: // Incoming jump from 0x1315 // Inputs[2] // { // @16E2 stack[-2] // @16E3 stack[-1] // } 16D9 5B JUMPDEST 16DA 60 PUSH1 0x00 16DC 80 DUP1 16DD 60 PUSH1 0x00 16DF 61 PUSH2 0x16e8 16E2 85 DUP6 16E3 85 DUP6 16E4 61 PUSH2 0x17bf 16E7 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @16DA stack[0] = 0x00 // @16DC stack[1] = 0x00 // @16DD stack[2] = 0x00 // @16DF stack[3] = 0x16e8 // @16E2 stack[4] = stack[-2] // @16E3 stack[5] = stack[-1] // } // Block ends with call to 0x17bf, returns to 0x16E8 label_16E8: // Incoming return from call to 0x17BF at 0x16E7 // Incoming return from call to 0x17BF at 0x16E7 // Inputs[4] // { // @16E9 stack[-3] // @16E9 stack[-1] // @16EB stack[-2] // @16EB stack[-4] // } 16E8 5B JUMPDEST 16E9 91 SWAP2 16EA 50 POP 16EB 91 SWAP2 16EC 50 POP 16ED 61 PUSH2 0x07e2 16F0 81 DUP2 16F1 61 PUSH2 0x182f 16F4 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @16E9 stack[-3] = stack[-1] // @16EB stack[-4] = stack[-2] // @16ED stack[-2] = 0x07e2 // @16F0 stack[-1] = stack[-1] // } // Block ends with call to 0x182f, returns to 0x07E2 label_16F5: // Incoming call from 0x150B, returns to 0x150C // Incoming call from 0x13F7, returns to 0x0681 // Inputs[2] // { // @16FE stack[-4] // @1700 address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 16F5 5B JUMPDEST 16F6 60 PUSH1 0x01 16F8 60 PUSH1 0x01 16FA 60 PUSH1 0xa0 16FC 1B SHL 16FD 03 SUB 16FE 84 DUP5 16FF 16 AND 1700 3B EXTCODESIZE 1701 15 ISZERO 1702 61 PUSH2 0x10bf 1705 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10bf, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_1706: // Incoming jump from 0x1705, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[7] // { // @1708 memory[0x40:0x60] // @171B stack[-4] // @1728 stack[-6] // @172A stack[-5] // @172C stack[-3] // @172E stack[-2] // @1730 stack[-1] // } 1706 60 PUSH1 0x40 1708 51 MLOAD 1709 63 PUSH4 0xf23a6e61 170E 60 PUSH1 0xe0 1710 1B SHL 1711 81 DUP2 1712 52 MSTORE 1713 60 PUSH1 0x01 1715 60 PUSH1 0x01 1717 60 PUSH1 0xa0 1719 1B SHL 171A 03 SUB 171B 85 DUP6 171C 16 AND 171D 90 SWAP1 171E 63 PUSH4 0xf23a6e61 1723 90 SWAP1 1724 61 PUSH2 0x1739 1727 90 SWAP1 1728 89 DUP10 1729 90 SWAP1 172A 89 DUP10 172B 90 SWAP1 172C 88 DUP9 172D 90 SWAP1 172E 88 DUP9 172F 90 SWAP1 1730 88 DUP9 1731 90 SWAP1 1732 60 PUSH1 0x04 1734 01 ADD 1735 61 PUSH2 0x2295 1738 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1712 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf23a6e61 << 0xe0 // @171D stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1723 stack[1] = 0xf23a6e61 // @1727 stack[2] = 0x1739 // @1729 stack[3] = stack[-6] // @172B stack[4] = stack[-5] // @172D stack[5] = stack[-3] // @172F stack[6] = stack[-2] // @1731 stack[7] = stack[-1] // @1734 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2295, returns to 0x1739 label_1739: // Incoming return from call to 0x2295 at 0x1738 // Inputs[4] // { // @173E memory[0x40:0x60] // @1740 stack[-1] // @1745 stack[-3] // @1747 address(stack[-3]).code.length // } 1739 5B JUMPDEST 173A 60 PUSH1 0x20 173C 60 PUSH1 0x40 173E 51 MLOAD 173F 80 DUP1 1740 83 DUP4 1741 03 SUB 1742 81 DUP2 1743 60 PUSH1 0x00 1745 87 DUP8 1746 80 DUP1 1747 3B EXTCODESIZE 1748 15 ISZERO 1749 80 DUP1 174A 15 ISZERO 174B 61 PUSH2 0x1753 174E 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @173A stack[0] = 0x20 // @173E stack[1] = memory[0x40:0x60] // @1741 stack[2] = stack[-1] - memory[0x40:0x60] // @1742 stack[3] = memory[0x40:0x60] // @1743 stack[4] = 0x00 // @1745 stack[5] = stack[-3] // @1748 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1753, if !!address(stack[-3]).code.length label_174F: // Incoming jump from 0x174E, if not !!address(stack[-3]).code.length // Inputs[1] { @1752 memory[0x00:0x00] } 174F 60 PUSH1 0x00 1751 80 DUP1 1752 FD *REVERT // Stack delta = +0 // Outputs[1] { @1752 revert(memory[0x00:0x00]); } // Block terminates label_1753: // Incoming jump from 0x174E, if !!address(stack[-3]).code.length // Inputs[10] // { // @1755 msg.gas // @1756 stack[-5] // @1756 memory[stack[-4]:stack[-4] + stack[-5]] // @1756 stack[-4] // @1756 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1756 stack[-7] // @1756 stack[-6] // @1756 stack[-2] // @1756 stack[-3] // @1757 stack[-10] // } 1753 5B JUMPDEST 1754 50 POP 1755 5A GAS 1756 F1 CALL 1757 92 SWAP3 1758 50 POP 1759 50 POP 175A 50 POP 175B 80 DUP1 175C 15 ISZERO 175D 61 PUSH2 0x1783 1760 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1756 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1757 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 0x1783, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1761: // Incoming jump from 0x1760, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1765 memory[0x40:0x60] // @1768 returndata.length // } 1761 50 POP 1762 60 PUSH1 0x40 1764 80 DUP1 1765 51 MLOAD 1766 60 PUSH1 0x1f 1768 3D RETURNDATASIZE 1769 90 SWAP1 176A 81 DUP2 176B 01 ADD 176C 60 PUSH1 0x1f 176E 19 NOT 176F 16 AND 1770 82 DUP3 1771 01 ADD 1772 90 SWAP1 1773 92 SWAP3 1774 52 MSTORE 1775 61 PUSH2 0x1780 1778 91 SWAP2 1779 81 DUP2 177A 01 ADD 177B 90 SWAP1 177C 61 PUSH2 0x2006 177F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1774 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1778 stack[-1] = 0x1780 // @177B stack[1] = memory[0x40:0x60] // @177B stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2006 1780 5B JUMPDEST 1781 60 PUSH1 0x01 label_1783: // Incoming jump from 0x1760, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1787 stack[-1] } 1783 5B JUMPDEST 1784 61 PUSH2 0x178f 1787 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x178f, if stack[-1] label_1788: // Incoming jump from 0x1787, if not stack[-1] 1788 61 PUSH2 0x1608 178B 61 PUSH2 0x2633 178E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1788 stack[0] = 0x1608 } // Block ends with call to 0x2633, returns to 0x1608 label_178F: // Incoming jump from 0x1787, if stack[-1] // Inputs[1] { @1799 stack[-1] } 178F 5B JUMPDEST 1790 60 PUSH1 0x01 1792 60 PUSH1 0x01 1794 60 PUSH1 0xe0 1796 1B SHL 1797 03 SUB 1798 19 NOT 1799 81 DUP2 179A 16 AND 179B 63 PUSH4 0xf23a6e61 17A0 60 PUSH1 0xe0 17A2 1B SHL 17A3 14 EQ 17A4 61 PUSH2 0x150c 17A7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x150c, if 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_17A8: // Incoming jump from 0x17A7, if not 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @17AA memory[0x40:0x60] } 17A8 60 PUSH1 0x40 17AA 51 MLOAD 17AB 62 PUSH3 0x461bcd 17AF 60 PUSH1 0xe5 17B1 1B SHL 17B2 81 DUP2 17B3 52 MSTORE 17B4 60 PUSH1 0x04 17B6 01 ADD 17B7 61 PUSH2 0x0377 17BA 90 SWAP1 17BB 61 PUSH2 0x232e 17BE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @17B3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @17BA stack[0] = 0x0377 // @17BA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x232e, returns to 0x0377 label_17BF: // Incoming call from 0x16E7, returns to 0x16E8 // Inputs[2] // { // @17C3 stack[-1] // @17C4 memory[stack[-1]:stack[-1] + 0x20] // } 17BF 5B JUMPDEST 17C0 60 PUSH1 0x00 17C2 80 DUP1 17C3 82 DUP3 17C4 51 MLOAD 17C5 60 PUSH1 0x41 17C7 14 EQ 17C8 15 ISZERO 17C9 61 PUSH2 0x17f6 17CC 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @17C0 stack[0] = 0x00 // @17C2 stack[1] = 0x00 // } // Block ends with conditional jump to 0x17f6, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) label_17CD: // Incoming jump from 0x17CC, if not !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[5] // { // @17CF stack[-3] // @17D1 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @17D6 memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @17DB memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] // @17E2 stack[-4] // } 17CD 60 PUSH1 0x20 17CF 83 DUP4 17D0 01 ADD 17D1 51 MLOAD 17D2 60 PUSH1 0x40 17D4 84 DUP5 17D5 01 ADD 17D6 51 MLOAD 17D7 60 PUSH1 0x60 17D9 85 DUP6 17DA 01 ADD 17DB 51 MLOAD 17DC 60 PUSH1 0x00 17DE 1A BYTE 17DF 61 PUSH2 0x17ea 17E2 87 DUP8 17E3 82 DUP3 17E4 85 DUP6 17E5 85 DUP6 17E6 61 PUSH2 0x1a30 17E9 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @17D1 stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @17D6 stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @17DE stack[2] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @17DF stack[3] = 0x17ea // @17E2 stack[4] = stack[-4] // @17E3 stack[5] = byte(memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20], 0x00) // @17E4 stack[6] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @17E5 stack[7] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x1a30, returns to 0x17EA label_17EA: // Incoming return from call to 0x1A30 at 0x17E9 // Inputs[4] // { // @17EB stack[-6] // @17EB stack[-1] // @17ED stack[-7] // @17ED stack[-2] // } 17EA 5B JUMPDEST 17EB 94 SWAP5 17EC 50 POP 17ED 94 SWAP5 17EE 50 POP 17EF 50 POP 17F0 50 POP 17F1 50 POP 17F2 61 PUSH2 0x1828 17F5 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @17EB stack[-6] = stack[-1] // @17ED stack[-7] = stack[-2] // } // Block ends with unconditional jump to 0x1828 label_17F6: // Incoming jump from 0x17CC, if !(0x41 == memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @17F7 stack[-3] // @17F8 memory[stack[-3]:stack[-3] + 0x20] // } 17F6 5B JUMPDEST 17F7 82 DUP3 17F8 51 MLOAD 17F9 60 PUSH1 0x40 17FB 14 EQ 17FC 15 ISZERO 17FD 61 PUSH2 0x1820 1800 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1820, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) label_1801: // Incoming jump from 0x1800, if not !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @1803 stack[-3] // @1805 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @180A memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @180E stack[-4] // } 1801 60 PUSH1 0x20 1803 83 DUP4 1804 01 ADD 1805 51 MLOAD 1806 60 PUSH1 0x40 1808 84 DUP5 1809 01 ADD 180A 51 MLOAD 180B 61 PUSH2 0x1815 180E 86 DUP7 180F 83 DUP4 1810 83 DUP4 1811 61 PUSH2 0x1b1d 1814 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @1805 stack[0] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @180A stack[1] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // @180B stack[2] = 0x1815 // @180E stack[3] = stack[-4] // @180F stack[4] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @1810 stack[5] = memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] // } // Block ends with call to 0x1b1d, returns to 0x1815 label_1815: // Incoming return from call to 0x1B1D at 0x1814 // Inputs[4] // { // @1816 stack[-5] // @1816 stack[-1] // @1818 stack[-6] // @1818 stack[-2] // } 1815 5B JUMPDEST 1816 93 SWAP4 1817 50 POP 1818 93 SWAP4 1819 50 POP 181A 50 POP 181B 50 POP 181C 61 PUSH2 0x1828 181F 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1816 stack[-5] = stack[-1] // @1818 stack[-6] = stack[-2] // } // Block ends with unconditional jump to 0x1828 label_1820: // Incoming jump from 0x1800, if !(0x40 == memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @1824 stack[-2] // @1829 stack[-4] // @182B stack[-5] // @182C stack[-3] // } 1820 5B JUMPDEST 1821 50 POP 1822 60 PUSH1 0x00 1824 90 SWAP1 1825 50 POP 1826 60 PUSH1 0x02 1828 5B JUMPDEST 1829 92 SWAP3 182A 50 POP 182B 92 SWAP3 182C 90 SWAP1 182D 50 POP 182E 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @1829 stack[-4] = 0x02 // @182B stack[-5] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_182F: // Incoming call from 0x16F4, returns to 0x07E2 // Inputs[1] { @1832 stack[-1] } 182F 5B JUMPDEST 1830 60 PUSH1 0x00 1832 81 DUP2 1833 60 PUSH1 0x04 1835 81 DUP2 1836 11 GT 1837 15 ISZERO 1838 61 PUSH2 0x1851 183B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1830 stack[0] = 0x00 // @1832 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1851, if !(stack[-1] > 0x04) label_183C: // Incoming jump from 0x183B, if not !(stack[-1] > 0x04) // Inputs[1] { @1850 memory[0x00:0x24] } 183C 63 PUSH4 0x4e487b71 1841 60 PUSH1 0xe0 1843 1B SHL 1844 60 PUSH1 0x00 1846 52 MSTORE 1847 60 PUSH1 0x21 1849 60 PUSH1 0x04 184B 52 MSTORE 184C 60 PUSH1 0x24 184E 60 PUSH1 0x00 1850 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1846 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @184B memory[0x04:0x24] = 0x21 // @1850 revert(memory[0x00:0x24]); // } // Block terminates label_1851: // Incoming jump from 0x183B, if !(stack[-1] > 0x04) // Inputs[2] // { // @1852 stack[-2] // @1852 stack[-1] // } 1851 5B JUMPDEST 1852 14 EQ 1853 15 ISZERO 1854 61 PUSH2 0x185a 1857 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x185a, if !(stack[-1] == stack[-2]) label_1858: // Incoming jump from 0x1857, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1859 stack[-2] } 1858 50 POP 1859 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_185A: // Incoming jump from 0x1857, if !(stack[-1] == stack[-2]) // Inputs[1] { @185D stack[-1] } 185A 5B JUMPDEST 185B 60 PUSH1 0x01 185D 81 DUP2 185E 60 PUSH1 0x04 1860 81 DUP2 1861 11 GT 1862 15 ISZERO 1863 61 PUSH2 0x187c 1866 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @185B stack[0] = 0x01 // @185D stack[1] = stack[-1] // } // Block ends with conditional jump to 0x187c, if !(stack[-1] > 0x04) label_1867: // Incoming jump from 0x1866, if not !(stack[-1] > 0x04) // Inputs[1] { @187B memory[0x00:0x24] } 1867 63 PUSH4 0x4e487b71 186C 60 PUSH1 0xe0 186E 1B SHL 186F 60 PUSH1 0x00 1871 52 MSTORE 1872 60 PUSH1 0x21 1874 60 PUSH1 0x04 1876 52 MSTORE 1877 60 PUSH1 0x24 1879 60 PUSH1 0x00 187B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1871 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1876 memory[0x04:0x24] = 0x21 // @187B revert(memory[0x00:0x24]); // } // Block terminates label_187C: // Incoming jump from 0x1866, if !(stack[-1] > 0x04) // Inputs[2] // { // @187D stack[-1] // @187D stack[-2] // } 187C 5B JUMPDEST 187D 14 EQ 187E 15 ISZERO 187F 61 PUSH2 0x18ca 1882 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x18ca, if !(stack[-1] == stack[-2]) label_1883: // Incoming jump from 0x1882, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1885 memory[0x40:0x60] } 1883 60 PUSH1 0x40 1885 51 MLOAD 1886 62 PUSH3 0x461bcd 188A 60 PUSH1 0xe5 188C 1B SHL 188D 81 DUP2 188E 52 MSTORE 188F 60 PUSH1 0x20 1891 60 PUSH1 0x04 1893 82 DUP3 1894 01 ADD 1895 52 MSTORE 1896 60 PUSH1 0x18 1898 60 PUSH1 0x24 189A 82 DUP3 189B 01 ADD 189C 52 MSTORE 189D 7F PUSH32 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 18BE 60 PUSH1 0x44 18C0 82 DUP3 18C1 01 ADD 18C2 52 MSTORE 18C3 60 PUSH1 0x64 18C5 01 ADD 18C6 61 PUSH2 0x0377 18C9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @188E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1895 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @189C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x18 // @18C2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e61747572650000000000000000 // @18C5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_18CA: // Incoming jump from 0x1882, if !(stack[-1] == stack[-2]) // Inputs[1] { @18CD stack[-1] } 18CA 5B JUMPDEST 18CB 60 PUSH1 0x02 18CD 81 DUP2 18CE 60 PUSH1 0x04 18D0 81 DUP2 18D1 11 GT 18D2 15 ISZERO 18D3 61 PUSH2 0x18ec 18D6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @18CB stack[0] = 0x02 // @18CD stack[1] = stack[-1] // } // Block ends with conditional jump to 0x18ec, if !(stack[-1] > 0x04) label_18D7: // Incoming jump from 0x18D6, if not !(stack[-1] > 0x04) // Inputs[1] { @18EB memory[0x00:0x24] } 18D7 63 PUSH4 0x4e487b71 18DC 60 PUSH1 0xe0 18DE 1B SHL 18DF 60 PUSH1 0x00 18E1 52 MSTORE 18E2 60 PUSH1 0x21 18E4 60 PUSH1 0x04 18E6 52 MSTORE 18E7 60 PUSH1 0x24 18E9 60 PUSH1 0x00 18EB FD *REVERT // Stack delta = +0 // Outputs[3] // { // @18E1 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @18E6 memory[0x04:0x24] = 0x21 // @18EB revert(memory[0x00:0x24]); // } // Block terminates label_18EC: // Incoming jump from 0x18D6, if !(stack[-1] > 0x04) // Inputs[2] // { // @18ED stack[-2] // @18ED stack[-1] // } 18EC 5B JUMPDEST 18ED 14 EQ 18EE 15 ISZERO 18EF 61 PUSH2 0x193a 18F2 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x193a, if !(stack[-1] == stack[-2]) label_18F3: // Incoming jump from 0x18F2, if not !(stack[-1] == stack[-2]) // Inputs[1] { @18F5 memory[0x40:0x60] } 18F3 60 PUSH1 0x40 18F5 51 MLOAD 18F6 62 PUSH3 0x461bcd 18FA 60 PUSH1 0xe5 18FC 1B SHL 18FD 81 DUP2 18FE 52 MSTORE 18FF 60 PUSH1 0x20 1901 60 PUSH1 0x04 1903 82 DUP3 1904 01 ADD 1905 52 MSTORE 1906 60 PUSH1 0x1f 1908 60 PUSH1 0x24 190A 82 DUP3 190B 01 ADD 190C 52 MSTORE 190D 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 192E 60 PUSH1 0x44 1930 82 DUP3 1931 01 ADD 1932 52 MSTORE 1933 60 PUSH1 0x64 1935 01 ADD 1936 61 PUSH2 0x0377 1939 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @18FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1905 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @190C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x1f // @1932 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265206c656e67746800 // @1935 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_193A: // Incoming jump from 0x18F2, if !(stack[-1] == stack[-2]) // Inputs[1] { @193D stack[-1] } 193A 5B JUMPDEST 193B 60 PUSH1 0x03 193D 81 DUP2 193E 60 PUSH1 0x04 1940 81 DUP2 1941 11 GT 1942 15 ISZERO 1943 61 PUSH2 0x195c 1946 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @193B stack[0] = 0x03 // @193D stack[1] = stack[-1] // } // Block ends with conditional jump to 0x195c, if !(stack[-1] > 0x04) label_1947: // Incoming jump from 0x1946, if not !(stack[-1] > 0x04) // Inputs[1] { @195B memory[0x00:0x24] } 1947 63 PUSH4 0x4e487b71 194C 60 PUSH1 0xe0 194E 1B SHL 194F 60 PUSH1 0x00 1951 52 MSTORE 1952 60 PUSH1 0x21 1954 60 PUSH1 0x04 1956 52 MSTORE 1957 60 PUSH1 0x24 1959 60 PUSH1 0x00 195B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1951 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1956 memory[0x04:0x24] = 0x21 // @195B revert(memory[0x00:0x24]); // } // Block terminates label_195C: // Incoming jump from 0x1946, if !(stack[-1] > 0x04) // Inputs[2] // { // @195D stack[-1] // @195D stack[-2] // } 195C 5B JUMPDEST 195D 14 EQ 195E 15 ISZERO 195F 61 PUSH2 0x19b5 1962 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x19b5, if !(stack[-1] == stack[-2]) label_1963: // Incoming jump from 0x1962, if not !(stack[-1] == stack[-2]) // Inputs[1] { @1965 memory[0x40:0x60] } 1963 60 PUSH1 0x40 1965 51 MLOAD 1966 62 PUSH3 0x461bcd 196A 60 PUSH1 0xe5 196C 1B SHL 196D 81 DUP2 196E 52 MSTORE 196F 60 PUSH1 0x20 1971 60 PUSH1 0x04 1973 82 DUP3 1974 01 ADD 1975 52 MSTORE 1976 60 PUSH1 0x22 1978 60 PUSH1 0x24 197A 82 DUP3 197B 01 ADD 197C 52 MSTORE 197D 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c 199E 60 PUSH1 0x44 19A0 82 DUP3 19A1 01 ADD 19A2 52 MSTORE 19A3 61 PUSH2 0x7565 19A6 60 PUSH1 0xf0 19A8 1B SHL 19A9 60 PUSH1 0x64 19AB 82 DUP3 19AC 01 ADD 19AD 52 MSTORE 19AE 60 PUSH1 0x84 19B0 01 ADD 19B1 61 PUSH2 0x0377 19B4 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @196E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1975 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @197C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @19A2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202773272076616c // @19AD memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @19B0 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_19B5: // Incoming jump from 0x1962, if !(stack[-1] == stack[-2]) // Inputs[1] { @19B8 stack[-1] } 19B5 5B JUMPDEST 19B6 60 PUSH1 0x04 19B8 81 DUP2 19B9 60 PUSH1 0x04 19BB 81 DUP2 19BC 11 GT 19BD 15 ISZERO 19BE 61 PUSH2 0x19d7 19C1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @19B6 stack[0] = 0x04 // @19B8 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x19d7, if !(stack[-1] > 0x04) label_19C2: // Incoming jump from 0x19C1, if not !(stack[-1] > 0x04) // Inputs[1] { @19D6 memory[0x00:0x24] } 19C2 63 PUSH4 0x4e487b71 19C7 60 PUSH1 0xe0 19C9 1B SHL 19CA 60 PUSH1 0x00 19CC 52 MSTORE 19CD 60 PUSH1 0x21 19CF 60 PUSH1 0x04 19D1 52 MSTORE 19D2 60 PUSH1 0x24 19D4 60 PUSH1 0x00 19D6 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @19CC memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @19D1 memory[0x04:0x24] = 0x21 // @19D6 revert(memory[0x00:0x24]); // } // Block terminates label_19D7: // Incoming jump from 0x19C1, if !(stack[-1] > 0x04) // Inputs[2] // { // @19D8 stack[-1] // @19D8 stack[-2] // } 19D7 5B JUMPDEST 19D8 14 EQ 19D9 15 ISZERO 19DA 61 PUSH2 0x0c70 19DD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0c70, if !(stack[-1] == stack[-2]) label_19DE: // Incoming jump from 0x19DD, if not !(stack[-1] == stack[-2]) // Inputs[1] { @19E0 memory[0x40:0x60] } 19DE 60 PUSH1 0x40 19E0 51 MLOAD 19E1 62 PUSH3 0x461bcd 19E5 60 PUSH1 0xe5 19E7 1B SHL 19E8 81 DUP2 19E9 52 MSTORE 19EA 60 PUSH1 0x20 19EC 60 PUSH1 0x04 19EE 82 DUP3 19EF 01 ADD 19F0 52 MSTORE 19F1 60 PUSH1 0x22 19F3 60 PUSH1 0x24 19F5 82 DUP3 19F6 01 ADD 19F7 52 MSTORE 19F8 7F PUSH32 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c 1A19 60 PUSH1 0x44 1A1B 82 DUP3 1A1C 01 ADD 1A1D 52 MSTORE 1A1E 61 PUSH2 0x7565 1A21 60 PUSH1 0xf0 1A23 1B SHL 1A24 60 PUSH1 0x64 1A26 82 DUP3 1A27 01 ADD 1A28 52 MSTORE 1A29 60 PUSH1 0x84 1A2B 01 ADD 1A2C 61 PUSH2 0x0377 1A2F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @19E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @19F0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @19F7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x22 // @1A1D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x45434453413a20696e76616c6964207369676e6174757265202776272076616c // @1A28 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7565 << 0xf0 // @1A2B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0377 label_1A30: // Incoming call from 0x1B3D, returns to 0x1B3E // Incoming call from 0x17E9, returns to 0x17EA // Inputs[1] { @1A55 stack[-1] } 1A30 5B JUMPDEST 1A31 60 PUSH1 0x00 1A33 80 DUP1 1A34 7F PUSH32 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0 1A55 83 DUP4 1A56 11 GT 1A57 15 ISZERO 1A58 61 PUSH2 0x1a67 1A5B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A31 stack[0] = 0x00 // @1A33 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1a67, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) label_1A5C: // Incoming jump from 0x1A5B, if not !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @1A5F stack[-2] } 1A5C 50 POP 1A5D 60 PUSH1 0x00 1A5F 90 SWAP1 1A60 50 POP 1A61 60 PUSH1 0x03 1A63 61 PUSH2 0x1b14 1A66 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1A5F stack[-2] = 0x00 // @1A61 stack[-1] = 0x03 // } // Block ends with unconditional jump to 0x1b14 label_1A67: // Incoming jump from 0x1A5B, if !(stack[-1] > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) // Inputs[1] { @1A68 stack[-5] } 1A67 5B JUMPDEST 1A68 84 DUP5 1A69 60 PUSH1 0xff 1A6B 16 AND 1A6C 60 PUSH1 0x1b 1A6E 14 EQ 1A6F 15 ISZERO 1A70 80 DUP1 1A71 15 ISZERO 1A72 61 PUSH2 0x1a7f 1A75 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A6F stack[0] = !(0x1b == 0xff & stack[-5]) } // Block ends with conditional jump to 0x1a7f, if !!(0x1b == 0xff & stack[-5]) label_1A76: // Incoming jump from 0x1A75, if not !!(0x1b == 0xff & stack[-5]) // Inputs[1] { @1A77 stack[-6] } 1A76 50 POP 1A77 84 DUP5 1A78 60 PUSH1 0xff 1A7A 16 AND 1A7B 60 PUSH1 0x1c 1A7D 14 EQ 1A7E 15 ISZERO 1A7F 5B JUMPDEST 1A80 15 ISZERO 1A81 61 PUSH2 0x1a90 1A84 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1a90, if !!(0x1c == 0xff & stack[-6]) label_1A85: // Incoming jump from 0x1A84, if not !stack[-1] // Incoming jump from 0x1A84, if not !!(0x1c == 0xff & stack[-6]) // Inputs[1] { @1A88 stack[-2] } 1A85 50 POP 1A86 60 PUSH1 0x00 1A88 90 SWAP1 1A89 50 POP 1A8A 60 PUSH1 0x04 1A8C 61 PUSH2 0x1b14 1A8F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1A88 stack[-2] = 0x00 // @1A8A stack[-1] = 0x04 // } // Block ends with unconditional jump to 0x1b14 label_1A90: // Incoming jump from 0x1A84, if !stack[-1] // Incoming jump from 0x1A84, if !!(0x1c == 0xff & stack[-6]) // Inputs[9] // { // @1A94 memory[0x40:0x60] // @1AA1 stack[-6] // @1AA6 stack[-5] // @1AB3 stack[-4] // @1ABA stack[-3] // @1AC7 memory[0x40:0x60] // @1AD2 msg.gas // @1AD3 address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1AD3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A90 5B JUMPDEST 1A91 60 PUSH1 0x40 1A93 80 DUP1 1A94 51 MLOAD 1A95 60 PUSH1 0x00 1A97 80 DUP1 1A98 82 DUP3 1A99 52 MSTORE 1A9A 60 PUSH1 0x20 1A9C 82 DUP3 1A9D 01 ADD 1A9E 80 DUP1 1A9F 84 DUP5 1AA0 52 MSTORE 1AA1 89 DUP10 1AA2 90 SWAP1 1AA3 52 MSTORE 1AA4 60 PUSH1 0xff 1AA6 88 DUP9 1AA7 16 AND 1AA8 92 SWAP3 1AA9 82 DUP3 1AAA 01 ADD 1AAB 92 SWAP3 1AAC 90 SWAP1 1AAD 92 SWAP3 1AAE 52 MSTORE 1AAF 60 PUSH1 0x60 1AB1 81 DUP2 1AB2 01 ADD 1AB3 86 DUP7 1AB4 90 SWAP1 1AB5 52 MSTORE 1AB6 60 PUSH1 0x80 1AB8 81 DUP2 1AB9 01 ADD 1ABA 85 DUP6 1ABB 90 SWAP1 1ABC 52 MSTORE 1ABD 60 PUSH1 0x01 1ABF 90 SWAP1 1AC0 60 PUSH1 0xa0 1AC2 01 ADD 1AC3 60 PUSH1 0x20 1AC5 60 PUSH1 0x40 1AC7 51 MLOAD 1AC8 60 PUSH1 0x20 1ACA 81 DUP2 1ACB 03 SUB 1ACC 90 SWAP1 1ACD 80 DUP1 1ACE 84 DUP5 1ACF 03 SUB 1AD0 90 SWAP1 1AD1 85 DUP6 1AD2 5A GAS 1AD3 FA STATICCALL 1AD4 15 ISZERO 1AD5 80 DUP1 1AD6 15 ISZERO 1AD7 61 PUSH2 0x1ae4 1ADA 57 *JUMPI // Stack delta = +4 // Outputs[11] // { // @1A99 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1AA0 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1AA3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-6] // @1AAD stack[0] = 0x00 // @1AAE memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = stack[-5] & 0xff // @1AB5 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-4] // @1ABC memory[memory[0x40:0x60] + 0x80:memory[0x40:0x60] + 0x80 + 0x20] = stack[-3] // @1ABF stack[1] = 0x01 // @1AC2 stack[2] = 0xa0 + memory[0x40:0x60] // @1AD3 memory[memory[0x40:0x60] - 0x20:memory[0x40:0x60] - 0x20 + 0x20] = address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @1AD4 stack[3] = !address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1ae4, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_1ADB: // Incoming jump from 0x1ADA, if not !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @1ADB returndata.length // @1ADF returndata[0x00:0x00 + returndata.length] // @1AE0 returndata.length // @1AE3 memory[0x00:0x00 + returndata.length] // } 1ADB 3D RETURNDATASIZE 1ADC 60 PUSH1 0x00 1ADE 80 DUP1 1ADF 3E RETURNDATACOPY 1AE0 3D RETURNDATASIZE 1AE1 60 PUSH1 0x00 1AE3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1ADF memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1AE3 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1AE4: // Incoming jump from 0x1ADA, if !!address(0x01).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0xa0 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[3] // { // @1AE9 memory[0x40:0x60] // @1AEE memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] // @1AEF stack[-4] // } 1AE4 5B JUMPDEST 1AE5 50 POP 1AE6 50 POP 1AE7 60 PUSH1 0x40 1AE9 51 MLOAD 1AEA 60 PUSH1 0x1f 1AEC 19 NOT 1AED 01 ADD 1AEE 51 MLOAD 1AEF 91 SWAP2 1AF0 50 POP 1AF1 50 POP 1AF2 60 PUSH1 0x01 1AF4 60 PUSH1 0x01 1AF6 60 PUSH1 0xa0 1AF8 1B SHL 1AF9 03 SUB 1AFA 81 DUP2 1AFB 16 AND 1AFC 61 PUSH2 0x1b0d 1AFF 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1AEF stack[-4] = memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] } // Block ends with conditional jump to 0x1b0d, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 label_1B00: // Incoming jump from 0x1AFF, if not memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1B04 stack[-2] // @1B06 stack[-3] // } 1B00 60 PUSH1 0x00 1B02 60 PUSH1 0x01 1B04 92 SWAP3 1B05 50 POP 1B06 92 SWAP3 1B07 50 POP 1B08 50 POP 1B09 61 PUSH2 0x1b14 1B0C 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1B04 stack[-2] = 0x01 // @1B06 stack[-3] = 0x00 // } // Block ends with unconditional jump to 0x1b14 label_1B0D: // Incoming jump from 0x1AFF, if memory[~0x1f + memory[0x40:0x60]:~0x1f + memory[0x40:0x60] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1B0E stack[-1] // @1B0E stack[-3] // @1B12 stack[-2] // } 1B0D 5B JUMPDEST 1B0E 91 SWAP2 1B0F 50 POP 1B10 60 PUSH1 0x00 1B12 90 SWAP1 1B13 50 POP // Stack delta = -1 // Outputs[2] // { // @1B0E stack[-3] = stack[-1] // @1B12 stack[-2] = 0x00 // } // Block continues label_1B14: // Incoming jump from 0x1A8F // Incoming jump from 0x1B0C // Incoming jump from 0x1B13 // Incoming jump from 0x1A66 // Inputs[5] // { // @1B15 stack[-6] // @1B15 stack[-1] // @1B17 stack[-7] // @1B17 stack[-2] // @1B18 stack[-5] // } 1B14 5B JUMPDEST 1B15 94 SWAP5 1B16 50 POP 1B17 94 SWAP5 1B18 92 SWAP3 1B19 50 POP 1B1A 50 POP 1B1B 50 POP 1B1C 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1B15 stack[-6] = stack[-1] // @1B17 stack[-7] = stack[-2] // } // Block ends with unconditional jump to stack[-7] label_1B1D: // Incoming call from 0x1814, returns to 0x1815 // Inputs[3] // { // @1B29 stack[-1] // @1B36 stack[-3] // @1B38 stack[-2] // } 1B1D 5B JUMPDEST 1B1E 60 PUSH1 0x00 1B20 80 DUP1 1B21 60 PUSH1 0x01 1B23 60 PUSH1 0x01 1B25 60 PUSH1 0xff 1B27 1B SHL 1B28 03 SUB 1B29 83 DUP4 1B2A 16 AND 1B2B 60 PUSH1 0xff 1B2D 84 DUP5 1B2E 90 SWAP1 1B2F 1C SHR 1B30 60 PUSH1 0x1b 1B32 01 ADD 1B33 61 PUSH2 0x1b3e 1B36 87 DUP8 1B37 82 DUP3 1B38 88 DUP9 1B39 85 DUP6 1B3A 61 PUSH2 0x1a30 1B3D 56 *JUMP // Stack delta = +9 // Outputs[9] // { // @1B1E stack[0] = 0x00 // @1B20 stack[1] = 0x00 // @1B2A stack[2] = stack[-1] & (0x01 << 0xff) - 0x01 // @1B32 stack[3] = 0x1b + (stack[-1] >> 0xff) // @1B33 stack[4] = 0x1b3e // @1B36 stack[5] = stack[-3] // @1B37 stack[6] = 0x1b + (stack[-1] >> 0xff) // @1B38 stack[7] = stack[-2] // @1B39 stack[8] = stack[-1] & (0x01 << 0xff) - 0x01 // } // Block ends with call to 0x1a30, returns to 0x1B3E label_1B3E: // Incoming return from call to 0x1A30 at 0x1B3D // Inputs[7] // { // @1B3F stack[-5] // @1B3F stack[-1] // @1B41 stack[-6] // @1B41 stack[-2] // @1B45 stack[-9] // @1B47 stack[-10] // @1B48 stack[-8] // } 1B3E 5B JUMPDEST 1B3F 93 SWAP4 1B40 50 POP 1B41 93 SWAP4 1B42 50 POP 1B43 50 POP 1B44 50 POP 1B45 93 SWAP4 1B46 50 POP 1B47 93 SWAP4 1B48 91 SWAP2 1B49 50 POP 1B4A 50 POP 1B4B 56 *JUMP // Stack delta = -8 // Outputs[2] // { // @1B45 stack[-9] = stack[-1] // @1B47 stack[-10] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_1B4C: // Incoming jump from 0x088B // Incoming jump from 0x081F // Inputs[2] // { // @1B4D stack[-3] // @1B4F storage[stack[-3]] // } 1B4C 5B JUMPDEST 1B4D 82 DUP3 1B4E 80 DUP1 1B4F 54 SLOAD 1B50 61 PUSH2 0x1b58 1B53 90 SWAP1 1B54 61 PUSH2 0x255a 1B57 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B4D stack[0] = stack[-3] // @1B53 stack[1] = 0x1b58 // @1B53 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x255a, returns to 0x1B58 label_1B58: // Incoming return from call to 0x255A at 0x1B57 // Inputs[5] // { // @1B59 stack[-1] // @1B59 stack[-2] // @1B61 memory[0x00:0x20] // @1B6C stack[-4] // @1B6D stack[-3] // } 1B58 5B JUMPDEST 1B59 90 SWAP1 1B5A 60 PUSH1 0x00 1B5C 52 MSTORE 1B5D 60 PUSH1 0x20 1B5F 60 PUSH1 0x00 1B61 20 SHA3 1B62 90 SWAP1 1B63 60 PUSH1 0x1f 1B65 01 ADD 1B66 60 PUSH1 0x20 1B68 90 SWAP1 1B69 04 DIV 1B6A 81 DUP2 1B6B 01 ADD 1B6C 92 SWAP3 1B6D 82 DUP3 1B6E 61 PUSH2 0x1b7a 1B71 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1B5C memory[0x00:0x20] = stack[-2] // @1B62 stack[-2] = keccak256(memory[0x00:0x20]) // @1B6C stack[-1] = stack[-4] // @1B6C stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1b7a, if stack[-3] label_1B72: // Incoming jump from 0x1B71, if not stack[-3] // Inputs[1] { @1B74 stack[-5] } 1B72 60 PUSH1 0x00 1B74 85 DUP6 1B75 55 SSTORE 1B76 61 PUSH2 0x1bc0 1B79 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B75 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x1bc0 label_1B7A: // Incoming jump from 0x1B71, if stack[-3] // Inputs[1] { @1B7B stack[-3] } 1B7A 5B JUMPDEST 1B7B 82 DUP3 1B7C 60 PUSH1 0x1f 1B7E 10 LT 1B7F 61 PUSH2 0x1b93 1B82 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b93, if 0x1f < stack[-3] label_1B83: // Incoming jump from 0x1B82, if not 0x1f < stack[-3] // Inputs[4] // { // @1B83 stack[-3] // @1B89 stack[-1] // @1B8A msg.data[stack[-1]:stack[-1] + 0x20] // @1B8D stack[-5] // } 1B83 82 DUP3 1B84 80 DUP1 1B85 01 ADD 1B86 60 PUSH1 0xff 1B88 19 NOT 1B89 82 DUP3 1B8A 35 CALLDATALOAD 1B8B 16 AND 1B8C 17 OR 1B8D 85 DUP6 1B8E 55 SSTORE 1B8F 61 PUSH2 0x1bc0 1B92 56 *JUMP // Stack delta = +0 // Outputs[1] { @1B8E storage[stack[-5]] = (msg.data[stack[-1]:stack[-1] + 0x20] & ~0xff) | stack[-3] + stack[-3] } // Block ends with unconditional jump to 0x1bc0 label_1B93: // Incoming jump from 0x1B82, if 0x1f < stack[-3] // Inputs[2] // { // @1B94 stack[-3] // @1B9A stack[-5] // } 1B93 5B JUMPDEST 1B94 82 DUP3 1B95 80 DUP1 1B96 01 ADD 1B97 60 PUSH1 0x01 1B99 01 ADD 1B9A 85 DUP6 1B9B 55 SSTORE 1B9C 82 DUP3 1B9D 15 ISZERO 1B9E 61 PUSH2 0x1bc0 1BA1 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1B9B storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x1bc0, if !stack[-3] label_1BA2: // Incoming jump from 0x1BA1, if not !stack[-3] // Inputs[2] // { // @1BA2 stack[-3] // @1BA2 stack[-1] // } 1BA2 91 SWAP2 1BA3 82 DUP3 1BA4 01 ADD 1BA5 5B JUMPDEST 1BA6 82 DUP3 1BA7 81 DUP2 1BA8 11 GT 1BA9 15 ISZERO 1BAA 61 PUSH2 0x1bc0 1BAD 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1BA2 stack[-3] = stack[-1] // @1BA4 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x1bc0, if !(stack[-1] + stack[-3] > stack[-1]) label_1BAE: // Incoming jump from 0x1BAD, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x1BAD, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @1BAE stack[-3] // @1BAF msg.data[stack[-3]:stack[-3] + 0x20] // @1BB0 stack[-2] // @1BB2 stack[-1] // } 1BAE 82 DUP3 1BAF 35 CALLDATALOAD 1BB0 82 DUP3 1BB1 55 SSTORE 1BB2 91 SWAP2 1BB3 60 PUSH1 0x20 1BB5 01 ADD 1BB6 91 SWAP2 1BB7 90 SWAP1 1BB8 60 PUSH1 0x01 1BBA 01 ADD 1BBB 90 SWAP1 1BBC 61 PUSH2 0x1ba5 1BBF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1BB1 storage[stack[-2]] = msg.data[stack[-3]:stack[-3] + 0x20] // @1BB6 stack[-3] = 0x20 + stack[-3] // @1BBB stack[-2] = 0x01 + stack[-2] // @1BBB stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1ba5 label_1BC0: // Incoming jump from 0x1BA1, if !stack[-3] // Incoming jump from 0x1B79 // Incoming jump from 0x1BAD, if !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1B92 // Incoming jump from 0x1BAD, if !(stack[-1] > stack[-3]) // Inputs[2] // { // @1BC5 stack[-4] // @1BC6 stack[-3] // } 1BC0 5B JUMPDEST 1BC1 50 POP 1BC2 61 PUSH2 0x1bcc 1BC5 92 SWAP3 1BC6 91 SWAP2 1BC7 50 POP 1BC8 61 PUSH2 0x1bd0 1BCB 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1BC5 stack[-4] = 0x1bcc // @1BC6 stack[-3] = stack[-4] // } // Block ends with call to 0x1bd0, returns to 0x1BCC label_1BCC: // Incoming jump from 0x1BD9, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x1BD0 at 0x1BCB // Incoming jump from 0x1BD9, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @1BCE stack[-2] // @1BCE stack[-3] // } 1BCC 5B JUMPDEST 1BCD 50 POP 1BCE 90 SWAP1 1BCF 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BCE stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_1BD0: // Incoming call from 0x1BCB, returns to 0x1BCC // Inputs[2] // { // @1BD2 stack[-1] // @1BD3 stack[-2] // } 1BD0 5B JUMPDEST 1BD1 5B JUMPDEST 1BD2 80 DUP1 1BD3 82 DUP3 1BD4 11 GT 1BD5 15 ISZERO 1BD6 61 PUSH2 0x1bcc 1BD9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1bcc, if !(stack[-2] > stack[-1]) label_1BDA: // Incoming jump from 0x1BD9, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1BD9, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1BDC stack[-1] } 1BDA 60 PUSH1 0x00 1BDC 81 DUP2 1BDD 55 SSTORE 1BDE 60 PUSH1 0x01 1BE0 01 ADD 1BE1 61 PUSH2 0x1bd1 1BE4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1BDD storage[stack[-1]] = 0x00 // @1BE0 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1bd1 label_1BE5: // Incoming call from 0x1E0A, returns to 0x1E0B // Incoming call from 0x1E94, returns to 0x1E95 // Incoming call from 0x1D2D, returns to 0x1D2E // Incoming call from 0x1CFD, returns to 0x1CFE // Incoming call from 0x1D56, returns to 0x1D57 // Incoming call from 0x1F5E, returns to 0x1F5F // Incoming call from 0x1EBF, returns to 0x1EC0 // Incoming call from 0x1D1F, returns to 0x1D20 // Incoming call from 0x1DFC, returns to 0x1DFD // Incoming call from 0x1E5A, returns to 0x1E5B // Incoming call from 0x1D64, returns to 0x1D65 // Inputs[2] // { // @1BE6 stack[-1] // @1BE7 msg.data[stack[-1]:stack[-1] + 0x20] // } 1BE5 5B JUMPDEST 1BE6 80 DUP1 1BE7 35 CALLDATALOAD 1BE8 60 PUSH1 0x01 1BEA 60 PUSH1 0x01 1BEC 60 PUSH1 0xa0 1BEE 1B SHL 1BEF 03 SUB 1BF0 81 DUP2 1BF1 16 AND 1BF2 81 DUP2 1BF3 14 EQ 1BF4 61 PUSH2 0x1bfc 1BF7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BE7 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1bfc, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1BF8: // Incoming jump from 0x1BF7, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1BFB memory[0x00:0x00] } 1BF8 60 PUSH1 0x00 1BFA 80 DUP1 1BFB FD *REVERT // Stack delta = +0 // Outputs[1] { @1BFB revert(memory[0x00:0x00]); } // Block terminates label_1BFC: // Incoming jump from 0x1BF7, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1BFD stack[-3] // @1BFD stack[-1] // @1BFE stack[-2] // } 1BFC 5B JUMPDEST 1BFD 91 SWAP2 1BFE 90 SWAP1 1BFF 50 POP 1C00 56 *JUMP // Stack delta = -2 // Outputs[1] { @1BFD stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1C01: // Incoming call from 0x1F95, returns to 0x1F96 // Incoming call from 0x1FD4, returns to 0x1FD5 // Incoming call from 0x1D8C, returns to 0x1D8D // Incoming call from 0x1DAD, returns to 0x1DAE // Inputs[2] // { // @1C04 stack[-2] // @1C07 stack[-1] // } 1C01 5B JUMPDEST 1C02 60 PUSH1 0x00 1C04 82 DUP3 1C05 60 PUSH1 0x1f 1C07 83 DUP4 1C08 01 ADD 1C09 12 SLT 1C0A 61 PUSH2 0x1c11 1C0D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C02 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c11, if stack[-1] + 0x1f i< stack[-2] label_1C0E: // Incoming jump from 0x1C0D, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1C0E stack[-1] // @1C10 memory[stack[-1]:stack[-1] + stack[-1]] // } 1C0E 80 DUP1 1C0F 81 DUP2 1C10 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C10 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1C11: // Incoming jump from 0x1C0D, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1C12 stack[-2] // @1C13 msg.data[stack[-2]:stack[-2] + 0x20] // } 1C11 5B JUMPDEST 1C12 81 DUP2 1C13 35 CALLDATALOAD 1C14 60 PUSH1 0x20 1C16 61 PUSH2 0x1c1e 1C19 82 DUP3 1C1A 61 PUSH2 0x24c3 1C1D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C13 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1C14 stack[1] = 0x20 // @1C16 stack[2] = 0x1c1e // @1C19 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x24c3, returns to 0x1C1E label_1C1E: // Incoming return from call to 0x24C3 at 0x1C1D // Inputs[2] // { // @1C21 memory[0x40:0x60] // @1C25 stack[-1] // } 1C1E 5B JUMPDEST 1C1F 60 PUSH1 0x40 1C21 51 MLOAD 1C22 61 PUSH2 0x1c2b 1C25 82 DUP3 1C26 82 DUP3 1C27 61 PUSH2 0x2595 1C2A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C21 stack[0] = memory[0x40:0x60] // @1C22 stack[1] = 0x1c2b // @1C25 stack[2] = stack[-1] // @1C26 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2595, returns to 0x1C2B label_1C2B: // Incoming return from call to 0x2595 at 0x1C2A // Inputs[6] // { // @1C2C stack[-4] // @1C2D stack[-1] // @1C2F stack[-3] // @1C32 stack[-2] // @1C34 stack[-6] // @1C40 stack[-7] // } 1C2B 5B JUMPDEST 1C2C 83 DUP4 1C2D 81 DUP2 1C2E 52 MSTORE 1C2F 82 DUP3 1C30 81 DUP2 1C31 01 ADD 1C32 91 SWAP2 1C33 50 POP 1C34 85 DUP6 1C35 83 DUP4 1C36 01 ADD 1C37 60 PUSH1 0x05 1C39 85 DUP6 1C3A 90 SWAP1 1C3B 1B SHL 1C3C 87 DUP8 1C3D 01 ADD 1C3E 84 DUP5 1C3F 01 ADD 1C40 88 DUP9 1C41 10 LT 1C42 15 ISZERO 1C43 61 PUSH2 0x1c4a 1C46 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1C2E memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1C32 stack[-2] = stack[-1] + stack[-3] // @1C36 stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1c4a, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_1C47: // Incoming jump from 0x1C46, if not !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1C47 stack[-6] // @1C49 memory[stack[-6]:stack[-6] + stack[-6]] // } 1C47 85 DUP6 1C48 86 DUP7 1C49 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C49 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_1C4A: // Incoming jump from 0x1C46, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1C4B stack[-6] // @1C4D stack[-5] // } 1C4A 5B JUMPDEST 1C4B 85 DUP6 1C4C 5B JUMPDEST 1C4D 85 DUP6 1C4E 81 DUP2 1C4F 10 LT 1C50 15 ISZERO 1C51 61 PUSH2 0x1c68 1C54 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C4B stack[0] = stack[-6] } // Block ends with conditional jump to 0x1c68, if !(stack[-6] < stack[-5]) label_1C55: // Incoming jump from 0x1C54, if not !(stack[-1] < stack[-6]) // Incoming jump from 0x1C54, if not !(stack[-6] < stack[-5]) // Inputs[5] // { // @1C55 stack[-2] // @1C56 msg.data[stack[-2]:stack[-2] + 0x20] // @1C57 stack[-4] // @1C59 stack[-1] // @1C5A stack[-5] // } 1C55 81 DUP2 1C56 35 CALLDATALOAD 1C57 84 DUP5 1C58 52 MSTORE 1C59 92 SWAP3 1C5A 84 DUP5 1C5B 01 ADD 1C5C 92 SWAP3 1C5D 90 SWAP1 1C5E 84 DUP5 1C5F 01 ADD 1C60 90 SWAP1 1C61 60 PUSH1 0x01 1C63 01 ADD 1C64 61 PUSH2 0x1c4c 1C67 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1C58 memory[stack[-4]:stack[-4] + 0x20] = msg.data[stack[-2]:stack[-2] + 0x20] // @1C5C stack[-4] = stack[-5] + stack[-4] // @1C60 stack[-2] = stack[-5] + stack[-2] // @1C63 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1c4c label_1C68: // Incoming jump from 0x1C54, if !(stack[-1] < stack[-6]) // Incoming jump from 0x1C54, if !(stack[-6] < stack[-5]) // Inputs[4] // { // @1C6A stack[-2] // @1C6A stack[-3] // @1C6B stack[-10] // @1C6C stack[-9] // } 1C68 5B JUMPDEST 1C69 50 POP 1C6A 90 SWAP1 1C6B 97 SWAP8 1C6C 96 SWAP7 1C6D 50 POP 1C6E 50 POP 1C6F 50 POP 1C70 50 POP 1C71 50 POP 1C72 50 POP 1C73 50 POP 1C74 56 *JUMP // Stack delta = -9 // Outputs[1] { @1C6B stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_1C75: // Incoming call from 0x1DCF, returns to 0x1DD0 // Incoming call from 0x20E1, returns to 0x1F96 // Incoming call from 0x1E3F, returns to 0x1DD0 // Inputs[2] // { // @1C78 stack[-2] // @1C7B stack[-1] // } 1C75 5B JUMPDEST 1C76 60 PUSH1 0x00 1C78 82 DUP3 1C79 60 PUSH1 0x1f 1C7B 83 DUP4 1C7C 01 ADD 1C7D 12 SLT 1C7E 61 PUSH2 0x1c85 1C81 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C76 stack[0] = 0x00 } // Block ends with conditional jump to 0x1c85, if stack[-1] + 0x1f i< stack[-2] label_1C82: // Incoming jump from 0x1C81, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1C82 stack[-1] // @1C84 memory[stack[-1]:stack[-1] + stack[-1]] // } 1C82 80 DUP1 1C83 81 DUP2 1C84 FD *REVERT // Stack delta = +0 // Outputs[1] { @1C84 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1C85: // Incoming jump from 0x1C81, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1C86 stack[-2] // @1C87 msg.data[stack[-2]:stack[-2] + 0x20] // } 1C85 5B JUMPDEST 1C86 81 DUP2 1C87 35 CALLDATALOAD 1C88 67 PUSH8 0xffffffffffffffff 1C91 81 DUP2 1C92 11 GT 1C93 15 ISZERO 1C94 61 PUSH2 0x1c9f 1C97 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1C87 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1c9f, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1C98: // Incoming jump from 0x1C97, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 1C98 61 PUSH2 0x1c9f 1C9B 61 PUSH2 0x261d 1C9E 56 *JUMP // Stack delta = +1 // Outputs[1] { @1C98 stack[0] = 0x1c9f } // Block ends with unconditional jump to 0x261d label_1C9F: // Incoming jump from 0x1C97, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1CA2 memory[0x40:0x60] // @1CA8 stack[-1] // } 1C9F 5B JUMPDEST 1CA0 60 PUSH1 0x40 1CA2 51 MLOAD 1CA3 61 PUSH2 0x1cb6 1CA6 60 PUSH1 0x1f 1CA8 83 DUP4 1CA9 01 ADD 1CAA 60 PUSH1 0x1f 1CAC 19 NOT 1CAD 16 AND 1CAE 60 PUSH1 0x20 1CB0 01 ADD 1CB1 82 DUP3 1CB2 61 PUSH2 0x2595 1CB5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1CA2 stack[0] = memory[0x40:0x60] // @1CA3 stack[1] = 0x1cb6 // @1CB0 stack[2] = 0x20 + (~0x1f & stack[-1] + 0x1f) // @1CB1 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2595, returns to 0x1CB6 label_1CB6: // Incoming return from call to 0x2595 at 0x1CB5 // Inputs[4] // { // @1CB7 stack[-2] // @1CB8 stack[-1] // @1CBA stack[-5] // @1CBE stack[-4] // } 1CB6 5B JUMPDEST 1CB7 81 DUP2 1CB8 81 DUP2 1CB9 52 MSTORE 1CBA 84 DUP5 1CBB 60 PUSH1 0x20 1CBD 83 DUP4 1CBE 86 DUP7 1CBF 01 ADD 1CC0 01 ADD 1CC1 11 GT 1CC2 15 ISZERO 1CC3 61 PUSH2 0x1cca 1CC6 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1CB9 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x1cca, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_1CC7: // Incoming jump from 0x1CC6, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[2] // { // @1CC7 stack[-3] // @1CC9 memory[stack[-3]:stack[-3] + stack[-3]] // } 1CC7 82 DUP3 1CC8 83 DUP4 1CC9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CC9 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1CCA: // Incoming jump from 0x1CC6, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[7] // { // @1CCB stack[-2] // @1CCE stack[-4] // @1CD2 stack[-1] // @1CD4 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @1CDB stack[-3] // @1CDF stack[-6] // @1CE0 stack[-5] // } 1CCA 5B JUMPDEST 1CCB 81 DUP2 1CCC 60 PUSH1 0x20 1CCE 85 DUP6 1CCF 01 ADD 1CD0 60 PUSH1 0x20 1CD2 83 DUP4 1CD3 01 ADD 1CD4 37 CALLDATACOPY 1CD5 90 SWAP1 1CD6 81 DUP2 1CD7 01 ADD 1CD8 60 PUSH1 0x20 1CDA 01 ADD 1CDB 91 SWAP2 1CDC 90 SWAP1 1CDD 91 SWAP2 1CDE 52 MSTORE 1CDF 92 SWAP3 1CE0 91 SWAP2 1CE1 50 POP 1CE2 50 POP 1CE3 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1CD4 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @1CDE memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] = stack[-3] // @1CDF stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_1CE4: // Incoming call from 0x025D, returns to 0x025E // Incoming call from 0x028B, returns to 0x028C // Incoming call from 0x0300, returns to 0x0301 // Inputs[2] // { // @1CE9 stack[-1] // @1CEA stack[-2] // } 1CE4 5B JUMPDEST 1CE5 60 PUSH1 0x00 1CE7 60 PUSH1 0x20 1CE9 82 DUP3 1CEA 84 DUP5 1CEB 03 SUB 1CEC 12 SLT 1CED 15 ISZERO 1CEE 61 PUSH2 0x1cf5 1CF1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1CE5 stack[0] = 0x00 } // Block ends with conditional jump to 0x1cf5, if !(stack[-2] - stack[-1] i< 0x20) label_1CF2: // Incoming jump from 0x1CF1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1CF2 stack[-1] // @1CF4 memory[stack[-1]:stack[-1] + stack[-1]] // } 1CF2 80 DUP1 1CF3 81 DUP2 1CF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1CF4 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1CF5: // Incoming jump from 0x1CF1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1CF9 stack[-2] } 1CF5 5B JUMPDEST 1CF6 61 PUSH2 0x1cfe 1CF9 82 DUP3 1CFA 61 PUSH2 0x1be5 1CFD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1CF6 stack[0] = 0x1cfe // @1CF9 stack[1] = stack[-2] // } // Block ends with call to 0x1be5, returns to 0x1CFE label_1CFE: // Incoming return from call to 0x1BE5 at 0x1CFD // Incoming return from call to 0x26D5 at 0x2005 // Incoming return from call to 0x26D5 at 0x2021 // Incoming return from call to 0x211C at 0x232D // Inputs[3] // { // @1CFF stack[-5] // @1CFF stack[-1] // @1D00 stack[-4] // } 1CFE 5B JUMPDEST 1CFF 93 SWAP4 1D00 92 SWAP3 1D01 50 POP 1D02 50 POP 1D03 50 POP 1D04 56 *JUMP // Stack delta = -4 // Outputs[1] { @1CFF stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1D05: // Incoming call from 0x02B1, returns to 0x02B2 // Inputs[2] // { // @1D0B stack[-1] // @1D0C stack[-2] // } 1D05 5B JUMPDEST 1D06 60 PUSH1 0x00 1D08 80 DUP1 1D09 60 PUSH1 0x40 1D0B 83 DUP4 1D0C 85 DUP6 1D0D 03 SUB 1D0E 12 SLT 1D0F 15 ISZERO 1D10 61 PUSH2 0x1d17 1D13 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1D06 stack[0] = 0x00 // @1D08 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1d17, if !(stack[-2] - stack[-1] i< 0x40) label_1D14: // Incoming jump from 0x1D13, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1D14 stack[-1] // @1D16 memory[stack[-1]:stack[-1] + stack[-1]] // } 1D14 80 DUP1 1D15 81 DUP2 1D16 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D16 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1D17: // Incoming jump from 0x1D13, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1D1B stack[-3] } 1D17 5B JUMPDEST 1D18 61 PUSH2 0x1d20 1D1B 83 DUP4 1D1C 61 PUSH2 0x1be5 1D1F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D18 stack[0] = 0x1d20 // @1D1B stack[1] = stack[-3] // } // Block ends with call to 0x1be5, returns to 0x1D20 label_1D20: // Incoming return from call to 0x1BE5 at 0x1D1F // Inputs[3] // { // @1D21 stack[-3] // @1D21 stack[-1] // @1D28 stack[-4] // } 1D20 5B JUMPDEST 1D21 91 SWAP2 1D22 50 POP 1D23 61 PUSH2 0x1d2e 1D26 60 PUSH1 0x20 1D28 84 DUP5 1D29 01 ADD 1D2A 61 PUSH2 0x1be5 1D2D 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D21 stack[-3] = stack[-1] // @1D23 stack[-1] = 0x1d2e // @1D29 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1be5, returns to 0x1D2E label_1D2E: // Incoming return from call to 0x1BE5 at 0x1D2D // Inputs[6] // { // @1D2F stack[-1] // @1D2F stack[-2] // @1D31 stack[-5] // @1D33 stack[-3] // @1D33 stack[-6] // @1D34 stack[-4] // } 1D2E 5B JUMPDEST 1D2F 90 SWAP1 1D30 50 POP 1D31 92 SWAP3 1D32 50 POP 1D33 92 SWAP3 1D34 90 SWAP1 1D35 50 POP 1D36 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1D31 stack[-5] = stack[-1] // @1D33 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1D37: // Incoming jump from 0x01CE // Inputs[2] // { // @1D42 stack[-1] // @1D43 stack[-2] // } 1D37 5B JUMPDEST 1D38 60 PUSH1 0x00 1D3A 80 DUP1 1D3B 60 PUSH1 0x00 1D3D 80 DUP1 1D3E 60 PUSH1 0x00 1D40 60 PUSH1 0xa0 1D42 86 DUP7 1D43 88 DUP9 1D44 03 SUB 1D45 12 SLT 1D46 15 ISZERO 1D47 61 PUSH2 0x1d4e 1D4A 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1D38 stack[0] = 0x00 // @1D3A stack[1] = 0x00 // @1D3B stack[2] = 0x00 // @1D3D stack[3] = 0x00 // @1D3E stack[4] = 0x00 // } // Block ends with conditional jump to 0x1d4e, if !(stack[-2] - stack[-1] i< 0xa0) label_1D4B: // Incoming jump from 0x1D4A, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1D4B stack[-1] // @1D4D memory[stack[-1]:stack[-1] + stack[-1]] // } 1D4B 80 DUP1 1D4C 81 DUP2 1D4D FD *REVERT // Stack delta = +0 // Outputs[1] { @1D4D revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1D4E: // Incoming jump from 0x1D4A, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1D52 stack[-6] } 1D4E 5B JUMPDEST 1D4F 61 PUSH2 0x1d57 1D52 86 DUP7 1D53 61 PUSH2 0x1be5 1D56 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1D4F stack[0] = 0x1d57 // @1D52 stack[1] = stack[-6] // } // Block ends with call to 0x1be5, returns to 0x1D57 label_1D57: // Incoming return from call to 0x1BE5 at 0x1D56 // Inputs[3] // { // @1D58 stack[-1] // @1D58 stack[-6] // @1D5F stack[-7] // } 1D57 5B JUMPDEST 1D58 94 SWAP5 1D59 50 POP 1D5A 61 PUSH2 0x1d65 1D5D 60 PUSH1 0x20 1D5F 87 DUP8 1D60 01 ADD 1D61 61 PUSH2 0x1be5 1D64 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1D58 stack[-6] = stack[-1] // @1D5A stack[-1] = 0x1d65 // @1D60 stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1be5, returns to 0x1D65 label_1D65: // Incoming return from call to 0x1BE5 at 0x1D64 // Inputs[4] // { // @1D66 stack[-1] // @1D66 stack[-5] // @1D6A stack[-7] // @1D6C msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 1D65 5B JUMPDEST 1D66 93 SWAP4 1D67 50 POP 1D68 60 PUSH1 0x40 1D6A 86 DUP7 1D6B 01 ADD 1D6C 35 CALLDATALOAD 1D6D 67 PUSH8 0xffffffffffffffff 1D76 80 DUP1 1D77 82 DUP3 1D78 11 GT 1D79 15 ISZERO 1D7A 61 PUSH2 0x1d81 1D7D 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1D66 stack[-5] = stack[-1] // @1D6C stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1D6D stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1d81, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) label_1D7E: // Incoming jump from 0x1D7D, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1D7E stack[-3] // @1D80 memory[stack[-3]:stack[-3] + stack[-3]] // } 1D7E 82 DUP3 1D7F 83 DUP4 1D80 FD *REVERT // Stack delta = +0 // Outputs[1] { @1D80 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1D81: // Incoming jump from 0x1D7D, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1D85 stack[-9] // @1D86 stack[-2] // @1D87 stack[-8] // } 1D81 5B JUMPDEST 1D82 61 PUSH2 0x1d8d 1D85 89 DUP10 1D86 83 DUP4 1D87 8A DUP11 1D88 01 ADD 1D89 61 PUSH2 0x1c01 1D8C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1D82 stack[0] = 0x1d8d // @1D85 stack[1] = stack[-9] // @1D88 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x1c01, returns to 0x1D8D label_1D8D: // Incoming return from call to 0x1C01 at 0x1D8C // Inputs[6] // { // @1D8E stack[-6] // @1D8E stack[-1] // @1D92 stack[-9] // @1D94 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @1D95 stack[-3] // @1D97 stack[-2] // } 1D8D 5B JUMPDEST 1D8E 94 SWAP5 1D8F 50 POP 1D90 60 PUSH1 0x60 1D92 88 DUP9 1D93 01 ADD 1D94 35 CALLDATALOAD 1D95 91 SWAP2 1D96 50 POP 1D97 80 DUP1 1D98 82 DUP3 1D99 11 GT 1D9A 15 ISZERO 1D9B 61 PUSH2 0x1da2 1D9E 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1D8E stack[-6] = stack[-1] // @1D95 stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x1da2, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_1D9F: // Incoming jump from 0x1D9E, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[2] // { // @1D9F stack[-3] // @1DA1 memory[stack[-3]:stack[-3] + stack[-3]] // } 1D9F 82 DUP3 1DA0 83 DUP4 1DA1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DA1 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1DA2: // Incoming jump from 0x1D9E, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @1DA6 stack[-9] // @1DA7 stack[-2] // @1DA8 stack[-8] // } 1DA2 5B JUMPDEST 1DA3 61 PUSH2 0x1dae 1DA6 89 DUP10 1DA7 83 DUP4 1DA8 8A DUP11 1DA9 01 ADD 1DAA 61 PUSH2 0x1c01 1DAD 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1DA3 stack[0] = 0x1dae // @1DA6 stack[1] = stack[-9] // @1DA9 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x1c01, returns to 0x1DAE label_1DAE: // Incoming return from call to 0x1C01 at 0x1DAD // Inputs[6] // { // @1DAF stack[-5] // @1DAF stack[-1] // @1DB3 stack[-9] // @1DB5 msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @1DB6 stack[-3] // @1DB8 stack[-2] // } 1DAE 5B JUMPDEST 1DAF 93 SWAP4 1DB0 50 POP 1DB1 60 PUSH1 0x80 1DB3 88 DUP9 1DB4 01 ADD 1DB5 35 CALLDATALOAD 1DB6 91 SWAP2 1DB7 50 POP 1DB8 80 DUP1 1DB9 82 DUP3 1DBA 11 GT 1DBB 15 ISZERO 1DBC 61 PUSH2 0x1dc3 1DBF 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1DAF stack[-5] = stack[-1] // @1DB6 stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1dc3, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_1DC0: // Incoming jump from 0x1DBF, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[2] // { // @1DC0 stack[-3] // @1DC2 memory[stack[-3]:stack[-3] + stack[-3]] // } 1DC0 82 DUP3 1DC1 83 DUP4 1DC2 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DC2 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1DC3: // Incoming jump from 0x1DBF, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @1DC8 stack[-9] // @1DC9 stack[-2] // @1DCA stack[-8] // } 1DC3 5B JUMPDEST 1DC4 50 POP 1DC5 61 PUSH2 0x1dd0 1DC8 88 DUP9 1DC9 82 DUP3 1DCA 89 DUP10 1DCB 01 ADD 1DCC 61 PUSH2 0x1c75 1DCF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1DC5 stack[-1] = 0x1dd0 // @1DC8 stack[0] = stack[-9] // @1DCB stack[1] = stack[-8] + stack[-2] // } // Block ends with call to 0x1c75, returns to 0x1DD0 label_1DD0: // Incoming return from call to 0x1C75 at 0x1E3F // Incoming return from call to 0x1C75 at 0x1DCF // Inputs[9] // { // @1DD1 stack[-3] // @1DD1 stack[-1] // @1DD4 stack[-6] // @1DD5 stack[-9] // @1DD7 stack[-7] // @1DD7 stack[-4] // @1DD8 stack[-10] // @1DD9 stack[-5] // @1DDA stack[-8] // } 1DD0 5B JUMPDEST 1DD1 91 SWAP2 1DD2 50 POP 1DD3 50 POP 1DD4 92 SWAP3 1DD5 95 SWAP6 1DD6 50 POP 1DD7 92 SWAP3 1DD8 95 SWAP6 1DD9 90 SWAP1 1DDA 93 SWAP4 1DDB 50 POP 1DDC 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @1DD4 stack[-6] = stack[-1] // @1DD5 stack[-9] = stack[-6] // @1DD7 stack[-7] = stack[-4] // @1DD8 stack[-10] = stack[-7] // @1DDA stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_1DDD: // Incoming call from 0x02ED, returns to 0x02EE // Inputs[2] // { // @1DE8 stack[-1] // @1DE9 stack[-2] // } 1DDD 5B JUMPDEST 1DDE 60 PUSH1 0x00 1DE0 80 DUP1 1DE1 60 PUSH1 0x00 1DE3 80 DUP1 1DE4 60 PUSH1 0x00 1DE6 60 PUSH1 0xa0 1DE8 86 DUP7 1DE9 88 DUP9 1DEA 03 SUB 1DEB 12 SLT 1DEC 15 ISZERO 1DED 61 PUSH2 0x1df4 1DF0 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @1DDE stack[0] = 0x00 // @1DE0 stack[1] = 0x00 // @1DE1 stack[2] = 0x00 // @1DE3 stack[3] = 0x00 // @1DE4 stack[4] = 0x00 // } // Block ends with conditional jump to 0x1df4, if !(stack[-2] - stack[-1] i< 0xa0) label_1DF1: // Incoming jump from 0x1DF0, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1DF1 stack[-1] // @1DF3 memory[stack[-1]:stack[-1] + stack[-1]] // } 1DF1 80 DUP1 1DF2 81 DUP2 1DF3 FD *REVERT // Stack delta = +0 // Outputs[1] { @1DF3 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1DF4: // Incoming jump from 0x1DF0, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @1DF8 stack[-6] } 1DF4 5B JUMPDEST 1DF5 61 PUSH2 0x1dfd 1DF8 86 DUP7 1DF9 61 PUSH2 0x1be5 1DFC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1DF5 stack[0] = 0x1dfd // @1DF8 stack[1] = stack[-6] // } // Block ends with call to 0x1be5, returns to 0x1DFD label_1DFD: // Incoming return from call to 0x1BE5 at 0x1DFC // Inputs[3] // { // @1DFE stack[-6] // @1DFE stack[-1] // @1E05 stack[-7] // } 1DFD 5B JUMPDEST 1DFE 94 SWAP5 1DFF 50 POP 1E00 61 PUSH2 0x1e0b 1E03 60 PUSH1 0x20 1E05 87 DUP8 1E06 01 ADD 1E07 61 PUSH2 0x1be5 1E0A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1DFE stack[-6] = stack[-1] // @1E00 stack[-1] = 0x1e0b // @1E06 stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x1be5, returns to 0x1E0B label_1E0B: // Incoming return from call to 0x1BE5 at 0x1E0A // Inputs[8] // { // @1E0C stack[-5] // @1E0C stack[-1] // @1E10 stack[-7] // @1E12 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1E13 stack[-4] // @1E19 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @1E1A stack[-3] // @1E20 msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 1E0B 5B JUMPDEST 1E0C 93 SWAP4 1E0D 50 POP 1E0E 60 PUSH1 0x40 1E10 86 DUP7 1E11 01 ADD 1E12 35 CALLDATALOAD 1E13 92 SWAP3 1E14 50 POP 1E15 60 PUSH1 0x60 1E17 86 DUP7 1E18 01 ADD 1E19 35 CALLDATALOAD 1E1A 91 SWAP2 1E1B 50 POP 1E1C 60 PUSH1 0x80 1E1E 86 DUP7 1E1F 01 ADD 1E20 35 CALLDATALOAD 1E21 67 PUSH8 0xffffffffffffffff 1E2A 81 DUP2 1E2B 11 GT 1E2C 15 ISZERO 1E2D 61 PUSH2 0x1e34 1E30 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1E0C stack[-5] = stack[-1] // @1E13 stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1E1A stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @1E20 stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x1e34, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) label_1E31: // Incoming jump from 0x1E30, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1E31 stack[-2] // @1E33 memory[stack[-2]:stack[-2] + stack[-2]] // } 1E31 81 DUP2 1E32 82 DUP3 1E33 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E33 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1E34: // Incoming jump from 0x1E30, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1E38 stack[-8] // @1E39 stack[-1] // @1E3A stack[-7] // } 1E34 5B JUMPDEST 1E35 61 PUSH2 0x1dd0 1E38 88 DUP9 1E39 82 DUP3 1E3A 89 DUP10 1E3B 01 ADD 1E3C 61 PUSH2 0x1c75 1E3F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E35 stack[0] = 0x1dd0 // @1E38 stack[1] = stack[-8] // @1E3B stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x1c75, returns to 0x1DD0 label_1E40: // Incoming call from 0x024A, returns to 0x024B // Inputs[2] // { // @1E46 stack[-1] // @1E47 stack[-2] // } 1E40 5B JUMPDEST 1E41 60 PUSH1 0x00 1E43 80 DUP1 1E44 60 PUSH1 0x40 1E46 83 DUP4 1E47 85 DUP6 1E48 03 SUB 1E49 12 SLT 1E4A 15 ISZERO 1E4B 61 PUSH2 0x1e52 1E4E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E41 stack[0] = 0x00 // @1E43 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e52, if !(stack[-2] - stack[-1] i< 0x40) label_1E4F: // Incoming jump from 0x1E4E, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1E4F stack[-2] // @1E51 memory[stack[-2]:stack[-2] + stack[-2]] // } 1E4F 81 DUP2 1E50 82 DUP3 1E51 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E51 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1E52: // Incoming jump from 0x1E4E, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E56 stack[-3] } 1E52 5B JUMPDEST 1E53 61 PUSH2 0x1e5b 1E56 83 DUP4 1E57 61 PUSH2 0x1be5 1E5A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E53 stack[0] = 0x1e5b // @1E56 stack[1] = stack[-3] // } // Block ends with call to 0x1be5, returns to 0x1E5B label_1E5B: // Incoming return from call to 0x1BE5 at 0x1E5A // Inputs[4] // { // @1E5C stack[-3] // @1E5C stack[-1] // @1E60 stack[-4] // @1E62 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1E5B 5B JUMPDEST 1E5C 91 SWAP2 1E5D 50 POP 1E5E 60 PUSH1 0x20 1E60 83 DUP4 1E61 01 ADD 1E62 35 CALLDATALOAD 1E63 80 DUP1 1E64 15 ISZERO 1E65 15 ISZERO 1E66 81 DUP2 1E67 14 EQ 1E68 61 PUSH2 0x1e6f 1E6B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1E5C stack[-3] = stack[-1] // @1E62 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1e6f, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1E6C: // Incoming jump from 0x1E6B, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @1E6C stack[-2] // @1E6E memory[stack[-2]:stack[-2] + stack[-2]] // } 1E6C 81 DUP2 1E6D 82 DUP3 1E6E FD *REVERT // Stack delta = +0 // Outputs[1] { @1E6E revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1E6F: // Incoming jump from 0x1E6B, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @1E70 stack[-1] // @1E71 stack[-2] // @1E74 stack[-5] // @1E76 stack[-3] // @1E76 stack[-6] // @1E77 stack[-4] // } 1E6F 5B JUMPDEST 1E70 80 DUP1 1E71 91 SWAP2 1E72 50 POP 1E73 50 POP 1E74 92 SWAP3 1E75 50 POP 1E76 92 SWAP3 1E77 90 SWAP1 1E78 50 POP 1E79 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1E74 stack[-5] = stack[-1] // @1E76 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1E7A: // Incoming call from 0x0148, returns to 0x0149 // Inputs[2] // { // @1E80 stack[-1] // @1E81 stack[-2] // } 1E7A 5B JUMPDEST 1E7B 60 PUSH1 0x00 1E7D 80 DUP1 1E7E 60 PUSH1 0x40 1E80 83 DUP4 1E81 85 DUP6 1E82 03 SUB 1E83 12 SLT 1E84 15 ISZERO 1E85 61 PUSH2 0x1e8c 1E88 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E7B stack[0] = 0x00 // @1E7D stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e8c, if !(stack[-2] - stack[-1] i< 0x40) label_1E89: // Incoming jump from 0x1E88, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1E89 stack[-2] // @1E8B memory[stack[-2]:stack[-2] + stack[-2]] // } 1E89 81 DUP2 1E8A 82 DUP3 1E8B FD *REVERT // Stack delta = +0 // Outputs[1] { @1E8B revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1E8C: // Incoming jump from 0x1E88, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E90 stack[-3] } 1E8C 5B JUMPDEST 1E8D 61 PUSH2 0x1e95 1E90 83 DUP4 1E91 61 PUSH2 0x1be5 1E94 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E8D stack[0] = 0x1e95 // @1E90 stack[1] = stack[-3] // } // Block ends with call to 0x1be5, returns to 0x1E95 label_1E95: // Incoming return from call to 0x1BE5 at 0x1E94 // Inputs[5] // { // @1E96 stack[-1] // @1E96 stack[-6] // @1E99 stack[-4] // @1E9D msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1E9E stack[-5] // } 1E95 5B JUMPDEST 1E96 94 SWAP5 1E97 60 PUSH1 0x20 1E99 93 SWAP4 1E9A 90 SWAP1 1E9B 93 SWAP4 1E9C 01 ADD 1E9D 35 CALLDATALOAD 1E9E 93 SWAP4 1E9F 50 POP 1EA0 50 POP 1EA1 50 POP 1EA2 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1E96 stack[-6] = stack[-1] // @1E9E stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1EA3: // Incoming call from 0x01B9, returns to 0x01BA // Inputs[2] // { // @1EAB stack[-1] // @1EAC stack[-2] // } 1EA3 5B JUMPDEST 1EA4 60 PUSH1 0x00 1EA6 80 DUP1 1EA7 60 PUSH1 0x00 1EA9 60 PUSH1 0x60 1EAB 84 DUP5 1EAC 86 DUP7 1EAD 03 SUB 1EAE 12 SLT 1EAF 15 ISZERO 1EB0 61 PUSH2 0x1eb7 1EB3 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1EA4 stack[0] = 0x00 // @1EA6 stack[1] = 0x00 // @1EA7 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1eb7, if !(stack[-2] - stack[-1] i< 0x60) label_1EB4: // Incoming jump from 0x1EB3, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1EB4 stack[-3] // @1EB6 memory[stack[-3]:stack[-3] + stack[-3]] // } 1EB4 82 DUP3 1EB5 83 DUP4 1EB6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EB6 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1EB7: // Incoming jump from 0x1EB3, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1EBB stack[-4] } 1EB7 5B JUMPDEST 1EB8 61 PUSH2 0x1ec0 1EBB 84 DUP5 1EBC 61 PUSH2 0x1be5 1EBF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1EB8 stack[0] = 0x1ec0 // @1EBB stack[1] = stack[-4] // } // Block ends with call to 0x1be5, returns to 0x1EC0 label_1EC0: // Incoming return from call to 0x1BE5 at 0x1EBF // Inputs[7] // { // @1EC1 stack[-7] // @1EC1 stack[-1] // @1EC4 stack[-5] // @1EC6 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1EC7 stack[-6] // @1ECE msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1ED0 stack[-4] // } 1EC0 5B JUMPDEST 1EC1 95 SWAP6 1EC2 60 PUSH1 0x20 1EC4 85 DUP6 1EC5 01 ADD 1EC6 35 CALLDATALOAD 1EC7 95 SWAP6 1EC8 50 POP 1EC9 60 PUSH1 0x40 1ECB 90 SWAP1 1ECC 94 SWAP5 1ECD 01 ADD 1ECE 35 CALLDATALOAD 1ECF 93 SWAP4 1ED0 92 SWAP3 1ED1 50 POP 1ED2 50 POP 1ED3 50 POP 1ED4 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1EC1 stack[-7] = stack[-1] // @1EC7 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1ECF stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_1ED5: // Incoming jump from 0x01E1 // Inputs[2] // { // @1EDB stack[-1] // @1EDC stack[-2] // } 1ED5 5B JUMPDEST 1ED6 60 PUSH1 0x00 1ED8 80 DUP1 1ED9 60 PUSH1 0x40 1EDB 83 DUP4 1EDC 85 DUP6 1EDD 03 SUB 1EDE 12 SLT 1EDF 15 ISZERO 1EE0 61 PUSH2 0x1ee7 1EE3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1ED6 stack[0] = 0x00 // @1ED8 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1ee7, if !(stack[-2] - stack[-1] i< 0x40) label_1EE4: // Incoming jump from 0x1EE3, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1EE4 stack[-2] // @1EE6 memory[stack[-2]:stack[-2] + stack[-2]] // } 1EE4 81 DUP2 1EE5 82 DUP3 1EE6 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EE6 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1EE7: // Incoming jump from 0x1EE3, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1EE8 stack[-3] // @1EE9 msg.data[stack[-3]:stack[-3] + 0x20] // } 1EE7 5B JUMPDEST 1EE8 82 DUP3 1EE9 35 CALLDATALOAD 1EEA 67 PUSH8 0xffffffffffffffff 1EF3 80 DUP1 1EF4 82 DUP3 1EF5 11 GT 1EF6 15 ISZERO 1EF7 61 PUSH2 0x1efe 1EFA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EE9 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1EEA stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1efe, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1EFB: // Incoming jump from 0x1EFA, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1EFB stack[-4] // @1EFD memory[stack[-4]:stack[-4] + stack[-4]] // } 1EFB 83 DUP4 1EFC 84 DUP5 1EFD FD *REVERT // Stack delta = +0 // Outputs[1] { @1EFD revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1EFE: // Incoming jump from 0x1EFA, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1EFF stack[-2] // @1F00 stack[-5] // @1F04 stack[-6] // } 1EFE 5B JUMPDEST 1EFF 81 DUP2 1F00 85 DUP6 1F01 01 ADD 1F02 91 SWAP2 1F03 50 POP 1F04 85 DUP6 1F05 60 PUSH1 0x1f 1F07 83 DUP4 1F08 01 ADD 1F09 12 SLT 1F0A 61 PUSH2 0x1f11 1F0D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1F02 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x1f11, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_1F0E: // Incoming jump from 0x1F0D, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1F0E stack[-4] // @1F10 memory[stack[-4]:stack[-4] + stack[-4]] // } 1F0E 83 DUP4 1F0F 84 DUP5 1F10 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F10 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1F11: // Incoming jump from 0x1F0D, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @1F12 stack[-2] // @1F13 msg.data[stack[-2]:stack[-2] + 0x20] // } 1F11 5B JUMPDEST 1F12 81 DUP2 1F13 35 CALLDATALOAD 1F14 60 PUSH1 0x20 1F16 61 PUSH2 0x1f1e 1F19 82 DUP3 1F1A 61 PUSH2 0x24c3 1F1D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F13 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1F14 stack[1] = 0x20 // @1F16 stack[2] = 0x1f1e // @1F19 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x24c3, returns to 0x1F1E label_1F1E: // Incoming return from call to 0x24C3 at 0x1F1D // Inputs[2] // { // @1F21 memory[0x40:0x60] // @1F25 stack[-1] // } 1F1E 5B JUMPDEST 1F1F 60 PUSH1 0x40 1F21 51 MLOAD 1F22 61 PUSH2 0x1f2b 1F25 82 DUP3 1F26 82 DUP3 1F27 61 PUSH2 0x2595 1F2A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F21 stack[0] = memory[0x40:0x60] // @1F22 stack[1] = 0x1f2b // @1F25 stack[2] = stack[-1] // @1F26 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x2595, returns to 0x1F2B label_1F2B: // Incoming return from call to 0x2595 at 0x1F2A // Inputs[6] // { // @1F2C stack[-4] // @1F2D stack[-1] // @1F2F stack[-3] // @1F32 stack[-2] // @1F34 stack[-6] // @1F40 stack[-10] // } 1F2B 5B JUMPDEST 1F2C 83 DUP4 1F2D 81 DUP2 1F2E 52 MSTORE 1F2F 82 DUP3 1F30 81 DUP2 1F31 01 ADD 1F32 91 SWAP2 1F33 50 POP 1F34 85 DUP6 1F35 83 DUP4 1F36 01 ADD 1F37 60 PUSH1 0x05 1F39 85 DUP6 1F3A 90 SWAP1 1F3B 1B SHL 1F3C 87 DUP8 1F3D 01 ADD 1F3E 84 DUP5 1F3F 01 ADD 1F40 8B DUP12 1F41 10 LT 1F42 15 ISZERO 1F43 61 PUSH2 0x1f4a 1F46 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1F2E memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @1F32 stack[-2] = stack[-1] + stack[-3] // @1F36 stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1f4a, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_1F47: // Incoming jump from 0x1F46, if not !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1F47 stack[-9] // @1F49 memory[stack[-9]:stack[-9] + stack[-9]] // } 1F47 88 DUP9 1F48 89 DUP10 1F49 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F49 revert(memory[stack[-9]:stack[-9] + stack[-9]]); } // Block terminates label_1F4A: // Incoming jump from 0x1F46, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[3] // { // @1F4B stack[-9] // @1F4C stack[-7] // @1F4F stack[-5] // } 1F4A 5B JUMPDEST 1F4B 88 DUP9 1F4C 96 SWAP7 1F4D 50 POP 1F4E 5B JUMPDEST 1F4F 84 DUP5 1F50 87 DUP8 1F51 10 LT 1F52 15 ISZERO 1F53 61 PUSH2 0x1f73 1F56 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1F4C stack[-7] = stack[-9] } // Block ends with conditional jump to 0x1f73, if !(stack[-9] < stack[-5]) label_1F57: // Incoming jump from 0x1F56, if not !(stack[-7] < stack[-5]) // Incoming jump from 0x1F56, if not !(stack[-9] < stack[-5]) // Inputs[1] { @1F5A stack[-1] } 1F57 61 PUSH2 0x1f5f 1F5A 81 DUP2 1F5B 61 PUSH2 0x1be5 1F5E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F57 stack[0] = 0x1f5f // @1F5A stack[1] = stack[-1] // } // Block ends with call to 0x1be5, returns to 0x1F5F label_1F5F: // Incoming return from call to 0x1BE5 at 0x1F5E // Inputs[5] // { // @1F60 stack[-4] // @1F61 stack[-1] // @1F64 stack[-8] // @1F65 stack[-2] // @1F6A stack[-5] // } 1F5F 5B JUMPDEST 1F60 83 DUP4 1F61 52 MSTORE 1F62 60 PUSH1 0x01 1F64 96 SWAP7 1F65 90 SWAP1 1F66 96 SWAP7 1F67 01 ADD 1F68 95 SWAP6 1F69 91 SWAP2 1F6A 83 DUP4 1F6B 01 ADD 1F6C 91 SWAP2 1F6D 83 DUP4 1F6E 01 ADD 1F6F 61 PUSH2 0x1f4e 1F72 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @1F61 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @1F68 stack[-8] = 0x01 + stack[-8] // @1F6C stack[-4] = stack[-5] + stack[-4] // @1F6E stack[-2] = stack[-5] + stack[-2] // } // Block ends with unconditional jump to 0x1f4e label_1F73: // Incoming jump from 0x1F56, if !(stack[-7] < stack[-5]) // Incoming jump from 0x1F56, if !(stack[-9] < stack[-5]) // Inputs[7] // { // @1F75 stack[-9] // @1F75 stack[-2] // @1F78 stack[-10] // @1F79 stack[-4] // @1F7A msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // @1F7B stack[-7] // @1F7E stack[-6] // } 1F73 5B JUMPDEST 1F74 50 POP 1F75 96 SWAP7 1F76 50 POP 1F77 50 POP 1F78 86 DUP7 1F79 01 ADD 1F7A 35 CALLDATALOAD 1F7B 92 SWAP3 1F7C 50 POP 1F7D 50 POP 1F7E 80 DUP1 1F7F 82 DUP3 1F80 11 GT 1F81 15 ISZERO 1F82 61 PUSH2 0x1f89 1F85 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1F75 stack[-9] = stack[-2] // @1F7B stack[-7] = msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // } // Block ends with conditional jump to 0x1f89, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) label_1F86: // Incoming jump from 0x1F85, if not !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[2] // { // @1F86 stack[-3] // @1F88 memory[stack[-3]:stack[-3] + stack[-3]] // } 1F86 82 DUP3 1F87 83 DUP4 1F88 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F88 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1F89: // Incoming jump from 0x1F85, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Incoming jump from 0x1FE6, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) // Inputs[3] // { // @1F8E stack[-6] // @1F8F stack[-2] // @1F90 stack[-5] // } 1F89 5B JUMPDEST 1F8A 50 POP 1F8B 61 PUSH2 0x1f96 1F8E 85 DUP6 1F8F 82 DUP3 1F90 86 DUP7 1F91 01 ADD 1F92 61 PUSH2 0x1c01 1F95 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1F8B stack[-1] = 0x1f96 // @1F8E stack[0] = stack[-6] // @1F91 stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x1c01, returns to 0x1F96 label_1F96: // Incoming return from call to 0x1C75 at 0x20E1 // Incoming return from call to 0x1C01 at 0x1F95 // Inputs[6] // { // @1F97 stack[-1] // @1F97 stack[-3] // @1F9A stack[-6] // @1F9C stack[-7] // @1F9C stack[-4] // @1F9D stack[-5] // } 1F96 5B JUMPDEST 1F97 91 SWAP2 1F98 50 POP 1F99 50 POP 1F9A 92 SWAP3 1F9B 50 POP 1F9C 92 SWAP3 1F9D 90 SWAP1 1F9E 50 POP 1F9F 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1F9A stack[-6] = stack[-1] // @1F9C stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1FA0: // Incoming jump from 0x0278 // Inputs[2] // { // @1FA6 stack[-1] // @1FA7 stack[-2] // } 1FA0 5B JUMPDEST 1FA1 60 PUSH1 0x00 1FA3 80 DUP1 1FA4 60 PUSH1 0x40 1FA6 83 DUP4 1FA7 85 DUP6 1FA8 03 SUB 1FA9 12 SLT 1FAA 15 ISZERO 1FAB 61 PUSH2 0x1fb2 1FAE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FA1 stack[0] = 0x00 // @1FA3 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1fb2, if !(stack[-2] - stack[-1] i< 0x40) label_1FAF: // Incoming jump from 0x1FAE, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1FAF stack[-2] // @1FB1 memory[stack[-2]:stack[-2] + stack[-2]] // } 1FAF 81 DUP2 1FB0 82 DUP3 1FB1 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FB1 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1FB2: // Incoming jump from 0x1FAE, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1FB3 stack[-3] // @1FB4 msg.data[stack[-3]:stack[-3] + 0x20] // } 1FB2 5B JUMPDEST 1FB3 82 DUP3 1FB4 35 CALLDATALOAD 1FB5 67 PUSH8 0xffffffffffffffff 1FBE 80 DUP1 1FBF 82 DUP3 1FC0 11 GT 1FC1 15 ISZERO 1FC2 61 PUSH2 0x1fc9 1FC5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FB4 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @1FB5 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1fc9, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_1FC6: // Incoming jump from 0x1FC5, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1FC6 stack[-4] // @1FC8 memory[stack[-4]:stack[-4] + stack[-4]] // } 1FC6 83 DUP4 1FC7 84 DUP5 1FC8 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FC8 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_1FC9: // Incoming jump from 0x1FC5, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1FCD stack[-6] // @1FCE stack[-2] // @1FCF stack[-5] // } 1FC9 5B JUMPDEST 1FCA 61 PUSH2 0x1fd5 1FCD 86 DUP7 1FCE 83 DUP4 1FCF 87 DUP8 1FD0 01 ADD 1FD1 61 PUSH2 0x1c01 1FD4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FCA stack[0] = 0x1fd5 // @1FCD stack[1] = stack[-6] // @1FD0 stack[2] = stack[-5] + stack[-2] // } // Block ends with call to 0x1c01, returns to 0x1FD5 label_1FD5: // Incoming return from call to 0x1C01 at 0x1FD4 // Inputs[6] // { // @1FD6 stack[-1] // @1FD6 stack[-5] // @1FDA stack[-6] // @1FDC msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // @1FDD stack[-3] // @1FDF stack[-2] // } 1FD5 5B JUMPDEST 1FD6 93 SWAP4 1FD7 50 POP 1FD8 60 PUSH1 0x20 1FDA 85 DUP6 1FDB 01 ADD 1FDC 35 CALLDATALOAD 1FDD 91 SWAP2 1FDE 50 POP 1FDF 80 DUP1 1FE0 82 DUP3 1FE1 11 GT 1FE2 15 ISZERO 1FE3 61 PUSH2 0x1f89 1FE6 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @1FD6 stack[-5] = stack[-1] // @1FDD stack[-3] = msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1f89, if !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) label_1FE7: // Incoming jump from 0x1FE6, if not !(msg.data[stack[-6] + 0x20:stack[-6] + 0x20 + 0x20] > stack[-2]) // Inputs[2] // { // @1FE7 stack[-3] // @1FE9 memory[stack[-3]:stack[-3] + stack[-3]] // } 1FE7 82 DUP3 1FE8 83 DUP4 1FE9 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FE9 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1FEA: // Incoming call from 0x016E, returns to 0x016F // Inputs[2] // { // @1FEF stack[-1] // @1FF0 stack[-2] // } 1FEA 5B JUMPDEST 1FEB 60 PUSH1 0x00 1FED 60 PUSH1 0x20 1FEF 82 DUP3 1FF0 84 DUP5 1FF1 03 SUB 1FF2 12 SLT 1FF3 15 ISZERO 1FF4 61 PUSH2 0x1ffb 1FF7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1FEB stack[0] = 0x00 } // Block ends with conditional jump to 0x1ffb, if !(stack[-2] - stack[-1] i< 0x20) label_1FF8: // Incoming jump from 0x1FF7, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1FF8 stack[-1] // @1FFA memory[stack[-1]:stack[-1] + stack[-1]] // } 1FF8 80 DUP1 1FF9 81 DUP2 1FFA FD *REVERT // Stack delta = +0 // Outputs[1] { @1FFA revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1FFB: // Incoming jump from 0x1FF7, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1FFC stack[-2] // @1FFD msg.data[stack[-2]:stack[-2] + 0x20] // } 1FFB 5B JUMPDEST 1FFC 81 DUP2 1FFD 35 CALLDATALOAD 1FFE 61 PUSH2 0x1cfe 2001 81 DUP2 2002 61 PUSH2 0x26d5 2005 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1FFD stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1FFE stack[1] = 0x1cfe // @2001 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x26d5, returns to 0x1CFE label_2006: // Incoming jump from 0x177F // Inputs[2] // { // @200B stack[-1] // @200C stack[-2] // } 2006 5B JUMPDEST 2007 60 PUSH1 0x00 2009 60 PUSH1 0x20 200B 82 DUP3 200C 84 DUP5 200D 03 SUB 200E 12 SLT 200F 15 ISZERO 2010 61 PUSH2 0x2017 2013 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2007 stack[0] = 0x00 } // Block ends with conditional jump to 0x2017, if !(stack[-2] - stack[-1] i< 0x20) label_2014: // Incoming jump from 0x2013, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2014 stack[-1] // @2016 memory[stack[-1]:stack[-1] + stack[-1]] // } 2014 80 DUP1 2015 81 DUP2 2016 FD *REVERT // Stack delta = +0 // Outputs[1] { @2016 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2017: // Incoming jump from 0x2013, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2018 stack[-2] // @2019 memory[stack[-2]:stack[-2] + 0x20] // } 2017 5B JUMPDEST 2018 81 DUP2 2019 51 MLOAD 201A 61 PUSH2 0x1cfe 201D 81 DUP2 201E 61 PUSH2 0x26d5 2021 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2019 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @201A stack[1] = 0x1cfe // @201D stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x26d5, returns to 0x1CFE label_2022: // Incoming call from 0x0201, returns to 0x0202 // Incoming call from 0x0237, returns to 0x0238 // Inputs[2] // { // @2028 stack[-1] // @2029 stack[-2] // } 2022 5B JUMPDEST 2023 60 PUSH1 0x00 2025 80 DUP1 2026 60 PUSH1 0x20 2028 83 DUP4 2029 85 DUP6 202A 03 SUB 202B 12 SLT 202C 15 ISZERO 202D 61 PUSH2 0x2034 2030 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2023 stack[0] = 0x00 // @2025 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2034, if !(stack[-2] - stack[-1] i< 0x20) label_2031: // Incoming jump from 0x2030, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2031 stack[-2] // @2033 memory[stack[-2]:stack[-2] + stack[-2]] // } 2031 81 DUP2 2032 82 DUP3 2033 FD *REVERT // Stack delta = +0 // Outputs[1] { @2033 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2034: // Incoming jump from 0x2030, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2035 stack[-3] // @2036 msg.data[stack[-3]:stack[-3] + 0x20] // } 2034 5B JUMPDEST 2035 82 DUP3 2036 35 CALLDATALOAD 2037 67 PUSH8 0xffffffffffffffff 2040 80 DUP1 2041 82 DUP3 2042 11 GT 2043 15 ISZERO 2044 61 PUSH2 0x204b 2047 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2036 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2037 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x204b, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2048: // Incoming jump from 0x2047, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2048 stack[-4] // @204A memory[stack[-4]:stack[-4] + stack[-4]] // } 2048 83 DUP4 2049 84 DUP5 204A FD *REVERT // Stack delta = +0 // Outputs[1] { @204A revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_204B: // Incoming jump from 0x2047, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @204C stack[-2] // @204D stack[-5] // @2051 stack[-6] // } 204B 5B JUMPDEST 204C 81 DUP2 204D 85 DUP6 204E 01 ADD 204F 91 SWAP2 2050 50 POP 2051 85 DUP6 2052 60 PUSH1 0x1f 2054 83 DUP4 2055 01 ADD 2056 12 SLT 2057 61 PUSH2 0x205e 205A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @204F stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x205e, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_205B: // Incoming jump from 0x205A, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @205B stack[-4] // @205D memory[stack[-4]:stack[-4] + stack[-4]] // } 205B 83 DUP4 205C 84 DUP5 205D FD *REVERT // Stack delta = +0 // Outputs[1] { @205D revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_205E: // Incoming jump from 0x205A, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @205F stack[-2] // @2060 msg.data[stack[-2]:stack[-2] + 0x20] // @2061 stack[-1] // } 205E 5B JUMPDEST 205F 81 DUP2 2060 35 CALLDATALOAD 2061 81 DUP2 2062 81 DUP2 2063 11 GT 2064 15 ISZERO 2065 61 PUSH2 0x206c 2068 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2060 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x206c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_2069: // Incoming jump from 0x2068, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @2069 stack[-5] // @206B memory[stack[-5]:stack[-5] + stack[-5]] // } 2069 84 DUP5 206A 85 DUP6 206B FD *REVERT // Stack delta = +0 // Outputs[1] { @206B revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_206C: // Incoming jump from 0x2068, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @206D stack[-7] // @2070 stack[-1] // @2071 stack[-3] // } 206C 5B JUMPDEST 206D 86 DUP7 206E 60 PUSH1 0x20 2070 82 DUP3 2071 85 DUP6 2072 01 ADD 2073 01 ADD 2074 11 GT 2075 15 ISZERO 2076 61 PUSH2 0x207d 2079 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x207d, if !(stack[-3] + stack[-1] + 0x20 > stack[-7]) label_207A: // Incoming jump from 0x2079, if not !(stack[-3] + stack[-1] + 0x20 > stack[-7]) // Inputs[2] // { // @207A stack[-5] // @207C memory[stack[-5]:stack[-5] + stack[-5]] // } 207A 84 DUP5 207B 85 DUP6 207C FD *REVERT // Stack delta = +0 // Outputs[1] { @207C revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_207D: // Incoming jump from 0x2079, if !(stack[-3] + stack[-1] + 0x20 > stack[-7]) // Inputs[6] // { // @2080 stack[-3] // @2081 stack[-1] // @2084 stack[-8] // @2086 stack[-7] // @2088 stack[-2] // @2089 stack[-6] // } 207D 5B JUMPDEST 207E 60 PUSH1 0x20 2080 92 SWAP3 2081 90 SWAP1 2082 92 SWAP3 2083 01 ADD 2084 96 SWAP7 2085 91 SWAP2 2086 95 SWAP6 2087 50 POP 2088 90 SWAP1 2089 93 SWAP4 208A 50 POP 208B 50 POP 208C 50 POP 208D 50 POP 208E 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @2084 stack[-8] = 0x20 + stack[-3] // @2086 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_208F: // Incoming call from 0x0191, returns to 0x0192 // Inputs[2] // { // @2094 stack[-1] // @2095 stack[-2] // } 208F 5B JUMPDEST 2090 60 PUSH1 0x00 2092 60 PUSH1 0x20 2094 82 DUP3 2095 84 DUP5 2096 03 SUB 2097 12 SLT 2098 15 ISZERO 2099 61 PUSH2 0x20a0 209C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2090 stack[0] = 0x00 } // Block ends with conditional jump to 0x20a0, if !(stack[-2] - stack[-1] i< 0x20) label_209D: // Incoming jump from 0x209C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @209D stack[-1] // @209F memory[stack[-1]:stack[-1] + stack[-1]] // } 209D 80 DUP1 209E 81 DUP2 209F FD *REVERT // Stack delta = +0 // Outputs[1] { @209F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_20A0: // Incoming jump from 0x209C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @20A2 msg.data[stack[-2]:stack[-2] + 0x20] // @20A2 stack[-2] // @20A3 stack[-4] // @20A4 stack[-3] // } 20A0 5B JUMPDEST 20A1 50 POP 20A2 35 CALLDATALOAD 20A3 91 SWAP2 20A4 90 SWAP1 20A5 50 POP 20A6 56 *JUMP // Stack delta = -3 // Outputs[1] { @20A3 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_20A7: // Incoming call from 0x029E, returns to 0x029F // Inputs[2] // { // @20AD stack[-1] // @20AE stack[-2] // } 20A7 5B JUMPDEST 20A8 60 PUSH1 0x00 20AA 80 DUP1 20AB 60 PUSH1 0x40 20AD 83 DUP4 20AE 85 DUP6 20AF 03 SUB 20B0 12 SLT 20B1 15 ISZERO 20B2 61 PUSH2 0x20b9 20B5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20A8 stack[0] = 0x00 // @20AA stack[1] = 0x00 // } // Block ends with conditional jump to 0x20b9, if !(stack[-2] - stack[-1] i< 0x40) label_20B6: // Incoming jump from 0x20B5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @20B6 stack[-2] // @20B8 memory[stack[-2]:stack[-2] + stack[-2]] // } 20B6 81 DUP2 20B7 82 DUP3 20B8 FD *REVERT // Stack delta = +0 // Outputs[1] { @20B8 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_20B9: // Incoming jump from 0x20B5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @20BA stack[-3] // @20BB msg.data[stack[-3]:stack[-3] + 0x20] // @20BC stack[-2] // @20C2 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 20B9 5B JUMPDEST 20BA 82 DUP3 20BB 35 CALLDATALOAD 20BC 91 SWAP2 20BD 50 POP 20BE 60 PUSH1 0x20 20C0 83 DUP4 20C1 01 ADD 20C2 35 CALLDATALOAD 20C3 67 PUSH8 0xffffffffffffffff 20CC 81 DUP2 20CD 11 GT 20CE 15 ISZERO 20CF 61 PUSH2 0x20d6 20D2 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @20BC stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @20C2 stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x20d6, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) label_20D3: // Incoming jump from 0x20D2, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @20D3 stack[-2] // @20D5 memory[stack[-2]:stack[-2] + stack[-2]] // } 20D3 81 DUP2 20D4 82 DUP3 20D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @20D5 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_20D6: // Incoming jump from 0x20D2, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @20DA stack[-5] // @20DB stack[-1] // @20DC stack[-4] // } 20D6 5B JUMPDEST 20D7 61 PUSH2 0x1f96 20DA 85 DUP6 20DB 82 DUP3 20DC 86 DUP7 20DD 01 ADD 20DE 61 PUSH2 0x1c75 20E1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20D7 stack[0] = 0x1f96 // @20DA stack[1] = stack[-5] // @20DD stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1c75, returns to 0x1F96 20E2 5B JUMPDEST 20E3 60 PUSH1 0x00 20E5 81 DUP2 20E6 51 MLOAD 20E7 80 DUP1 20E8 84 DUP5 20E9 52 MSTORE 20EA 60 PUSH1 0x20 20EC 80 DUP1 20ED 85 DUP6 20EE 01 ADD 20EF 94 SWAP5 20F0 50 POP 20F1 80 DUP1 20F2 84 DUP5 20F3 01 ADD 20F4 83 DUP4 20F5 5B JUMPDEST 20F6 83 DUP4 20F7 81 DUP2 20F8 10 LT 20F9 15 ISZERO 20FA 61 PUSH2 0x2111 20FD 57 *JUMPI 20FE 81 DUP2 20FF 51 MLOAD 2100 87 DUP8 2101 52 MSTORE 2102 95 SWAP6 2103 82 DUP3 2104 01 ADD 2105 95 SWAP6 2106 90 SWAP1 2107 82 DUP3 2108 01 ADD 2109 90 SWAP1 210A 60 PUSH1 0x01 210C 01 ADD 210D 61 PUSH2 0x20f5 2110 56 *JUMP 2111 5B JUMPDEST 2112 50 POP 2113 94 SWAP5 2114 95 SWAP6 2115 94 SWAP5 2116 50 POP 2117 50 POP 2118 50 POP 2119 50 POP 211A 50 POP 211B 56 *JUMP label_211C: // Incoming call from 0x22CE, returns to 0x22CF // Incoming call from 0x232D, returns to 0x1CFE // Inputs[3] // { // @211F stack[-1] // @2120 memory[stack[-1]:stack[-1] + 0x20] // @2122 stack[-2] // } 211C 5B JUMPDEST 211D 60 PUSH1 0x00 211F 81 DUP2 2120 51 MLOAD 2121 80 DUP1 2122 84 DUP5 2123 52 MSTORE 2124 61 PUSH2 0x2134 2127 81 DUP2 2128 60 PUSH1 0x20 212A 86 DUP7 212B 01 ADD 212C 60 PUSH1 0x20 212E 86 DUP7 212F 01 ADD 2130 61 PUSH2 0x252a 2133 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @211D stack[0] = 0x00 // @2120 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2123 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2124 stack[2] = 0x2134 // @2127 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @212B stack[4] = stack[-2] + 0x20 // @212F stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x252a, returns to 0x2134 label_2134: // Incoming return from call to 0x252A at 0x2133 // Inputs[4] // { // @2137 stack[-1] // @213C stack[-4] // @213D stack[-2] // @2143 stack[-5] // } 2134 5B JUMPDEST 2135 60 PUSH1 0x1f 2137 01 ADD 2138 60 PUSH1 0x1f 213A 19 NOT 213B 16 AND 213C 92 SWAP3 213D 90 SWAP1 213E 92 SWAP3 213F 01 ADD 2140 60 PUSH1 0x20 2142 01 ADD 2143 92 SWAP3 2144 91 SWAP2 2145 50 POP 2146 50 POP 2147 56 *JUMP // Stack delta = -4 // Outputs[1] { @2143 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_2148: // Incoming call from 0x221D, returns to 0x221E // Incoming call from 0x2203, returns to 0x2204 // Inputs[2] // { // @2149 stack[-1] // @214A storage[stack[-1]] // } 2148 5B JUMPDEST 2149 80 DUP1 214A 54 SLOAD 214B 60 PUSH1 0x00 214D 90 SWAP1 214E 60 PUSH1 0x01 2150 81 DUP2 2151 81 DUP2 2152 1C SHR 2153 90 SWAP1 2154 80 DUP1 2155 83 DUP4 2156 16 AND 2157 80 DUP1 2158 61 PUSH2 0x2162 215B 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @214D stack[0] = 0x00 // @214D stack[1] = storage[stack[-1]] // @2153 stack[2] = storage[stack[-1]] >> 0x01 // @2153 stack[3] = 0x01 // @2156 stack[4] = storage[stack[-1]] & 0x01 // } // Block ends with conditional jump to 0x2162, if storage[stack[-1]] & 0x01 label_215C: // Incoming jump from 0x215B, if not storage[stack[-1]] & 0x01 // Inputs[2] // { // @215E stack[-3] // @2168 stack[-1] // } 215C 60 PUSH1 0x7f 215E 83 DUP4 215F 16 AND 2160 92 SWAP3 2161 50 POP 2162 5B JUMPDEST 2163 60 PUSH1 0x20 2165 80 DUP1 2166 84 DUP5 2167 10 LT 2168 82 DUP3 2169 14 EQ 216A 15 ISZERO 216B 61 PUSH2 0x2182 216E 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2160 stack[-3] = stack[-3] & 0x7f // @2163 stack[0] = 0x20 // } // Block ends with conditional jump to 0x2182, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) label_216F: // Incoming jump from 0x216E, if not !(stack[-1] == (stack[-3] < 0x20)) // Incoming jump from 0x216E, if not !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Inputs[2] // { // @2177 stack[-6] // @2181 memory[stack[-6]:stack[-6] + 0x24] // } 216F 63 PUSH4 0x4e487b71 2174 60 PUSH1 0xe0 2176 1B SHL 2177 86 DUP7 2178 52 MSTORE 2179 60 PUSH1 0x22 217B 60 PUSH1 0x04 217D 52 MSTORE 217E 60 PUSH1 0x24 2180 86 DUP7 2181 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2178 memory[stack[-6]:stack[-6] + 0x20] = 0x4e487b71 << 0xe0 // @217D memory[0x04:0x24] = 0x22 // @2181 revert(memory[stack[-6]:stack[-6] + 0x24]); // } // Block terminates label_2182: // Incoming jump from 0x216E, if !(stack[-1] == (stack[-3] < 0x20)) // Incoming jump from 0x216E, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Inputs[1] { @2183 stack[-2] } 2182 5B JUMPDEST 2183 81 DUP2 2184 80 DUP1 2185 15 ISZERO 2186 61 PUSH2 0x2196 2189 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2183 stack[0] = stack[-2] } // Block ends with conditional jump to 0x2196, if !stack[-2] label_218A: // Incoming jump from 0x2189, if not !stack[-2] // Inputs[1] { @218C stack[-1] } 218A 60 PUSH1 0x01 218C 81 DUP2 218D 14 EQ 218E 61 PUSH2 0x21a7 2191 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x21a7, if stack[-1] == 0x01 label_2192: // Incoming jump from 0x2191, if not stack[-1] == 0x01 2192 61 PUSH2 0x21d4 2195 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x21d4 label_2196: // Incoming jump from 0x2189, if !stack[-2] // Inputs[4] // { // @219A stack[-6] // @219C stack[-9] // @219E stack[-5] // @21A1 stack[-7] // } 2196 5B JUMPDEST 2197 60 PUSH1 0xff 2199 19 NOT 219A 86 DUP7 219B 16 AND 219C 89 DUP10 219D 52 MSTORE 219E 84 DUP5 219F 89 DUP10 21A0 01 ADD 21A1 96 SWAP7 21A2 50 POP 21A3 61 PUSH2 0x21d4 21A6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @219D memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @21A1 stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x21d4 label_21A7: // Incoming jump from 0x2191, if stack[-1] == 0x01 // Inputs[3] // { // @21AA stack[-8] // @21B0 memory[0x00:0x20] // @21B4 stack[-5] // } 21A7 5B JUMPDEST 21A8 60 PUSH1 0x00 21AA 88 DUP9 21AB 81 DUP2 21AC 52 MSTORE 21AD 60 PUSH1 0x20 21AF 90 SWAP1 21B0 20 SHA3 21B1 60 PUSH1 0x00 21B3 5B JUMPDEST 21B4 86 DUP7 21B5 81 DUP2 21B6 10 LT 21B7 15 ISZERO 21B8 61 PUSH2 0x21cc 21BB 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @21AC memory[0x00:0x20] = stack[-8] // @21B0 stack[0] = keccak256(memory[0x00:0x20]) // @21B1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x21cc, if !(0x00 < stack[-5]) label_21BC: // Incoming jump from 0x21BB, if not !(0x00 < stack[-5]) // Incoming jump from 0x21BB, if not !(stack[-1] < stack[-7]) // Inputs[6] // { // @21BC stack[-2] // @21BD storage[stack[-2]] // @21BE stack[-11] // @21BF stack[-1] // @21C3 stack[-6] // @21C6 stack[-4] // } 21BC 81 DUP2 21BD 54 SLOAD 21BE 8B DUP12 21BF 82 DUP3 21C0 01 ADD 21C1 52 MSTORE 21C2 90 SWAP1 21C3 85 DUP6 21C4 01 ADD 21C5 90 SWAP1 21C6 83 DUP4 21C7 01 ADD 21C8 61 PUSH2 0x21b3 21CB 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @21C1 memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @21C5 stack[-2] = stack[-6] + stack[-2] // @21C7 stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x21b3 label_21CC: // Incoming jump from 0x21BB, if !(0x00 < stack[-5]) // Incoming jump from 0x21BB, if !(stack[-1] < stack[-7]) // Inputs[3] // { // @21CF stack[-7] // @21D0 stack[-11] // @21D2 stack[-9] // } 21CC 5B JUMPDEST 21CD 50 POP 21CE 50 POP 21CF 84 DUP5 21D0 89 DUP10 21D1 01 ADD 21D2 96 SWAP7 21D3 50 POP // Stack delta = -2 // Outputs[1] { @21D2 stack[-9] = stack[-11] + stack[-7] } // Block continues label_21D4: // Incoming jump from 0x21A6 // Incoming jump from 0x2195 // Incoming jump from 0x21D3 // Inputs[3] // { // @21DB stack[-10] // @21DB stack[-7] // @21DC stack[-9] // } 21D4 5B JUMPDEST 21D5 50 POP 21D6 50 POP 21D7 50 POP 21D8 50 POP 21D9 50 POP 21DA 50 POP 21DB 92 SWAP3 21DC 91 SWAP2 21DD 50 POP 21DE 50 POP 21DF 56 *JUMP // Stack delta = -9 // Outputs[1] { @21DB stack[-10] = stack[-7] } // Block ends with unconditional jump to stack[-10] label_21E0: // Incoming call from 0x12AF, returns to 0x12B0 // Inputs[3] // { // @21EF stack[-4] // @21F4 stack[-1] // @21FF stack[-3] // } 21E0 5B JUMPDEST 21E1 6B PUSH12 0xffffffffffffffffffffffff 21EE 19 NOT 21EF 84 DUP5 21F0 60 PUSH1 0x60 21F2 1B SHL 21F3 16 AND 21F4 81 DUP2 21F5 52 MSTORE 21F6 60 PUSH1 0x00 21F8 61 PUSH2 0x2204 21FB 60 PUSH1 0x14 21FD 83 DUP4 21FE 01 ADD 21FF 85 DUP6 2200 61 PUSH2 0x2148 2203 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @21F5 memory[stack[-1]:stack[-1] + 0x20] = (stack[-4] << 0x60) & ~0xffffffffffffffffffffffff // @21F6 stack[0] = 0x00 // @21F8 stack[1] = 0x2204 // @21FE stack[2] = stack[-1] + 0x14 // @21FF stack[3] = stack[-3] // } // Block ends with call to 0x2148, returns to 0x2204 label_2204: // Incoming return from call to 0x2148 at 0x2203 // Inputs[4] // { // @2205 stack[-4] // @2205 stack[-1] // @220D stack[-7] // @220E stack[-6] // } 2204 5B JUMPDEST 2205 92 SWAP3 2206 83 DUP4 2207 52 MSTORE 2208 50 POP 2209 50 POP 220A 60 PUSH1 0x20 220C 01 ADD 220D 92 SWAP3 220E 91 SWAP2 220F 50 POP 2210 50 POP 2211 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @2207 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @220D stack[-7] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-7] label_2212: // Incoming call from 0x051A, returns to 0x051B // Inputs[2] // { // @2218 stack[-1] // @2219 stack[-3] // } 2212 5B JUMPDEST 2213 60 PUSH1 0x00 2215 61 PUSH2 0x221e 2218 82 DUP3 2219 85 DUP6 221A 61 PUSH2 0x2148 221D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2213 stack[0] = 0x00 // @2215 stack[1] = 0x221e // @2218 stack[2] = stack[-1] // @2219 stack[3] = stack[-3] // } // Block ends with call to 0x2148, returns to 0x221E label_221E: // Incoming return from call to 0x2148 at 0x221D // Inputs[3] // { // @221F stack[-4] // @2220 memory[stack[-4]:stack[-4] + 0x20] // @2225 stack[-1] // } 221E 5B JUMPDEST 221F 83 DUP4 2220 51 MLOAD 2221 61 PUSH2 0x222e 2224 81 DUP2 2225 83 DUP4 2226 60 PUSH1 0x20 2228 88 DUP9 2229 01 ADD 222A 61 PUSH2 0x252a 222D 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2220 stack[0] = memory[stack[-4]:stack[-4] + 0x20] // @2221 stack[1] = 0x222e // @2224 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // @2225 stack[3] = stack[-1] // @2229 stack[4] = stack[-4] + 0x20 // } // Block ends with call to 0x252a, returns to 0x222E label_222E: // Incoming return from call to 0x252A at 0x222D // Inputs[4] // { // @222F stack[-2] // @222F stack[-1] // @2230 stack[-7] // @2231 stack[-6] // } 222E 5B JUMPDEST 222F 01 ADD 2230 94 SWAP5 2231 93 SWAP4 2232 50 POP 2233 50 POP 2234 50 POP 2235 50 POP 2236 56 *JUMP // Stack delta = -6 // Outputs[1] { @2230 stack[-7] = stack[-1] + stack[-2] } // Block ends with unconditional jump to stack[-7] 2237 5B JUMPDEST 2238 60 PUSH1 0x01 223A 60 PUSH1 0x01 223C 60 PUSH1 0xa0 223E 1B SHL 223F 03 SUB 2240 86 DUP7 2241 81 DUP2 2242 16 AND 2243 82 DUP3 2244 52 MSTORE 2245 85 DUP6 2246 16 AND 2247 60 PUSH1 0x20 2249 82 DUP3 224A 01 ADD 224B 52 MSTORE 224C 60 PUSH1 0xa0 224E 60 PUSH1 0x40 2250 82 DUP3 2251 01 ADD 2252 81 DUP2 2253 90 SWAP1 2254 52 MSTORE 2255 60 PUSH1 0x00 2257 90 SWAP1 2258 61 PUSH2 0x2263 225B 90 SWAP1 225C 83 DUP4 225D 01 ADD 225E 86 DUP7 225F 61 PUSH2 0x20e2 2262 56 *JUMP 2263 5B JUMPDEST 2264 82 DUP3 2265 81 DUP2 2266 03 SUB 2267 60 PUSH1 0x60 2269 84 DUP5 226A 01 ADD 226B 52 MSTORE 226C 61 PUSH2 0x2275 226F 81 DUP2 2270 86 DUP7 2271 61 PUSH2 0x20e2 2274 56 *JUMP 2275 5B JUMPDEST 2276 90 SWAP1 2277 50 POP 2278 82 DUP3 2279 81 DUP2 227A 03 SUB 227B 60 PUSH1 0x80 227D 84 DUP5 227E 01 ADD 227F 52 MSTORE 2280 61 PUSH2 0x2289 2283 81 DUP2 2284 85 DUP6 2285 61 PUSH2 0x211c 2288 56 *JUMP 2289 5B JUMPDEST 228A 98 SWAP9 228B 97 SWAP8 228C 50 POP 228D 50 POP 228E 50 POP 228F 50 POP 2290 50 POP 2291 50 POP 2292 50 POP 2293 50 POP 2294 56 *JUMP label_2295: // Incoming call from 0x1738, returns to 0x1739 // Inputs[6] // { // @229E stack[-6] // @22A1 stack[-1] // @22A3 stack[-5] // @22AE stack[-4] // @22B5 stack[-3] // @22CA stack[-2] // } 2295 5B JUMPDEST 2296 60 PUSH1 0x01 2298 60 PUSH1 0x01 229A 60 PUSH1 0xa0 229C 1B SHL 229D 03 SUB 229E 86 DUP7 229F 81 DUP2 22A0 16 AND 22A1 82 DUP3 22A2 52 MSTORE 22A3 85 DUP6 22A4 16 AND 22A5 60 PUSH1 0x20 22A7 82 DUP3 22A8 01 ADD 22A9 52 MSTORE 22AA 60 PUSH1 0x40 22AC 81 DUP2 22AD 01 ADD 22AE 84 DUP5 22AF 90 SWAP1 22B0 52 MSTORE 22B1 60 PUSH1 0x60 22B3 81 DUP2 22B4 01 ADD 22B5 83 DUP4 22B6 90 SWAP1 22B7 52 MSTORE 22B8 60 PUSH1 0xa0 22BA 60 PUSH1 0x80 22BC 82 DUP3 22BD 01 ADD 22BE 81 DUP2 22BF 90 SWAP1 22C0 52 MSTORE 22C1 60 PUSH1 0x00 22C3 90 SWAP1 22C4 61 PUSH2 0x22cf 22C7 90 SWAP1 22C8 83 DUP4 22C9 01 ADD 22CA 84 DUP5 22CB 61 PUSH2 0x211c 22CE 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @22A2 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @22A9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @22B0 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-4] // @22B7 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-3] // @22C0 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = 0xa0 // @22C3 stack[0] = 0x00 // @22C7 stack[1] = 0x22cf // @22C9 stack[2] = stack[-1] + 0xa0 // @22CA stack[3] = stack[-2] // } // Block ends with call to 0x211c, returns to 0x22CF label_22CF: // Incoming return from call to 0x211C at 0x22CE // Inputs[3] // { // @22D0 stack[-1] // @22D0 stack[-9] // @22D1 stack[-8] // } 22CF 5B JUMPDEST 22D0 97 SWAP8 22D1 96 SWAP7 22D2 50 POP 22D3 50 POP 22D4 50 POP 22D5 50 POP 22D6 50 POP 22D7 50 POP 22D8 50 POP 22D9 56 *JUMP // Stack delta = -8 // Outputs[1] { @22D0 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] 22DA 5B JUMPDEST 22DB 60 PUSH1 0x20 22DD 81 DUP2 22DE 52 MSTORE 22DF 60 PUSH1 0x00 22E1 61 PUSH2 0x1cfe 22E4 60 PUSH1 0x20 22E6 83 DUP4 22E7 01 ADD 22E8 84 DUP5 22E9 61 PUSH2 0x20e2 22EC 56 *JUMP 22ED 5B JUMPDEST 22EE 60 PUSH1 0x40 22F0 81 DUP2 22F1 52 MSTORE 22F2 60 PUSH1 0x00 22F4 61 PUSH2 0x2300 22F7 60 PUSH1 0x40 22F9 83 DUP4 22FA 01 ADD 22FB 85 DUP6 22FC 61 PUSH2 0x20e2 22FF 56 *JUMP 2300 5B JUMPDEST 2301 82 DUP3 2302 81 DUP2 2303 03 SUB 2304 60 PUSH1 0x20 2306 84 DUP5 2307 01 ADD 2308 52 MSTORE 2309 61 PUSH2 0x2312 230C 81 DUP2 230D 85 DUP6 230E 61 PUSH2 0x20e2 2311 56 *JUMP 2312 5B JUMPDEST 2313 95 SWAP6 2314 94 SWAP5 2315 50 POP 2316 50 POP 2317 50 POP 2318 50 POP 2319 50 POP 231A 56 *JUMP label_231B: // Incoming jump from 0x1641 // Incoming jump from 0x01A3 // Inputs[2] // { // @231E stack[-1] // @2329 stack[-2] // } 231B 5B JUMPDEST 231C 60 PUSH1 0x20 231E 81 DUP2 231F 52 MSTORE 2320 60 PUSH1 0x00 2322 61 PUSH2 0x1cfe 2325 60 PUSH1 0x20 2327 83 DUP4 2328 01 ADD 2329 84 DUP5 232A 61 PUSH2 0x211c 232D 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @231F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2320 stack[0] = 0x00 // @2322 stack[1] = 0x1cfe // @2328 stack[2] = stack[-1] + 0x20 // @2329 stack[3] = stack[-2] // } // Block ends with call to 0x211c, returns to 0x1CFE label_232E: // Incoming call from 0x17BE, returns to 0x0377 // Inputs[2] // { // @2332 stack[-1] // @2374 stack[-2] // } 232E 5B JUMPDEST 232F 60 PUSH1 0x20 2331 80 DUP1 2332 82 DUP3 2333 52 MSTORE 2334 60 PUSH1 0x28 2336 90 SWAP1 2337 82 DUP3 2338 01 ADD 2339 52 MSTORE 233A 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 235B 60 PUSH1 0x40 235D 82 DUP3 235E 01 ADD 235F 52 MSTORE 2360 67 PUSH8 0x6420746f6b656e73 2369 60 PUSH1 0xc0 236B 1B SHL 236C 60 PUSH1 0x60 236E 82 DUP3 236F 01 ADD 2370 52 MSTORE 2371 60 PUSH1 0x80 2373 01 ADD 2374 90 SWAP1 2375 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2333 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2339 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x28 // @235F memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @2370 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6420746f6b656e73 << 0xc0 // @2374 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2376: // Incoming call from 0x141D, returns to 0x0377 // Inputs[2] // { // @237A stack[-1] // @23B9 stack[-2] // } 2376 5B JUMPDEST 2377 60 PUSH1 0x20 2379 80 DUP1 237A 82 DUP3 237B 52 MSTORE 237C 60 PUSH1 0x25 237E 90 SWAP1 237F 82 DUP3 2380 01 ADD 2381 52 MSTORE 2382 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 23A3 60 PUSH1 0x40 23A5 82 DUP3 23A6 01 ADD 23A7 52 MSTORE 23A8 64 PUSH5 0x6472657373 23AE 60 PUSH1 0xd8 23B0 1B SHL 23B1 60 PUSH1 0x60 23B3 82 DUP3 23B4 01 ADD 23B5 52 MSTORE 23B6 60 PUSH1 0x80 23B8 01 ADD 23B9 90 SWAP1 23BA 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @237B memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2381 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x25 // @23A7 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 // @23B5 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6472657373 << 0xd8 // @23B9 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_23BB: // Incoming call from 0x146E, returns to 0x0377 // Inputs[2] // { // @23BF stack[-1] // @2403 stack[-2] // } 23BB 5B JUMPDEST 23BC 60 PUSH1 0x20 23BE 80 DUP1 23BF 82 DUP3 23C0 52 MSTORE 23C1 60 PUSH1 0x2a 23C3 90 SWAP1 23C4 82 DUP3 23C5 01 ADD 23C6 52 MSTORE 23C7 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 23E8 60 PUSH1 0x40 23EA 82 DUP3 23EB 01 ADD 23EC 52 MSTORE 23ED 69 PUSH10 0x39103a3930b739b332b9 23F8 60 PUSH1 0xb1 23FA 1B SHL 23FB 60 PUSH1 0x60 23FD 82 DUP3 23FE 01 ADD 23FF 52 MSTORE 2400 60 PUSH1 0x80 2402 01 ADD 2403 90 SWAP1 2404 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @23C0 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @23C6 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2a // @23EC memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a20696e73756666696369656e742062616c616e636520666f // @23FF memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x39103a3930b739b332b9 << 0xb1 // @2403 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2405: // Incoming call from 0x0849, returns to 0x0377 // Incoming call from 0x0C01, returns to 0x0377 // Incoming call from 0x0813, returns to 0x0377 // Incoming call from 0x087F, returns to 0x0377 // Incoming call from 0x098C, returns to 0x0377 // Incoming call from 0x0A32, returns to 0x0377 // Inputs[2] // { // @2409 stack[-1] // @2438 stack[-2] // } 2405 5B JUMPDEST 2406 60 PUSH1 0x20 2408 80 DUP1 2409 82 DUP3 240A 52 MSTORE 240B 81 DUP2 240C 81 DUP2 240D 01 ADD 240E 52 MSTORE 240F 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2430 60 PUSH1 0x40 2432 82 DUP3 2433 01 ADD 2434 52 MSTORE 2435 60 PUSH1 0x60 2437 01 ADD 2438 90 SWAP1 2439 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @240A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @240E memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @2434 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2438 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 243A 5B JUMPDEST 243B 60 PUSH1 0x20 243D 80 DUP1 243E 82 DUP3 243F 52 MSTORE 2440 60 PUSH1 0x28 2442 90 SWAP1 2443 82 DUP3 2444 01 ADD 2445 52 MSTORE 2446 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 2467 60 PUSH1 0x40 2469 82 DUP3 246A 01 ADD 246B 52 MSTORE 246C 67 PUSH8 0x0dad2e6dac2e8c6d 2475 60 PUSH1 0xc3 2477 1B SHL 2478 60 PUSH1 0x60 247A 82 DUP3 247B 01 ADD 247C 52 MSTORE 247D 60 PUSH1 0x80 247F 01 ADD 2480 90 SWAP1 2481 56 *JUMP label_2482: // Incoming call from 0x134D, returns to 0x0377 // Inputs[2] // { // @2486 stack[-1] // @24C1 stack[-2] // } 2482 5B JUMPDEST 2483 60 PUSH1 0x20 2485 80 DUP1 2486 82 DUP3 2487 52 MSTORE 2488 60 PUSH1 0x21 248A 90 SWAP1 248B 82 DUP3 248C 01 ADD 248D 52 MSTORE 248E 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 24AF 60 PUSH1 0x40 24B1 82 DUP3 24B2 01 ADD 24B3 52 MSTORE 24B4 60 PUSH1 0x73 24B6 60 PUSH1 0xf8 24B8 1B SHL 24B9 60 PUSH1 0x60 24BB 82 DUP3 24BC 01 ADD 24BD 52 MSTORE 24BE 60 PUSH1 0x80 24C0 01 ADD 24C1 90 SWAP1 24C2 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2487 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @248D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x21 // @24B3 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @24BD memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x73 << 0xf8 // @24C1 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_24C3: // Incoming call from 0x1C1D, returns to 0x1C1E // Incoming call from 0x1F1D, returns to 0x1F1E // Inputs[1] { @24CF stack[-1] } 24C3 5B JUMPDEST 24C4 60 PUSH1 0x00 24C6 67 PUSH8 0xffffffffffffffff 24CF 82 DUP3 24D0 11 GT 24D1 15 ISZERO 24D2 61 PUSH2 0x24dd 24D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24C4 stack[0] = 0x00 } // Block ends with conditional jump to 0x24dd, if !(stack[-1] > 0xffffffffffffffff) label_24D6: // Incoming jump from 0x24D5, if not !(stack[-1] > 0xffffffffffffffff) 24D6 61 PUSH2 0x24dd 24D9 61 PUSH2 0x261d 24DC 56 *JUMP // Stack delta = +1 // Outputs[1] { @24D6 stack[0] = 0x24dd } // Block ends with unconditional jump to 0x261d label_24DD: // Incoming jump from 0x24D5, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @24E1 stack[-2] // @24E5 stack[-3] // } 24DD 5B JUMPDEST 24DE 50 POP 24DF 60 PUSH1 0x05 24E1 1B SHL 24E2 60 PUSH1 0x20 24E4 01 ADD 24E5 90 SWAP1 24E6 56 *JUMP // Stack delta = -2 // Outputs[1] { @24E5 stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_24E7: // Incoming call from 0x1397, returns to 0x1398 // Incoming call from 0x0D40, returns to 0x0D41 // Incoming call from 0x14AB, returns to 0x14AC // Inputs[2] // { // @24EA stack[-2] // @24EC stack[-1] // } 24E7 5B JUMPDEST 24E8 60 PUSH1 0x00 24EA 82 DUP3 24EB 19 NOT 24EC 82 DUP3 24ED 11 GT 24EE 15 ISZERO 24EF 61 PUSH2 0x24fa 24F2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24E8 stack[0] = 0x00 } // Block ends with conditional jump to 0x24fa, if !(stack[-1] > ~stack[-2]) label_24F3: // Incoming jump from 0x24F2, if not !(stack[-1] > ~stack[-2]) 24F3 61 PUSH2 0x24fa 24F6 61 PUSH2 0x25f1 24F9 56 *JUMP // Stack delta = +1 // Outputs[1] { @24F3 stack[0] = 0x24fa } // Block ends with unconditional jump to 0x25f1 label_24FA: // Incoming jump from 0x24F2, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @24FC stack[-2] // @24FC stack[-3] // @24FD stack[-4] // } 24FA 5B JUMPDEST 24FB 50 POP 24FC 01 ADD 24FD 90 SWAP1 24FE 56 *JUMP // Stack delta = -3 // Outputs[1] { @24FD stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_24FF: // Incoming call from 0x0CB9, returns to 0x0CBA // Incoming call from 0x0D85, returns to 0x0D86 // Inputs[1] { @2502 stack[-2] } 24FF 5B JUMPDEST 2500 60 PUSH1 0x00 2502 82 DUP3 2503 61 PUSH2 0x250e 2506 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2500 stack[0] = 0x00 } // Block ends with conditional jump to 0x250e, if stack[-2] label_2507: // Incoming jump from 0x2506, if not stack[-2] 2507 61 PUSH2 0x250e 250A 61 PUSH2 0x2607 250D 56 *JUMP // Stack delta = +1 // Outputs[1] { @2507 stack[0] = 0x250e } // Block ends with unconditional jump to 0x2607 label_250E: // Incoming jump from 0x2506, if stack[-2] // Inputs[3] // { // @2510 stack[-2] // @2510 stack[-3] // @2511 stack[-4] // } 250E 5B JUMPDEST 250F 50 POP 2510 04 DIV 2511 90 SWAP1 2512 56 *JUMP // Stack delta = -3 // Outputs[1] { @2511 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2513: // Incoming call from 0x0D28, returns to 0x0D29 // Inputs[2] // { // @2516 stack[-2] // @2517 stack[-1] // } 2513 5B JUMPDEST 2514 60 PUSH1 0x00 2516 82 DUP3 2517 82 DUP3 2518 10 LT 2519 15 ISZERO 251A 61 PUSH2 0x2525 251D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2514 stack[0] = 0x00 } // Block ends with conditional jump to 0x2525, if !(stack[-1] < stack[-2]) label_251E: // Incoming jump from 0x251D, if not !(stack[-1] < stack[-2]) 251E 61 PUSH2 0x2525 2521 61 PUSH2 0x25f1 2524 56 *JUMP // Stack delta = +1 // Outputs[1] { @251E stack[0] = 0x2525 } // Block ends with unconditional jump to 0x25f1 label_2525: // Incoming jump from 0x251D, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @2527 stack[-2] // @2527 stack[-3] // @2528 stack[-4] // } 2525 5B JUMPDEST 2526 50 POP 2527 03 SUB 2528 90 SWAP1 2529 56 *JUMP // Stack delta = -3 // Outputs[1] { @2528 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_252A: // Incoming call from 0x2133, returns to 0x2134 // Incoming call from 0x222D, returns to 0x222E // Inputs[1] { @252E stack[-3] } 252A 5B JUMPDEST 252B 60 PUSH1 0x00 252D 5B JUMPDEST 252E 83 DUP4 252F 81 DUP2 2530 10 LT 2531 15 ISZERO 2532 61 PUSH2 0x2545 2535 57 *JUMPI // Stack delta = +1 // Outputs[1] { @252B stack[0] = 0x00 } // Block ends with conditional jump to 0x2545, if !(0x00 < stack[-3]) label_2536: // Incoming jump from 0x2535, if not !(0x00 < stack[-3]) // Incoming jump from 0x2535, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @2536 stack[-2] // @2537 stack[-1] // @2539 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @253A stack[-3] // } 2536 81 DUP2 2537 81 DUP2 2538 01 ADD 2539 51 MLOAD 253A 83 DUP4 253B 82 DUP3 253C 01 ADD 253D 52 MSTORE 253E 60 PUSH1 0x20 2540 01 ADD 2541 61 PUSH2 0x252d 2544 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @253D memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2540 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x252d label_2545: // Incoming jump from 0x2535, if !(0x00 < stack[-3]) // Incoming jump from 0x2535, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @2546 stack[-4] // @2547 stack[-1] // } 2545 5B JUMPDEST 2546 83 DUP4 2547 81 DUP2 2548 11 GT 2549 15 ISZERO 254A 61 PUSH2 0x2554 254D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2554, if !(stack[-1] > stack[-4]) label_254E: // Incoming jump from 0x254D, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @2550 stack[-4] // @2551 stack[-3] // @2559 stack[-5] // } 254E 60 PUSH1 0x00 2550 84 DUP5 2551 84 DUP5 2552 01 ADD 2553 52 MSTORE 2554 5B JUMPDEST 2555 50 POP 2556 50 POP 2557 50 POP 2558 50 POP 2559 56 *JUMP // Stack delta = -5 // Outputs[1] { @2553 memory[stack[-3] + stack[-4]:stack[-3] + stack[-4] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_255A: // Incoming call from 0x1B57, returns to 0x1B58 // Incoming call from 0x047B, returns to 0x047C // Incoming call from 0x0467, returns to 0x0468 // Incoming call from 0x04A7, returns to 0x04A8 // Inputs[1] { @255D stack[-1] } 255A 5B JUMPDEST 255B 60 PUSH1 0x01 255D 81 DUP2 255E 81 DUP2 255F 1C SHR 2560 90 SWAP1 2561 82 DUP3 2562 16 AND 2563 80 DUP1 2564 61 PUSH2 0x256e 2567 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2560 stack[0] = stack[-1] >> 0x01 // @2562 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x256e, if stack[-1] & 0x01 label_2568: // Incoming jump from 0x2567, if not stack[-1] & 0x01 // Inputs[2] // { // @256A stack[-2] // @2573 stack[-1] // } 2568 60 PUSH1 0x7f 256A 82 DUP3 256B 16 AND 256C 91 SWAP2 256D 50 POP 256E 5B JUMPDEST 256F 60 PUSH1 0x20 2571 82 DUP3 2572 10 LT 2573 81 DUP2 2574 14 EQ 2575 15 ISZERO 2576 61 PUSH2 0x258f 2579 57 *JUMPI // Stack delta = +0 // Outputs[1] { @256C stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x258f, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_257A: // Incoming jump from 0x2579, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2579, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @258E memory[0x00:0x24] } 257A 63 PUSH4 0x4e487b71 257F 60 PUSH1 0xe0 2581 1B SHL 2582 60 PUSH1 0x00 2584 52 MSTORE 2585 60 PUSH1 0x22 2587 60 PUSH1 0x04 2589 52 MSTORE 258A 60 PUSH1 0x24 258C 60 PUSH1 0x00 258E FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2584 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2589 memory[0x04:0x24] = 0x22 // @258E revert(memory[0x00:0x24]); // } // Block terminates label_258F: // Incoming jump from 0x2579, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x2579, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @2591 stack[-4] // @2591 stack[-2] // @2592 stack[-3] // } 258F 5B JUMPDEST 2590 50 POP 2591 91 SWAP2 2592 90 SWAP1 2593 50 POP 2594 56 *JUMP // Stack delta = -3 // Outputs[1] { @2591 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2595: // Incoming call from 0x1C2A, returns to 0x1C2B // Incoming call from 0x1F2A, returns to 0x1F2B // Incoming call from 0x1CB5, returns to 0x1CB6 // Incoming call from 0x26C9, returns to 0x26CA // Inputs[2] // { // @2598 stack[-2] // @259E stack[-1] // } 2595 5B JUMPDEST 2596 60 PUSH1 0x1f 2598 82 DUP3 2599 01 ADD 259A 60 PUSH1 0x1f 259C 19 NOT 259D 16 AND 259E 81 DUP2 259F 01 ADD 25A0 67 PUSH8 0xffffffffffffffff 25A9 81 DUP2 25AA 11 GT 25AB 82 DUP3 25AC 82 DUP3 25AD 10 LT 25AE 17 OR 25AF 15 ISZERO 25B0 61 PUSH2 0x25bb 25B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @259F stack[0] = stack[-1] + (~0x1f & stack[-2] + 0x1f) } // Block ends with conditional jump to 0x25bb, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) label_25B4: // Incoming jump from 0x25B3, if not !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) 25B4 61 PUSH2 0x25bb 25B7 61 PUSH2 0x261d 25BA 56 *JUMP // Stack delta = +1 // Outputs[1] { @25B4 stack[0] = 0x25bb } // Block ends with unconditional jump to 0x261d label_25BB: // Incoming jump from 0x25B3, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) // Inputs[2] // { // @25BE stack[-1] // @25C1 stack[-4] // } 25BB 5B JUMPDEST 25BC 60 PUSH1 0x40 25BE 52 MSTORE 25BF 50 POP 25C0 50 POP 25C1 56 *JUMP // Stack delta = -4 // Outputs[1] { @25BE memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_25C2: // Incoming call from 0x0CAA, returns to 0x0CAB // Inputs[1] { @25C8 stack[-1] } 25C2 5B JUMPDEST 25C3 60 PUSH1 0x00 25C5 60 PUSH1 0x00 25C7 19 NOT 25C8 82 DUP3 25C9 14 EQ 25CA 15 ISZERO 25CB 61 PUSH2 0x25d6 25CE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25C3 stack[0] = 0x00 } // Block ends with conditional jump to 0x25d6, if !(stack[-1] == ~0x00) label_25CF: // Incoming jump from 0x25CE, if not !(stack[-1] == ~0x00) 25CF 61 PUSH2 0x25d6 25D2 61 PUSH2 0x25f1 25D5 56 *JUMP // Stack delta = +1 // Outputs[1] { @25CF stack[0] = 0x25d6 } // Block ends with unconditional jump to 0x25f1 label_25D6: // Incoming jump from 0x25CE, if !(stack[-1] == ~0x00) // Inputs[2] // { // @25DA stack[-2] // @25DB stack[-3] // } 25D6 5B JUMPDEST 25D7 50 POP 25D8 60 PUSH1 0x01 25DA 01 ADD 25DB 90 SWAP1 25DC 56 *JUMP // Stack delta = -2 // Outputs[1] { @25DB stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_25DD: // Incoming call from 0x0D35, returns to 0x0D36 // Inputs[1] { @25E0 stack[-2] } 25DD 5B JUMPDEST 25DE 60 PUSH1 0x00 25E0 82 DUP3 25E1 61 PUSH2 0x25ec 25E4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25DE stack[0] = 0x00 } // Block ends with conditional jump to 0x25ec, if stack[-2] label_25E5: // Incoming jump from 0x25E4, if not stack[-2] 25E5 61 PUSH2 0x25ec 25E8 61 PUSH2 0x2607 25EB 56 *JUMP // Stack delta = +1 // Outputs[1] { @25E5 stack[0] = 0x25ec } // Block ends with unconditional jump to 0x2607 label_25EC: // Incoming jump from 0x25E4, if stack[-2] // Inputs[3] // { // @25EE stack[-2] // @25EE stack[-3] // @25EF stack[-4] // } 25EC 5B JUMPDEST 25ED 50 POP 25EE 06 MOD 25EF 90 SWAP1 25F0 56 *JUMP // Stack delta = -3 // Outputs[1] { @25EF stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_25F1: // Incoming jump from 0x24F9 // Incoming jump from 0x25D5 // Incoming jump from 0x2524 // Inputs[1] { @2606 memory[0x00:0x24] } 25F1 5B JUMPDEST 25F2 63 PUSH4 0x4e487b71 25F7 60 PUSH1 0xe0 25F9 1B SHL 25FA 60 PUSH1 0x00 25FC 52 MSTORE 25FD 60 PUSH1 0x11 25FF 60 PUSH1 0x04 2601 52 MSTORE 2602 60 PUSH1 0x24 2604 60 PUSH1 0x00 2606 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @25FC memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2601 memory[0x04:0x24] = 0x11 // @2606 revert(memory[0x00:0x24]); // } // Block terminates label_2607: // Incoming jump from 0x25EB // Incoming jump from 0x250D // Inputs[1] { @261C memory[0x00:0x24] } 2607 5B JUMPDEST 2608 63 PUSH4 0x4e487b71 260D 60 PUSH1 0xe0 260F 1B SHL 2610 60 PUSH1 0x00 2612 52 MSTORE 2613 60 PUSH1 0x12 2615 60 PUSH1 0x04 2617 52 MSTORE 2618 60 PUSH1 0x24 261A 60 PUSH1 0x00 261C FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2612 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2617 memory[0x04:0x24] = 0x12 // @261C revert(memory[0x00:0x24]); // } // Block terminates label_261D: // Incoming jump from 0x24DC // Incoming jump from 0x1C9E // Incoming jump from 0x25BA // Inputs[1] { @2632 memory[0x00:0x24] } 261D 5B JUMPDEST 261E 63 PUSH4 0x4e487b71 2623 60 PUSH1 0xe0 2625 1B SHL 2626 60 PUSH1 0x00 2628 52 MSTORE 2629 60 PUSH1 0x41 262B 60 PUSH1 0x04 262D 52 MSTORE 262E 60 PUSH1 0x24 2630 60 PUSH1 0x00 2632 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2628 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @262D memory[0x04:0x24] = 0x41 // @2632 revert(memory[0x00:0x24]); // } // Block terminates label_2633: // Incoming call from 0x178E, returns to 0x1608 // Inputs[1] { @2638 returndata.length } 2633 5B JUMPDEST 2634 60 PUSH1 0x00 2636 60 PUSH1 0x03 2638 3D RETURNDATASIZE 2639 11 GT 263A 15 ISZERO 263B 61 PUSH2 0x2648 263E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2634 stack[0] = 0x00 } // Block ends with conditional jump to 0x2648, if !(returndata.length > 0x03) label_263F: // Incoming jump from 0x263E, if not !(returndata.length > 0x03) // Inputs[4] // { // @2641 stack[-1] // @2643 returndata[stack[-1]:stack[-1] + 0x04] // @2644 memory[stack[-1]:stack[-1] + 0x20] // @2649 stack[-2] // } 263F 60 PUSH1 0x04 2641 81 DUP2 2642 82 DUP3 2643 3E RETURNDATACOPY 2644 51 MLOAD 2645 60 PUSH1 0xe0 2647 1C SHR 2648 5B JUMPDEST 2649 90 SWAP1 264A 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @2643 memory[stack[-1]:stack[-1] + 0x04] = returndata[stack[-1]:stack[-1] + 0x04] // @2649 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] >> 0xe0 // } // Block ends with unconditional jump to stack[-2] label_264B: // Incoming call from 0x161C, returns to 0x161D // Inputs[1] { @2650 returndata.length } 264B 5B JUMPDEST 264C 60 PUSH1 0x00 264E 60 PUSH1 0x44 2650 3D RETURNDATASIZE 2651 10 LT 2652 15 ISZERO 2653 61 PUSH2 0x2659 2656 57 *JUMPI // Stack delta = +1 // Outputs[1] { @264C stack[0] = 0x00 } // Block ends with conditional jump to 0x2659, if !(returndata.length < 0x44) label_2657: // Incoming jump from 0x2656, if not !(returndata.length < 0x44) // Inputs[2] // { // @2657 stack[-2] // @2657 stack[-1] // } 2657 90 SWAP1 2658 56 *JUMP // Stack delta = -1 // Outputs[1] { @2657 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_2659: // Incoming jump from 0x2656, if !(returndata.length < 0x44) // Inputs[5] // { // @265C memory[0x40:0x60] // @2660 returndata.length // @2666 returndata[0x04:0x04 + ~0x03 + returndata.length] // @2668 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2669 returndata.length // } 2659 5B JUMPDEST 265A 60 PUSH1 0x40 265C 51 MLOAD 265D 60 PUSH1 0x03 265F 19 NOT 2660 3D RETURNDATASIZE 2661 81 DUP2 2662 01 ADD 2663 60 PUSH1 0x04 2665 83 DUP4 2666 3E RETURNDATACOPY 2667 81 DUP2 2668 51 MLOAD 2669 3D RETURNDATASIZE 266A 67 PUSH8 0xffffffffffffffff 2673 81 DUP2 2674 60 PUSH1 0x24 2676 84 DUP5 2677 01 ADD 2678 11 GT 2679 81 DUP2 267A 84 DUP5 267B 11 GT 267C 17 OR 267D 15 ISZERO 267E 61 PUSH2 0x2689 2681 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @265C stack[0] = memory[0x40:0x60] // @265F stack[1] = ~0x03 // @2666 memory[memory[0x40:0x60]:memory[0x40:0x60] + ~0x03 + returndata.length] = returndata[0x04:0x04 + ~0x03 + returndata.length] // @2668 stack[2] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @2669 stack[3] = returndata.length // @266A stack[4] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2689, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) label_2682: // Incoming jump from 0x2681, if not !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[2] // { // @2687 stack[-7] // @2687 stack[-6] // } 2682 50 POP 2683 50 POP 2684 50 POP 2685 50 POP 2686 50 POP 2687 90 SWAP1 2688 56 *JUMP // Stack delta = -6 // Outputs[1] { @2687 stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_2689: // Incoming jump from 0x2681, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[5] // { // @268A stack[-3] // @268B stack[-5] // @268D stack[-2] // @2690 memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // @2691 stack[-1] // } 2689 5B JUMPDEST 268A 82 DUP3 268B 85 DUP6 268C 01 ADD 268D 91 SWAP2 268E 50 POP 268F 81 DUP2 2690 51 MLOAD 2691 81 DUP2 2692 81 DUP2 2693 11 GT 2694 15 ISZERO 2695 61 PUSH2 0x26a1 2698 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @268D stack[-2] = stack[-5] + stack[-3] // @2690 stack[0] = memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x26a1, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) label_2699: // Incoming jump from 0x2698, if not !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[2] // { // @269F stack[-7] // @269F stack[-8] // } 2699 50 POP 269A 50 POP 269B 50 POP 269C 50 POP 269D 50 POP 269E 50 POP 269F 90 SWAP1 26A0 56 *JUMP // Stack delta = -7 // Outputs[1] { @269F stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_26A1: // Incoming jump from 0x2698, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[5] // { // @26A2 stack[-5] // @26A3 returndata.length // @26A4 stack[-6] // @26A9 stack[-1] // @26AA stack[-3] // } 26A1 5B JUMPDEST 26A2 84 DUP5 26A3 3D RETURNDATASIZE 26A4 87 DUP8 26A5 01 ADD 26A6 01 ADD 26A7 60 PUSH1 0x20 26A9 82 DUP3 26AA 85 DUP6 26AB 01 ADD 26AC 01 ADD 26AD 11 GT 26AE 15 ISZERO 26AF 61 PUSH2 0x26bb 26B2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x26bb, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) label_26B3: // Incoming jump from 0x26B2, if not !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[2] // { // @26B9 stack[-8] // @26B9 stack[-7] // } 26B3 50 POP 26B4 50 POP 26B5 50 POP 26B6 50 POP 26B7 50 POP 26B8 50 POP 26B9 90 SWAP1 26BA 56 *JUMP // Stack delta = -7 // Outputs[1] { @26B9 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_26BB: // Incoming jump from 0x26B2, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[3] // { // @26C1 stack[-1] // @26C2 stack[-4] // @26C5 stack[-6] // } 26BB 5B JUMPDEST 26BC 61 PUSH2 0x26ca 26BF 60 PUSH1 0x20 26C1 82 DUP3 26C2 86 DUP7 26C3 01 ADD 26C4 01 ADD 26C5 87 DUP8 26C6 61 PUSH2 0x2595 26C9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @26BC stack[0] = 0x26ca // @26C4 stack[1] = stack[-4] + stack[-1] + 0x20 // @26C5 stack[2] = stack[-6] // } // Block ends with call to 0x2595, returns to 0x26CA label_26CA: // Incoming return from call to 0x2595 at 0x26C9 // Inputs[4] // { // @26CC stack[-3] // @26CC stack[-2] // @26CD stack[-8] // @26CE stack[-7] // } 26CA 5B JUMPDEST 26CB 50 POP 26CC 90 SWAP1 26CD 95 SWAP6 26CE 94 SWAP5 26CF 50 POP 26D0 50 POP 26D1 50 POP 26D2 50 POP 26D3 50 POP 26D4 56 *JUMP // Stack delta = -7 // Outputs[1] { @26CD stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] label_26D5: // Incoming call from 0x2021, returns to 0x1CFE // Incoming call from 0x2005, returns to 0x1CFE // Inputs[1] { @26DF stack[-1] } 26D5 5B JUMPDEST 26D6 60 PUSH1 0x01 26D8 60 PUSH1 0x01 26DA 60 PUSH1 0xe0 26DC 1B SHL 26DD 03 SUB 26DE 19 NOT 26DF 81 DUP2 26E0 16 AND 26E1 81 DUP2 26E2 14 EQ 26E3 61 PUSH2 0x0c70 26E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c70, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_26E7: // Incoming jump from 0x26E6, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @26EA memory[0x00:0x00] } 26E7 60 PUSH1 0x00 26E9 80 DUP1 26EA FD *REVERT // Stack delta = +0 // Outputs[1] { @26EA revert(memory[0x00:0x00]); } // Block terminates 26EB FE *ASSERT 26EC A2 LOG2 26ED 64 PUSH5 0x6970667358 26F3 22 22 26F4 12 SLT 26F5 20 SHA3 26F6 72 PUSH19 0xb7372a8c655062d2685fc467a2c259a0c0d780 270A DA DA 270B AD AD 270C E2 E2 270D FC FC 270E 1A BYTE 270F 24 24 2710 16 AND 2711 66 PUSH7 0x7048141a64736f 2719 6C PUSH13 0x63430008040033