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 0x0115 0019 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0115, 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 0x715018a6 0026 11 GT 0027 61 PUSH2 0x00a2 002A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @001F stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00a2, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_002B: // Incoming jump from 0x002A, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @002B stack[-1] } 002B 80 DUP1 002C 63 PUSH4 0xbf70d34f 0031 11 GT 0032 61 PUSH2 0x0071 0035 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0071, if 0xbf70d34f > stack[-1] label_0036: // Incoming jump from 0x0035, if not 0xbf70d34f > stack[-1] // Inputs[1] { @0036 stack[-1] } 0036 80 DUP1 0037 63 PUSH4 0xbf70d34f 003C 14 EQ 003D 61 PUSH2 0x0237 0040 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0237, if 0xbf70d34f == stack[-1] label_0041: // Incoming jump from 0x0040, if not 0xbf70d34f == stack[-1] // Inputs[1] { @0041 stack[-1] } 0041 80 DUP1 0042 63 PUSH4 0xc87b56dd 0047 14 EQ 0048 61 PUSH2 0x0240 004B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0240, if 0xc87b56dd == stack[-1] label_004C: // Incoming jump from 0x004B, if not 0xc87b56dd == stack[-1] // Inputs[1] { @004C stack[-1] } 004C 80 DUP1 004D 63 PUSH4 0xe985e9c5 0052 14 EQ 0053 61 PUSH2 0x0253 0056 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0253, 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 0x028f 0061 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x028f, 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 0x02a2 006C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a2, if 0xf2fde38b == stack[-1] label_006D: // Incoming jump from 0x006C, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0070 memory[0x00:0x00] } 006D 60 PUSH1 0x00 006F 80 DUP1 0070 FD *REVERT // Stack delta = +0 // Outputs[1] { @0070 revert(memory[0x00:0x00]); } // Block terminates label_0071: // Incoming jump from 0x0035, if 0xbf70d34f > stack[-1] // Inputs[1] { @0072 stack[-1] } 0071 5B JUMPDEST 0072 80 DUP1 0073 63 PUSH4 0x715018a6 0078 14 EQ 0079 61 PUSH2 0x01f9 007C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f9, if 0x715018a6 == stack[-1] label_007D: // Incoming jump from 0x007C, if not 0x715018a6 == stack[-1] // Inputs[1] { @007D stack[-1] } 007D 80 DUP1 007E 63 PUSH4 0x8da5cb5b 0083 14 EQ 0084 61 PUSH2 0x0201 0087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0201, if 0x8da5cb5b == stack[-1] label_0088: // Incoming jump from 0x0087, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0088 stack[-1] } 0088 80 DUP1 0089 63 PUSH4 0x95d89b41 008E 14 EQ 008F 61 PUSH2 0x021c 0092 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021c, if 0x95d89b41 == stack[-1] label_0093: // Incoming jump from 0x0092, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0093 stack[-1] } 0093 80 DUP1 0094 63 PUSH4 0xa22cb465 0099 14 EQ 009A 61 PUSH2 0x0224 009D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0224, if 0xa22cb465 == stack[-1] label_009E: // Incoming jump from 0x009D, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00A1 memory[0x00:0x00] } 009E 60 PUSH1 0x00 00A0 80 DUP1 00A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00A1 revert(memory[0x00:0x00]); } // Block terminates label_00A2: // Incoming jump from 0x002A, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00A3 stack[-1] } 00A2 5B JUMPDEST 00A3 80 DUP1 00A4 63 PUSH4 0x1386a57e 00A9 11 GT 00AA 61 PUSH2 0x00e9 00AD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00e9, if 0x1386a57e > stack[-1] label_00AE: // Incoming jump from 0x00AD, if not 0x1386a57e > stack[-1] // Inputs[1] { @00AE stack[-1] } 00AE 80 DUP1 00AF 63 PUSH4 0x1386a57e 00B4 14 EQ 00B5 61 PUSH2 0x018b 00B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x018b, if 0x1386a57e == stack[-1] label_00B9: // Incoming jump from 0x00B8, if not 0x1386a57e == stack[-1] // Inputs[1] { @00B9 stack[-1] } 00B9 80 DUP1 00BA 63 PUSH4 0x156e29f6 00BF 14 EQ 00C0 61 PUSH2 0x01a0 00C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a0, if 0x156e29f6 == stack[-1] label_00C4: // Incoming jump from 0x00C3, if not 0x156e29f6 == stack[-1] // Inputs[1] { @00C4 stack[-1] } 00C4 80 DUP1 00C5 63 PUSH4 0x162094c4 00CA 14 EQ 00CB 61 PUSH2 0x01b3 00CE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b3, if 0x162094c4 == stack[-1] label_00CF: // Incoming jump from 0x00CE, if not 0x162094c4 == stack[-1] // Inputs[1] { @00CF stack[-1] } 00CF 80 DUP1 00D0 63 PUSH4 0x2eb2c2d6 00D5 14 EQ 00D6 61 PUSH2 0x01c6 00D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c6, if 0x2eb2c2d6 == stack[-1] label_00DA: // Incoming jump from 0x00D9, if not 0x2eb2c2d6 == stack[-1] // Inputs[1] { @00DA stack[-1] } 00DA 80 DUP1 00DB 63 PUSH4 0x4e1273f4 00E0 14 EQ 00E1 61 PUSH2 0x01d9 00E4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d9, if 0x4e1273f4 == stack[-1] label_00E5: // Incoming jump from 0x00E4, if not 0x4e1273f4 == stack[-1] // Inputs[1] { @00E8 memory[0x00:0x00] } 00E5 60 PUSH1 0x00 00E7 80 DUP1 00E8 FD *REVERT // Stack delta = +0 // Outputs[1] { @00E8 revert(memory[0x00:0x00]); } // Block terminates label_00E9: // Incoming jump from 0x00AD, if 0x1386a57e > stack[-1] // Inputs[1] { @00EA stack[-1] } 00E9 5B JUMPDEST 00EA 80 DUP1 00EB 62 PUSH3 0xfdd58e 00EF 14 EQ 00F0 61 PUSH2 0x011a 00F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011a, if 0xfdd58e == stack[-1] label_00F4: // Incoming jump from 0x00F3, if not 0xfdd58e == stack[-1] // Inputs[1] { @00F4 stack[-1] } 00F4 80 DUP1 00F5 63 PUSH4 0x01ffc9a7 00FA 14 EQ 00FB 61 PUSH2 0x0140 00FE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0140, if 0x01ffc9a7 == stack[-1] label_00FF: // Incoming jump from 0x00FE, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @00FF stack[-1] } 00FF 80 DUP1 0100 63 PUSH4 0x06fdde03 0105 14 EQ 0106 61 PUSH2 0x0163 0109 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0163, if 0x06fdde03 == stack[-1] label_010A: // Incoming jump from 0x0109, if not 0x06fdde03 == stack[-1] // Inputs[1] { @010A stack[-1] } 010A 80 DUP1 010B 63 PUSH4 0x0e89341c 0110 14 EQ 0111 61 PUSH2 0x0178 0114 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0178, if 0x0e89341c == stack[-1] label_0115: // Incoming jump from 0x0019, if msg.data.length < 0x04 // Incoming jump from 0x0114, if not 0x0e89341c == stack[-1] // Inputs[1] { @0119 memory[0x00:0x00] } 0115 5B JUMPDEST 0116 60 PUSH1 0x00 0118 80 DUP1 0119 FD *REVERT // Stack delta = +0 // Outputs[1] { @0119 revert(memory[0x00:0x00]); } // Block terminates label_011A: // Incoming jump from 0x00F3, if 0xfdd58e == stack[-1] // Inputs[1] { @0121 msg.data.length } 011A 5B JUMPDEST 011B 61 PUSH2 0x012d 011E 61 PUSH2 0x0128 0121 36 CALLDATASIZE 0122 60 PUSH1 0x04 0124 61 PUSH2 0x1536 0127 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @011B stack[0] = 0x012d // @011E stack[1] = 0x0128 // @0121 stack[2] = msg.data.length // @0122 stack[3] = 0x04 // } // Block ends with call to 0x1536, returns to 0x0128 label_0128: // Incoming return from call to 0x1536 at 0x0127 0128 5B JUMPDEST 0129 61 PUSH2 0x02b5 012C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x02b5 label_012D: // Incoming jump from 0x023F // Incoming return from call to 0x0128 at 0x0127 // Inputs[4] // { // @0130 memory[0x40:0x60] // @0131 stack[-1] // @013A memory[0x40:0x60] // @013F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 012D 5B JUMPDEST 012E 60 PUSH1 0x40 0130 51 MLOAD 0131 90 SWAP1 0132 81 DUP2 0133 52 MSTORE 0134 60 PUSH1 0x20 0136 01 ADD 0137 5B JUMPDEST 0138 60 PUSH1 0x40 013A 51 MLOAD 013B 80 DUP1 013C 91 SWAP2 013D 03 SUB 013E 90 SWAP1 013F F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0133 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @013F return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0140: // Incoming jump from 0x00FE, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @0147 msg.data.length } 0140 5B JUMPDEST 0141 61 PUSH2 0x0153 0144 61 PUSH2 0x014e 0147 36 CALLDATASIZE 0148 60 PUSH1 0x04 014A 61 PUSH2 0x165c 014D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0141 stack[0] = 0x0153 // @0144 stack[1] = 0x014e // @0147 stack[2] = msg.data.length // @0148 stack[3] = 0x04 // } // Block ends with call to 0x165c, returns to 0x014E label_014E: // Incoming return from call to 0x165C at 0x014D 014E 5B JUMPDEST 014F 61 PUSH2 0x034c 0152 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x034c label_0153: // Incoming return from call to 0x014E at 0x014D // Incoming return from call to 0x0261 at 0x0260 // Inputs[2] // { // @0156 memory[0x40:0x60] // @0157 stack[-1] // } 0153 5B JUMPDEST 0154 60 PUSH1 0x40 0156 51 MLOAD 0157 90 SWAP1 0158 15 ISZERO 0159 15 ISZERO 015A 81 DUP2 015B 52 MSTORE 015C 60 PUSH1 0x20 015E 01 ADD 015F 61 PUSH2 0x0137 0162 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @015B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @015E stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0137 label_0163: // Incoming jump from 0x0109, if 0x06fdde03 == stack[-1] 0163 5B JUMPDEST 0164 61 PUSH2 0x016b 0167 61 PUSH2 0x039e 016A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0164 stack[0] = 0x016b } // Block ends with call to 0x039e, returns to 0x016B label_016B: // Incoming return from call to 0x024E at 0x024D // Incoming return from call to 0x0186 at 0x0185 // Incoming return from call to 0x08D0 at 0x0223 // Incoming return from call to 0x039E at 0x016A // Inputs[2] // { // @016E memory[0x40:0x60] // @0172 stack[-1] // } 016B 5B JUMPDEST 016C 60 PUSH1 0x40 016E 51 MLOAD 016F 61 PUSH2 0x0137 0172 91 SWAP2 0173 90 SWAP1 0174 61 PUSH2 0x188b 0177 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0172 stack[-1] = 0x0137 // @0173 stack[1] = memory[0x40:0x60] // @0173 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x188b label_0178: // Incoming jump from 0x0114, if 0x0e89341c == stack[-1] // Inputs[1] { @017F msg.data.length } 0178 5B JUMPDEST 0179 61 PUSH2 0x016b 017C 61 PUSH2 0x0186 017F 36 CALLDATASIZE 0180 60 PUSH1 0x04 0182 61 PUSH2 0x16cf 0185 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0179 stack[0] = 0x016b // @017C stack[1] = 0x0186 // @017F stack[2] = msg.data.length // @0180 stack[3] = 0x04 // } // Block ends with call to 0x16cf, returns to 0x0186 label_0186: // Incoming return from call to 0x16CF at 0x0185 0186 5B JUMPDEST 0187 61 PUSH2 0x042c 018A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x042c label_018B: // Incoming jump from 0x00B8, if 0x1386a57e == stack[-1] // Inputs[1] { @0192 msg.data.length } 018B 5B JUMPDEST 018C 61 PUSH2 0x019e 018F 61 PUSH2 0x0199 0192 36 CALLDATASIZE 0193 60 PUSH1 0x04 0195 61 PUSH2 0x1694 0198 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @018C stack[0] = 0x019e // @018F stack[1] = 0x0199 // @0192 stack[2] = msg.data.length // @0193 stack[3] = 0x04 // } // Block ends with call to 0x1694, returns to 0x0199 label_0199: // Incoming return from call to 0x1694 at 0x0198 0199 5B JUMPDEST 019A 61 PUSH2 0x04ed 019D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04ed label_019E: // Incoming return from call to 0x089A at 0x0200 // Incoming return from call to 0x0232 at 0x0231 019E 5B JUMPDEST 019F 00 *STOP // Stack delta = +0 // Outputs[1] { @019F stop(); } // Block terminates label_01A0: // Incoming jump from 0x00C3, if 0x156e29f6 == stack[-1] // Inputs[1] { @01A7 msg.data.length } 01A0 5B JUMPDEST 01A1 61 PUSH2 0x019e 01A4 61 PUSH2 0x01ae 01A7 36 CALLDATASIZE 01A8 60 PUSH1 0x04 01AA 61 PUSH2 0x155f 01AD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01A1 stack[0] = 0x019e // @01A4 stack[1] = 0x01ae // @01A7 stack[2] = msg.data.length // @01A8 stack[3] = 0x04 // } // Block ends with call to 0x155f, returns to 0x01AE label_01AE: // Incoming return from call to 0x155F at 0x01AD 01AE 5B JUMPDEST 01AF 61 PUSH2 0x058f 01B2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x058f label_01B3: // Incoming jump from 0x00CE, if 0x162094c4 == stack[-1] // Inputs[1] { @01BA msg.data.length } 01B3 5B JUMPDEST 01B4 61 PUSH2 0x019e 01B7 61 PUSH2 0x01c1 01BA 36 CALLDATASIZE 01BB 60 PUSH1 0x04 01BD 61 PUSH2 0x16e7 01C0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01B4 stack[0] = 0x019e // @01B7 stack[1] = 0x01c1 // @01BA stack[2] = msg.data.length // @01BB stack[3] = 0x04 // } // Block ends with call to 0x16e7, returns to 0x01C1 label_01C1: // Incoming return from call to 0x16E7 at 0x01C0 01C1 5B JUMPDEST 01C2 61 PUSH2 0x05fa 01C5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05fa label_01C6: // Incoming jump from 0x00D9, if 0x2eb2c2d6 == stack[-1] // Inputs[1] { @01CD msg.data.length } 01C6 5B JUMPDEST 01C7 61 PUSH2 0x019e 01CA 61 PUSH2 0x01d4 01CD 36 CALLDATASIZE 01CE 60 PUSH1 0x04 01D0 61 PUSH2 0x13f3 01D3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01C7 stack[0] = 0x019e // @01CA stack[1] = 0x01d4 // @01CD stack[2] = msg.data.length // @01CE stack[3] = 0x04 // } // Block ends with unconditional jump to 0x13f3 01D4 5B JUMPDEST 01D5 61 PUSH2 0x06a1 01D8 56 *JUMP label_01D9: // Incoming jump from 0x00E4, if 0x4e1273f4 == stack[-1] // Inputs[1] { @01E0 msg.data.length } 01D9 5B JUMPDEST 01DA 61 PUSH2 0x01ec 01DD 61 PUSH2 0x01e7 01E0 36 CALLDATASIZE 01E1 60 PUSH1 0x04 01E3 61 PUSH2 0x1591 01E6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @01DA stack[0] = 0x01ec // @01DD stack[1] = 0x01e7 // @01E0 stack[2] = msg.data.length // @01E1 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1591 01E7 5B JUMPDEST 01E8 61 PUSH2 0x0738 01EB 56 *JUMP 01EC 5B JUMPDEST 01ED 60 PUSH1 0x40 01EF 51 MLOAD 01F0 61 PUSH2 0x0137 01F3 91 SWAP2 01F4 90 SWAP1 01F5 61 PUSH2 0x184a 01F8 56 *JUMP label_01F9: // Incoming jump from 0x007C, if 0x715018a6 == stack[-1] 01F9 5B JUMPDEST 01FA 61 PUSH2 0x019e 01FD 61 PUSH2 0x089a 0200 56 *JUMP // Stack delta = +1 // Outputs[1] { @01FA stack[0] = 0x019e } // Block ends with call to 0x089a, returns to 0x019E label_0201: // Incoming jump from 0x0087, if 0x8da5cb5b == stack[-1] // Inputs[2] // { // @0204 storage[0x03] // @0207 memory[0x40:0x60] // } 0201 5B JUMPDEST 0202 60 PUSH1 0x03 0204 54 SLOAD 0205 60 PUSH1 0x40 0207 51 MLOAD 0208 60 PUSH1 0x01 020A 60 PUSH1 0x01 020C 60 PUSH1 0xa0 020E 1B SHL 020F 03 SUB 0210 90 SWAP1 0211 91 SWAP2 0212 16 AND 0213 81 DUP2 0214 52 MSTORE 0215 60 PUSH1 0x20 0217 01 ADD 0218 61 PUSH2 0x0137 021B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0214 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x03] & (0x01 << 0xa0) - 0x01 // @0217 stack[0] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0137 label_021C: // Incoming jump from 0x0092, if 0x95d89b41 == stack[-1] 021C 5B JUMPDEST 021D 61 PUSH2 0x016b 0220 61 PUSH2 0x08d0 0223 56 *JUMP // Stack delta = +1 // Outputs[1] { @021D stack[0] = 0x016b } // Block ends with call to 0x08d0, returns to 0x016B label_0224: // Incoming jump from 0x009D, if 0xa22cb465 == stack[-1] // Inputs[1] { @022B msg.data.length } 0224 5B JUMPDEST 0225 61 PUSH2 0x019e 0228 61 PUSH2 0x0232 022B 36 CALLDATASIZE 022C 60 PUSH1 0x04 022E 61 PUSH2 0x14fc 0231 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0225 stack[0] = 0x019e // @0228 stack[1] = 0x0232 // @022B stack[2] = msg.data.length // @022C stack[3] = 0x04 // } // Block ends with call to 0x14fc, returns to 0x0232 label_0232: // Incoming return from call to 0x14FC at 0x0231 0232 5B JUMPDEST 0233 61 PUSH2 0x08dd 0236 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08dd label_0237: // Incoming jump from 0x0040, if 0xbf70d34f == stack[-1] // Inputs[1] { @023D storage[0x04] } 0237 5B JUMPDEST 0238 61 PUSH2 0x012d 023B 60 PUSH1 0x04 023D 54 SLOAD 023E 81 DUP2 023F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0238 stack[0] = 0x012d // @023D stack[1] = storage[0x04] // } // Block ends with unconditional jump to 0x012d label_0240: // Incoming jump from 0x004B, if 0xc87b56dd == stack[-1] // Inputs[1] { @0247 msg.data.length } 0240 5B JUMPDEST 0241 61 PUSH2 0x016b 0244 61 PUSH2 0x024e 0247 36 CALLDATASIZE 0248 60 PUSH1 0x04 024A 61 PUSH2 0x16cf 024D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0241 stack[0] = 0x016b // @0244 stack[1] = 0x024e // @0247 stack[2] = msg.data.length // @0248 stack[3] = 0x04 // } // Block ends with call to 0x16cf, returns to 0x024E label_024E: // Incoming return from call to 0x16CF at 0x024D 024E 5B JUMPDEST 024F 61 PUSH2 0x08ec 0252 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x08ec label_0253: // Incoming jump from 0x0056, if 0xe985e9c5 == stack[-1] // Inputs[1] { @025A msg.data.length } 0253 5B JUMPDEST 0254 61 PUSH2 0x0153 0257 61 PUSH2 0x0261 025A 36 CALLDATASIZE 025B 60 PUSH1 0x04 025D 61 PUSH2 0x13c1 0260 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0254 stack[0] = 0x0153 // @0257 stack[1] = 0x0261 // @025A stack[2] = msg.data.length // @025B stack[3] = 0x04 // } // Block ends with call to 0x13c1, returns to 0x0261 label_0261: // Incoming call from 0x0920, returns to 0x0921 // Incoming return from call to 0x13C1 at 0x0260 // Inputs[6] // { // @026A stack[-2] // @027D memory[0x00:0x40] // @027E stack[-1] // @0288 memory[0x00:0x40] // @0289 storage[keccak256(memory[0x00:0x40])] // @028D stack[-3] // } 0261 5B JUMPDEST 0262 60 PUSH1 0x01 0264 60 PUSH1 0x01 0266 60 PUSH1 0xa0 0268 1B SHL 0269 03 SUB 026A 91 SWAP2 026B 82 DUP3 026C 16 AND 026D 60 PUSH1 0x00 026F 90 SWAP1 0270 81 DUP2 0271 52 MSTORE 0272 60 PUSH1 0x01 0274 60 PUSH1 0x20 0276 90 SWAP1 0277 81 DUP2 0278 52 MSTORE 0279 60 PUSH1 0x40 027B 80 DUP1 027C 83 DUP4 027D 20 SHA3 027E 93 SWAP4 027F 90 SWAP1 0280 94 SWAP5 0281 16 AND 0282 82 DUP3 0283 52 MSTORE 0284 91 SWAP2 0285 90 SWAP1 0286 91 SWAP2 0287 52 MSTORE 0288 20 SHA3 0289 54 SLOAD 028A 60 PUSH1 0xff 028C 16 AND 028D 90 SWAP1 028E 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0271 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0278 memory[0x20:0x40] = 0x01 // @0283 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0287 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @028D stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_028F: // Incoming jump from 0x0061, if 0xf242432a == stack[-1] // Inputs[1] { @0296 msg.data.length } 028F 5B JUMPDEST 0290 61 PUSH2 0x019e 0293 61 PUSH2 0x029d 0296 36 CALLDATASIZE 0297 60 PUSH1 0x04 0299 61 PUSH2 0x1499 029C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0290 stack[0] = 0x019e // @0293 stack[1] = 0x029d // @0296 stack[2] = msg.data.length // @0297 stack[3] = 0x04 // } // Block ends with call to 0x1499, returns to 0x029D label_029D: // Incoming return from call to 0x1499 at 0x029C 029D 5B JUMPDEST 029E 61 PUSH2 0x0905 02A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0905 label_02A2: // Incoming jump from 0x006C, if 0xf2fde38b == stack[-1] // Inputs[1] { @02A9 msg.data.length } 02A2 5B JUMPDEST 02A3 61 PUSH2 0x019e 02A6 61 PUSH2 0x02b0 02A9 36 CALLDATASIZE 02AA 60 PUSH1 0x04 02AC 61 PUSH2 0x13a0 02AF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A3 stack[0] = 0x019e // @02A6 stack[1] = 0x02b0 // @02A9 stack[2] = msg.data.length // @02AA stack[3] = 0x04 // } // Block ends with call to 0x13a0, returns to 0x02B0 label_02B0: // Incoming return from call to 0x13A0 at 0x02AF 02B0 5B JUMPDEST 02B1 61 PUSH2 0x098c 02B4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x098c label_02B5: // Incoming jump from 0x012C // Inputs[1] { @02C0 stack[-2] } 02B5 5B JUMPDEST 02B6 60 PUSH1 0x00 02B8 60 PUSH1 0x01 02BA 60 PUSH1 0x01 02BC 60 PUSH1 0xa0 02BE 1B SHL 02BF 03 SUB 02C0 83 DUP4 02C1 16 AND 02C2 61 PUSH2 0x0326 02C5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B6 stack[0] = 0x00 } // Block ends with conditional jump to 0x0326, if stack[-2] & (0x01 << 0xa0) - 0x01 label_02C6: // Incoming jump from 0x02C5, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @02C8 memory[0x40:0x60] } 02C6 60 PUSH1 0x40 02C8 51 MLOAD 02C9 62 PUSH3 0x461bcd 02CD 60 PUSH1 0xe5 02CF 1B SHL 02D0 81 DUP2 02D1 52 MSTORE 02D2 60 PUSH1 0x20 02D4 60 PUSH1 0x04 02D6 82 DUP3 02D7 01 ADD 02D8 52 MSTORE 02D9 60 PUSH1 0x2b 02DB 60 PUSH1 0x24 02DD 82 DUP3 02DE 01 ADD 02DF 52 MSTORE 02E0 7F PUSH32 0x455243313135353a2062616c616e636520717565727920666f7220746865207a 0301 60 PUSH1 0x44 0303 82 DUP3 0304 01 ADD 0305 52 MSTORE 0306 6A PUSH11 0x65726f2061646472657373 0312 60 PUSH1 0xa8 0314 1B SHL 0315 60 PUSH1 0x64 0317 82 DUP3 0318 01 ADD 0319 52 MSTORE 031A 60 PUSH1 0x84 031C 01 ADD // Stack delta = +1 // Outputs[6] // { // @02D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @02D8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @02DF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @0305 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2062616c616e636520717565727920666f7220746865207a // @0319 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x65726f2061646472657373 << 0xa8 // @031C stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_031D: // Incoming return from call to 0x199F at 0x09B5 // Incoming jump from 0x0A1A // Incoming return from call to 0x1910 at 0x0E82 // Incoming return from call to 0x199F at 0x05B8 // Incoming return from call to 0x189E at 0x113D // Incoming jump from 0x110D // Incoming jump from 0x0DEF // Incoming return from call to 0x18E6 at 0x044E // Incoming return from call to 0x1955 at 0x0ED3 // Incoming jump from 0x097E // Incoming jump from 0x031C // Incoming jump from 0x110D // Incoming return from call to 0x199F at 0x0623 // Incoming return from call to 0x18E6 at 0x05D9 // Incoming jump from 0x0A86 // Incoming return from call to 0x199F at 0x0516 // Incoming return from call to 0x199F at 0x08C3 // Incoming return from call to 0x18E6 at 0x0644 // Inputs[3] // { // @0320 memory[0x40:0x60] // @0322 stack[-1] // @0325 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 031D 5B JUMPDEST 031E 60 PUSH1 0x40 0320 51 MLOAD 0321 80 DUP1 0322 91 SWAP2 0323 03 SUB 0324 90 SWAP1 0325 FD *REVERT // Stack delta = -1 // Outputs[1] { @0325 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_0326: // Incoming jump from 0x02C5, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[6] // { // @032A stack[-2] // @0336 memory[0x00:0x40] // @033F stack[-3] // @0348 memory[0x00:0x40] // @0349 storage[keccak256(memory[0x00:0x40])] // @034A stack[-4] // } 0326 5B JUMPDEST 0327 50 POP 0328 60 PUSH1 0x00 032A 90 SWAP1 032B 81 DUP2 032C 52 MSTORE 032D 60 PUSH1 0x20 032F 81 DUP2 0330 81 DUP2 0331 52 MSTORE 0332 60 PUSH1 0x40 0334 80 DUP1 0335 83 DUP4 0336 20 SHA3 0337 60 PUSH1 0x01 0339 60 PUSH1 0x01 033B 60 PUSH1 0xa0 033D 1B SHL 033E 03 SUB 033F 94 SWAP5 0340 90 SWAP1 0341 94 SWAP5 0342 16 AND 0343 83 DUP4 0344 52 MSTORE 0345 92 SWAP3 0346 90 SWAP1 0347 52 MSTORE 0348 20 SHA3 0349 54 SLOAD 034A 90 SWAP1 034B 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @032C memory[0x00:0x20] = stack[-2] // @0331 memory[0x20:0x40] = 0x00 // @0344 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0347 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @034A stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_034C: // Incoming jump from 0x0152 // Inputs[1] { @0358 stack[-1] } 034C 5B JUMPDEST 034D 60 PUSH1 0x00 034F 60 PUSH1 0x01 0351 60 PUSH1 0x01 0353 60 PUSH1 0xe0 0355 1B SHL 0356 03 SUB 0357 19 NOT 0358 82 DUP3 0359 16 AND 035A 63 PUSH4 0x6cdb3d13 035F 60 PUSH1 0xe1 0361 1B SHL 0362 14 EQ 0363 80 DUP1 0364 61 PUSH2 0x037d 0367 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @034D stack[0] = 0x00 // @0362 stack[1] = 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x037d, if 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_0368: // Incoming jump from 0x0367, if not 0x6cdb3d13 << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0372 stack[-3] } 0368 50 POP 0369 60 PUSH1 0x01 036B 60 PUSH1 0x01 036D 60 PUSH1 0xe0 036F 1B SHL 0370 03 SUB 0371 19 NOT 0372 82 DUP3 0373 16 AND 0374 63 PUSH4 0x03a24d07 0379 60 PUSH1 0xe2 037B 1B SHL 037C 14 EQ 037D 5B JUMPDEST 037E 80 DUP1 037F 61 PUSH2 0x0398 0382 57 *JUMPI // Stack delta = +0 // Outputs[1] { @037C stack[-1] = 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0398, if 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_0383: // Incoming jump from 0x0382, if not 0x03a24d07 << 0xe2 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0382, if not stack[-1] // Inputs[2] // { // @0395 stack[-3] // @0399 stack[-4] // } 0383 50 POP 0384 63 PUSH4 0x01ffc9a7 0389 60 PUSH1 0xe0 038B 1B SHL 038C 60 PUSH1 0x01 038E 60 PUSH1 0x01 0390 60 PUSH1 0xe0 0392 1B SHL 0393 03 SUB 0394 19 NOT 0395 83 DUP4 0396 16 AND 0397 14 EQ 0398 5B JUMPDEST 0399 92 SWAP3 039A 91 SWAP2 039B 50 POP 039C 50 POP 039D 56 *JUMP // Stack delta = -3 // Outputs[1] { @0399 stack[-4] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to stack[-4] label_039E: // Incoming call from 0x016A, returns to 0x016B // Inputs[1] { @03A2 storage[0x05] } 039E 5B JUMPDEST 039F 60 PUSH1 0x05 03A1 80 DUP1 03A2 54 SLOAD 03A3 61 PUSH2 0x03ab 03A6 90 SWAP1 03A7 61 PUSH2 0x1a10 03AA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @039F stack[0] = 0x05 // @03A6 stack[1] = 0x03ab // @03A6 stack[2] = storage[0x05] // } // Block ends with call to 0x1a10, returns to 0x03AB label_03AB: // Incoming return from call to 0x1A10 at 0x08DC // Incoming return from call to 0x1A10 at 0x03AA // Incoming return from call to 0x1A10 at 0x0904 // Inputs[4] // { // @03AC stack[-1] // @03BB memory[0x40:0x60] // @03C3 stack[-2] // @03CE storage[stack[-2]] // } 03AB 5B JUMPDEST 03AC 80 DUP1 03AD 60 PUSH1 0x1f 03AF 01 ADD 03B0 60 PUSH1 0x20 03B2 80 DUP1 03B3 91 SWAP2 03B4 04 DIV 03B5 02 MUL 03B6 60 PUSH1 0x20 03B8 01 ADD 03B9 60 PUSH1 0x40 03BB 51 MLOAD 03BC 90 SWAP1 03BD 81 DUP2 03BE 01 ADD 03BF 60 PUSH1 0x40 03C1 52 MSTORE 03C2 80 DUP1 03C3 92 SWAP3 03C4 91 SWAP2 03C5 90 SWAP1 03C6 81 DUP2 03C7 81 DUP2 03C8 52 MSTORE 03C9 60 PUSH1 0x20 03CB 01 ADD 03CC 82 DUP3 03CD 80 DUP1 03CE 54 SLOAD 03CF 61 PUSH2 0x03d7 03D2 90 SWAP1 03D3 61 PUSH2 0x1a10 03D6 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @03C1 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @03C3 stack[-2] = memory[0x40:0x60] // @03C4 stack[-1] = stack[-2] // @03C5 stack[0] = stack[-1] // @03C8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @03CB stack[1] = 0x20 + memory[0x40:0x60] // @03CC stack[2] = stack[-2] // @03D2 stack[4] = storage[stack[-2]] // @03D2 stack[3] = 0x03d7 // } // Block ends with call to 0x1a10, returns to 0x03D7 label_03D7: // Incoming return from call to 0x1A10 at 0x03D6 // Inputs[1] { @03D8 stack[-1] } 03D7 5B JUMPDEST 03D8 80 DUP1 03D9 15 ISZERO 03DA 61 PUSH2 0x0424 03DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0424, if !stack[-1] label_03DE: // Incoming jump from 0x03DD, if not !stack[-1] // Inputs[1] { @03DE stack[-1] } 03DE 80 DUP1 03DF 60 PUSH1 0x1f 03E1 10 LT 03E2 61 PUSH2 0x03f9 03E5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f9, if 0x1f < stack[-1] label_03E6: // Incoming jump from 0x03E5, if not 0x1f < stack[-1] // Inputs[4] // { // @03EA stack[-2] // @03EB storage[stack[-2]] // @03EE stack[-3] // @03F0 stack[-1] // } 03E6 61 PUSH2 0x0100 03E9 80 DUP1 03EA 83 DUP4 03EB 54 SLOAD 03EC 04 DIV 03ED 02 MUL 03EE 83 DUP4 03EF 52 MSTORE 03F0 91 SWAP2 03F1 60 PUSH1 0x20 03F3 01 ADD 03F4 91 SWAP2 03F5 61 PUSH2 0x0424 03F8 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @03EF memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @03F4 stack[-1] = stack[-1] // @03F4 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0424 label_03F9: // Incoming jump from 0x03E5, if 0x1f < stack[-1] // Inputs[5] // { // @03FA stack[-3] // @03FB stack[-1] // @03FD stack[-2] // @0405 memory[0x00:0x20] // @0409 storage[keccak256(memory[0x00:0x20])] // } 03F9 5B JUMPDEST 03FA 82 DUP3 03FB 01 ADD 03FC 91 SWAP2 03FD 90 SWAP1 03FE 60 PUSH1 0x00 0400 52 MSTORE 0401 60 PUSH1 0x20 0403 60 PUSH1 0x00 0405 20 SHA3 0406 90 SWAP1 0407 5B JUMPDEST 0408 81 DUP2 0409 54 SLOAD 040A 81 DUP2 040B 52 MSTORE 040C 90 SWAP1 040D 60 PUSH1 0x01 040F 01 ADD 0410 90 SWAP1 0411 60 PUSH1 0x20 0413 01 ADD 0414 80 DUP1 0415 83 DUP4 0416 11 GT 0417 61 PUSH2 0x0407 041A 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @03FC stack[-3] = stack[-3] + stack[-1] // @0400 memory[0x00:0x20] = stack[-2] // @040B memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @0410 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @0413 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x0407, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_041B: // Incoming jump from 0x041A, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x041A, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @041B stack[-3] // @041C stack[-1] // } 041B 82 DUP3 041C 90 SWAP1 041D 03 SUB 041E 60 PUSH1 0x1f 0420 16 AND 0421 82 DUP3 0422 01 ADD 0423 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0423 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0423 stack[-1] = stack[-3] // } // Block continues label_0424: // Incoming jump from 0x03DD, if !stack[-1] // Incoming jump from 0x0423 // Incoming jump from 0x03F8 // Inputs[1] { @042A stack[-7] } 0424 5B JUMPDEST 0425 50 POP 0426 50 POP 0427 50 POP 0428 50 POP 0429 50 POP 042A 81 DUP2 042B 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_042C: // Incoming jump from 0x018A // Inputs[2] // { // @0431 storage[0x04] // @0432 stack[-1] // } 042C 5B JUMPDEST 042D 60 PUSH1 0x60 042F 60 PUSH1 0x04 0431 54 SLOAD 0432 82 DUP3 0433 10 LT 0434 61 PUSH2 0x044f 0437 57 *JUMPI // Stack delta = +1 // Outputs[1] { @042D stack[0] = 0x60 } // Block ends with conditional jump to 0x044f, if stack[-1] < storage[0x04] label_0438: // Incoming jump from 0x0437, if not stack[-1] < storage[0x04] // Inputs[1] { @043A memory[0x40:0x60] } 0438 60 PUSH1 0x40 043A 51 MLOAD 043B 62 PUSH3 0x461bcd 043F 60 PUSH1 0xe5 0441 1B SHL 0442 81 DUP2 0443 52 MSTORE 0444 60 PUSH1 0x04 0446 01 ADD 0447 61 PUSH2 0x031d 044A 90 SWAP1 044B 61 PUSH2 0x18e6 044E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0443 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @044A stack[0] = 0x031d // @044A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x18e6, returns to 0x031D label_044F: // Incoming jump from 0x0437, if stack[-1] < storage[0x04] // Inputs[3] // { // @0452 stack[-2] // @045D memory[0x00:0x40] // @045F storage[keccak256(memory[0x00:0x40])] // } 044F 5B JUMPDEST 0450 60 PUSH1 0x00 0452 82 DUP3 0453 81 DUP2 0454 52 MSTORE 0455 60 PUSH1 0x07 0457 60 PUSH1 0x20 0459 52 MSTORE 045A 60 PUSH1 0x40 045C 90 SWAP1 045D 20 SHA3 045E 80 DUP1 045F 54 SLOAD 0460 61 PUSH2 0x0468 0463 90 SWAP1 0464 61 PUSH2 0x1a10 0467 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @0454 memory[0x00:0x20] = stack[-2] // @0459 memory[0x20:0x40] = 0x07 // @045D stack[0] = keccak256(memory[0x00:0x40]) // @0463 stack[1] = 0x0468 // @0463 stack[2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x1a10, returns to 0x0468 label_0468: // Incoming return from call to 0x1A10 at 0x0467 // Inputs[4] // { // @0469 stack[-1] // @0478 memory[0x40:0x60] // @0480 stack[-2] // @048B storage[stack[-2]] // } 0468 5B JUMPDEST 0469 80 DUP1 046A 60 PUSH1 0x1f 046C 01 ADD 046D 60 PUSH1 0x20 046F 80 DUP1 0470 91 SWAP2 0471 04 DIV 0472 02 MUL 0473 60 PUSH1 0x20 0475 01 ADD 0476 60 PUSH1 0x40 0478 51 MLOAD 0479 90 SWAP1 047A 81 DUP2 047B 01 ADD 047C 60 PUSH1 0x40 047E 52 MSTORE 047F 80 DUP1 0480 92 SWAP3 0481 91 SWAP2 0482 90 SWAP1 0483 81 DUP2 0484 81 DUP2 0485 52 MSTORE 0486 60 PUSH1 0x20 0488 01 ADD 0489 82 DUP3 048A 80 DUP1 048B 54 SLOAD 048C 61 PUSH2 0x0494 048F 90 SWAP1 0490 61 PUSH2 0x1a10 0493 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @047E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0480 stack[-2] = memory[0x40:0x60] // @0481 stack[-1] = stack[-2] // @0482 stack[0] = stack[-1] // @0485 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0488 stack[1] = 0x20 + memory[0x40:0x60] // @0489 stack[2] = stack[-2] // @048F stack[4] = storage[stack[-2]] // @048F stack[3] = 0x0494 // } // Block ends with call to 0x1a10, returns to 0x0494 label_0494: // Incoming return from call to 0x1A10 at 0x0493 // Inputs[1] { @0495 stack[-1] } 0494 5B JUMPDEST 0495 80 DUP1 0496 15 ISZERO 0497 61 PUSH2 0x04e1 049A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e1, if !stack[-1] label_049B: // Incoming jump from 0x049A, if not !stack[-1] // Inputs[1] { @049B stack[-1] } 049B 80 DUP1 049C 60 PUSH1 0x1f 049E 10 LT 049F 61 PUSH2 0x04b6 04A2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b6, if 0x1f < stack[-1] label_04A3: // Incoming jump from 0x04A2, if not 0x1f < stack[-1] // Inputs[4] // { // @04A7 stack[-2] // @04A8 storage[stack[-2]] // @04AB stack[-3] // @04AD stack[-1] // } 04A3 61 PUSH2 0x0100 04A6 80 DUP1 04A7 83 DUP4 04A8 54 SLOAD 04A9 04 DIV 04AA 02 MUL 04AB 83 DUP4 04AC 52 MSTORE 04AD 91 SWAP2 04AE 60 PUSH1 0x20 04B0 01 ADD 04B1 91 SWAP2 04B2 61 PUSH2 0x04e1 04B5 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @04AC memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @04B1 stack[-1] = stack[-1] // @04B1 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x04e1 label_04B6: // Incoming jump from 0x04A2, if 0x1f < stack[-1] // Inputs[5] // { // @04B7 stack[-3] // @04B8 stack[-1] // @04BA stack[-2] // @04C2 memory[0x00:0x20] // @04C6 storage[keccak256(memory[0x00:0x20])] // } 04B6 5B JUMPDEST 04B7 82 DUP3 04B8 01 ADD 04B9 91 SWAP2 04BA 90 SWAP1 04BB 60 PUSH1 0x00 04BD 52 MSTORE 04BE 60 PUSH1 0x20 04C0 60 PUSH1 0x00 04C2 20 SHA3 04C3 90 SWAP1 04C4 5B JUMPDEST 04C5 81 DUP2 04C6 54 SLOAD 04C7 81 DUP2 04C8 52 MSTORE 04C9 90 SWAP1 04CA 60 PUSH1 0x01 04CC 01 ADD 04CD 90 SWAP1 04CE 60 PUSH1 0x20 04D0 01 ADD 04D1 80 DUP1 04D2 83 DUP4 04D3 11 GT 04D4 61 PUSH2 0x04c4 04D7 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @04B9 stack[-3] = stack[-3] + stack[-1] // @04BD memory[0x00:0x20] = stack[-2] // @04C8 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @04CD stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @04D0 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x04c4, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_04D8: // Incoming jump from 0x04D7, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x04D7, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @04D8 stack[-3] // @04D9 stack[-1] // } 04D8 82 DUP3 04D9 90 SWAP1 04DA 03 SUB 04DB 60 PUSH1 0x1f 04DD 16 AND 04DE 82 DUP3 04DF 01 ADD 04E0 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @04E0 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @04E0 stack[-1] = stack[-3] // } // Block continues label_04E1: // Incoming jump from 0x04E0 // Incoming jump from 0x049A, if !stack[-1] // Incoming jump from 0x04B5 // Inputs[4] // { // @04E7 stack[-6] // @04E7 stack[-7] // @04E9 stack[-9] // @04EA stack[-8] // } 04E1 5B JUMPDEST 04E2 50 POP 04E3 50 POP 04E4 50 POP 04E5 50 POP 04E6 50 POP 04E7 90 SWAP1 04E8 50 POP 04E9 91 SWAP2 04EA 90 SWAP1 04EB 50 POP 04EC 56 *JUMP // Stack delta = -8 // Outputs[1] { @04E9 stack[-9] = stack[-6] } // Block ends with unconditional jump to stack[-9] label_04ED: // Incoming jump from 0x019D // Inputs[2] // { // @04F0 storage[0x03] // @04FA msg.sender // } 04ED 5B JUMPDEST 04EE 60 PUSH1 0x03 04F0 54 SLOAD 04F1 60 PUSH1 0x01 04F3 60 PUSH1 0x01 04F5 60 PUSH1 0xa0 04F7 1B SHL 04F8 03 SUB 04F9 16 AND 04FA 33 CALLER 04FB 14 EQ 04FC 61 PUSH2 0x0517 04FF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0517, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_0500: // Incoming jump from 0x04FF, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @0502 memory[0x40:0x60] } 0500 60 PUSH1 0x40 0502 51 MLOAD 0503 62 PUSH3 0x461bcd 0507 60 PUSH1 0xe5 0509 1B SHL 050A 81 DUP2 050B 52 MSTORE 050C 60 PUSH1 0x04 050E 01 ADD 050F 61 PUSH2 0x031d 0512 90 SWAP1 0513 61 PUSH2 0x199f 0516 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @050B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0512 stack[0] = 0x031d // @0512 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x199f, returns to 0x031D label_0517: // Incoming jump from 0x04FF, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[4] // { // @051A storage[0x04] // @052B memory[0x00:0x40] // @052C stack[-1] // @052D memory[stack[-1]:stack[-1] + 0x20] // } 0517 5B JUMPDEST 0518 60 PUSH1 0x04 051A 54 SLOAD 051B 60 PUSH1 0x00 051D 90 SWAP1 051E 81 DUP2 051F 52 MSTORE 0520 60 PUSH1 0x07 0522 60 PUSH1 0x20 0524 90 SWAP1 0525 81 DUP2 0526 52 MSTORE 0527 60 PUSH1 0x40 0529 90 SWAP1 052A 91 SWAP2 052B 20 SHA3 052C 82 DUP3 052D 51 MLOAD 052E 61 PUSH2 0x0539 0531 92 SWAP3 0532 84 DUP5 0533 01 ADD 0534 90 SWAP1 0535 61 PUSH2 0x1208 0538 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @051F memory[0x00:0x20] = storage[0x04] // @0526 memory[0x20:0x40] = 0x07 // @052B stack[1] = keccak256(memory[0x00:0x40]) // @0531 stack[0] = 0x0539 // @0534 stack[2] = stack[-1] + 0x20 // @0534 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1208 0539 5B JUMPDEST 053A 50 POP 053B 60 PUSH1 0x04 053D 54 SLOAD 053E 7F PUSH32 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b 055F 82 DUP3 0560 60 PUSH1 0x40 0562 51 MLOAD 0563 61 PUSH2 0x056c 0566 91 SWAP2 0567 90 SWAP1 0568 61 PUSH2 0x188b 056B 56 *JUMP 056C 5B JUMPDEST 056D 60 PUSH1 0x40 056F 51 MLOAD 0570 80 DUP1 0571 91 SWAP2 0572 03 SUB 0573 90 SWAP1 0574 A2 LOG2 0575 60 PUSH1 0x01 0577 60 PUSH1 0x04 0579 60 PUSH1 0x00 057B 82 DUP3 057C 82 DUP3 057D 54 SLOAD 057E 61 PUSH2 0x0587 0581 91 SWAP2 0582 90 SWAP1 0583 61 PUSH2 0x19f8 0586 56 *JUMP 0587 5B JUMPDEST 0588 90 SWAP1 0589 91 SWAP2 058A 55 SSTORE 058B 50 POP 058C 50 POP 058D 50 POP 058E 56 *JUMP label_058F: // Incoming jump from 0x01B2 // Inputs[2] // { // @0592 storage[0x03] // @059C msg.sender // } 058F 5B JUMPDEST 0590 60 PUSH1 0x03 0592 54 SLOAD 0593 60 PUSH1 0x01 0595 60 PUSH1 0x01 0597 60 PUSH1 0xa0 0599 1B SHL 059A 03 SUB 059B 16 AND 059C 33 CALLER 059D 14 EQ 059E 61 PUSH2 0x05b9 05A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_05A2: // Incoming jump from 0x05A1, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @05A4 memory[0x40:0x60] } 05A2 60 PUSH1 0x40 05A4 51 MLOAD 05A5 62 PUSH3 0x461bcd 05A9 60 PUSH1 0xe5 05AB 1B SHL 05AC 81 DUP2 05AD 52 MSTORE 05AE 60 PUSH1 0x04 05B0 01 ADD 05B1 61 PUSH2 0x031d 05B4 90 SWAP1 05B5 61 PUSH2 0x199f 05B8 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05AD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05B4 stack[0] = 0x031d // @05B4 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x199f, returns to 0x031D label_05B9: // Incoming jump from 0x05A1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[2] // { // @05BC storage[0x04] // @05BD stack[-2] // } 05B9 5B JUMPDEST 05BA 60 PUSH1 0x04 05BC 54 SLOAD 05BD 82 DUP3 05BE 10 LT 05BF 61 PUSH2 0x05da 05C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05da, if stack[-2] < storage[0x04] label_05C3: // Incoming jump from 0x05C2, if not stack[-2] < storage[0x04] // Inputs[1] { @05C5 memory[0x40:0x60] } 05C3 60 PUSH1 0x40 05C5 51 MLOAD 05C6 62 PUSH3 0x461bcd 05CA 60 PUSH1 0xe5 05CC 1B SHL 05CD 81 DUP2 05CE 52 MSTORE 05CF 60 PUSH1 0x04 05D1 01 ADD 05D2 61 PUSH2 0x031d 05D5 90 SWAP1 05D6 61 PUSH2 0x18e6 05D9 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @05CE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @05D5 stack[0] = 0x031d // @05D5 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x18e6, returns to 0x031D label_05DA: // Incoming jump from 0x05C2, if stack[-2] < storage[0x04] // Inputs[4] // { // @05DE stack[-3] // @05DF stack[-2] // @05E0 stack[-1] // @05E3 memory[0x40:0x60] // } 05DA 5B JUMPDEST 05DB 61 PUSH2 0x05f5 05DE 83 DUP4 05DF 83 DUP4 05E0 83 DUP4 05E1 60 PUSH1 0x40 05E3 51 MLOAD 05E4 80 DUP1 05E5 60 PUSH1 0x20 05E7 01 ADD 05E8 60 PUSH1 0x40 05EA 52 MSTORE 05EB 80 DUP1 05EC 60 PUSH1 0x00 05EE 81 DUP2 05EF 52 MSTORE 05F0 50 POP 05F1 61 PUSH2 0x0a27 05F4 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @05DB stack[0] = 0x05f5 // @05DE stack[1] = stack[-3] // @05DF stack[2] = stack[-2] // @05E0 stack[3] = stack[-1] // @05E3 stack[4] = memory[0x40:0x60] // @05EA memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @05EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0a27 05F5 5B JUMPDEST 05F6 50 POP 05F7 50 POP 05F8 50 POP 05F9 56 *JUMP label_05FA: // Incoming jump from 0x01C5 // Inputs[2] // { // @05FD storage[0x03] // @0607 msg.sender // } 05FA 5B JUMPDEST 05FB 60 PUSH1 0x03 05FD 54 SLOAD 05FE 60 PUSH1 0x01 0600 60 PUSH1 0x01 0602 60 PUSH1 0xa0 0604 1B SHL 0605 03 SUB 0606 16 AND 0607 33 CALLER 0608 14 EQ 0609 61 PUSH2 0x0624 060C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0624, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_060D: // Incoming jump from 0x060C, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @060F memory[0x40:0x60] } 060D 60 PUSH1 0x40 060F 51 MLOAD 0610 62 PUSH3 0x461bcd 0614 60 PUSH1 0xe5 0616 1B SHL 0617 81 DUP2 0618 52 MSTORE 0619 60 PUSH1 0x04 061B 01 ADD 061C 61 PUSH2 0x031d 061F 90 SWAP1 0620 61 PUSH2 0x199f 0623 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0618 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @061F stack[0] = 0x031d // @061F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x199f, returns to 0x031D label_0624: // Incoming jump from 0x060C, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[2] // { // @0627 storage[0x04] // @0628 stack[-2] // } 0624 5B JUMPDEST 0625 60 PUSH1 0x04 0627 54 SLOAD 0628 82 DUP3 0629 10 LT 062A 61 PUSH2 0x0645 062D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0645, if stack[-2] < storage[0x04] label_062E: // Incoming jump from 0x062D, if not stack[-2] < storage[0x04] // Inputs[1] { @0630 memory[0x40:0x60] } 062E 60 PUSH1 0x40 0630 51 MLOAD 0631 62 PUSH3 0x461bcd 0635 60 PUSH1 0xe5 0637 1B SHL 0638 81 DUP2 0639 52 MSTORE 063A 60 PUSH1 0x04 063C 01 ADD 063D 61 PUSH2 0x031d 0640 90 SWAP1 0641 61 PUSH2 0x18e6 0644 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0639 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0640 stack[0] = 0x031d // @0640 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x18e6, returns to 0x031D label_0645: // Incoming jump from 0x062D, if stack[-2] < storage[0x04] // Inputs[4] // { // @0648 stack[-2] // @0656 memory[0x00:0x40] // @0657 stack[-1] // @0658 memory[stack[-1]:stack[-1] + 0x20] // } 0645 5B JUMPDEST 0646 60 PUSH1 0x00 0648 82 DUP3 0649 81 DUP2 064A 52 MSTORE 064B 60 PUSH1 0x07 064D 60 PUSH1 0x20 064F 90 SWAP1 0650 81 DUP2 0651 52 MSTORE 0652 60 PUSH1 0x40 0654 90 SWAP1 0655 91 SWAP2 0656 20 SHA3 0657 82 DUP3 0658 51 MLOAD 0659 61 PUSH2 0x0664 065C 92 SWAP3 065D 84 DUP5 065E 01 ADD 065F 90 SWAP1 0660 61 PUSH2 0x1208 0663 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @064A memory[0x00:0x20] = stack[-2] // @0651 memory[0x20:0x40] = 0x07 // @0656 stack[1] = keccak256(memory[0x00:0x40]) // @065C stack[0] = 0x0664 // @065F stack[2] = stack[-1] + 0x20 // @065F stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x1208 0664 5B JUMPDEST 0665 50 POP 0666 81 DUP2 0667 7F PUSH32 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b 0688 82 DUP3 0689 60 PUSH1 0x40 068B 51 MLOAD 068C 61 PUSH2 0x0695 068F 91 SWAP2 0690 90 SWAP1 0691 61 PUSH2 0x188b 0694 56 *JUMP 0695 5B JUMPDEST 0696 60 PUSH1 0x40 0698 51 MLOAD 0699 80 DUP1 069A 91 SWAP2 069B 03 SUB 069C 90 SWAP1 069D A2 LOG2 069E 50 POP 069F 50 POP 06A0 56 *JUMP 06A1 5B JUMPDEST 06A2 60 PUSH1 0x01 06A4 60 PUSH1 0x01 06A6 60 PUSH1 0xa0 06A8 1B SHL 06A9 03 SUB 06AA 85 DUP6 06AB 16 AND 06AC 33 CALLER 06AD 14 EQ 06AE 80 DUP1 06AF 61 PUSH2 0x06bd 06B2 57 *JUMPI 06B3 50 POP 06B4 61 PUSH2 0x06bd 06B7 85 DUP6 06B8 33 CALLER 06B9 61 PUSH2 0x0261 06BC 56 *JUMP 06BD 5B JUMPDEST 06BE 61 PUSH2 0x0724 06C1 57 *JUMPI 06C2 60 PUSH1 0x40 06C4 51 MLOAD 06C5 62 PUSH3 0x461bcd 06C9 60 PUSH1 0xe5 06CB 1B SHL 06CC 81 DUP2 06CD 52 MSTORE 06CE 60 PUSH1 0x20 06D0 60 PUSH1 0x04 06D2 82 DUP3 06D3 01 ADD 06D4 52 MSTORE 06D5 60 PUSH1 0x32 06D7 60 PUSH1 0x24 06D9 82 DUP3 06DA 01 ADD 06DB 52 MSTORE 06DC 7F PUSH32 0x455243313135353a207472616e736665722063616c6c6572206973206e6f7420 06FD 60 PUSH1 0x44 06FF 82 DUP3 0700 01 ADD 0701 52 MSTORE 0702 71 PUSH18 0x1bdddb995c881b9bdc88185c1c1c9bdd9959 0715 60 PUSH1 0x72 0717 1B SHL 0718 60 PUSH1 0x64 071A 82 DUP3 071B 01 ADD 071C 52 MSTORE 071D 60 PUSH1 0x84 071F 01 ADD 0720 61 PUSH2 0x031d 0723 56 *JUMP 0724 5B JUMPDEST 0725 61 PUSH2 0x0731 0728 85 DUP6 0729 85 DUP6 072A 85 DUP6 072B 85 DUP6 072C 85 DUP6 072D 61 PUSH2 0x0b31 0730 56 *JUMP label_0731: // Incoming return from call to 0x0FD3 at 0x0B30 // Incoming return from call to 0x0F7A at 0x0AA0 // Incoming return from call to 0x0E5D at 0x098B // Inputs[1] { @0737 stack[-6] } 0731 5B JUMPDEST 0732 50 POP 0733 50 POP 0734 50 POP 0735 50 POP 0736 50 POP 0737 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] 0738 5B JUMPDEST 0739 60 PUSH1 0x60 073B 81 DUP2 073C 51 MLOAD 073D 83 DUP4 073E 51 MLOAD 073F 14 EQ 0740 61 PUSH2 0x079d 0743 57 *JUMPI 0744 60 PUSH1 0x40 0746 51 MLOAD 0747 62 PUSH3 0x461bcd 074B 60 PUSH1 0xe5 074D 1B SHL 074E 81 DUP2 074F 52 MSTORE 0750 60 PUSH1 0x20 0752 60 PUSH1 0x04 0754 82 DUP3 0755 01 ADD 0756 52 MSTORE 0757 60 PUSH1 0x29 0759 60 PUSH1 0x24 075B 82 DUP3 075C 01 ADD 075D 52 MSTORE 075E 7F PUSH32 0x455243313135353a206163636f756e747320616e6420696473206c656e677468 077F 60 PUSH1 0x44 0781 82 DUP3 0782 01 ADD 0783 52 MSTORE 0784 68 PUSH9 0x040dad2e6dac2e8c6d 078E 60 PUSH1 0xbb 0790 1B SHL 0791 60 PUSH1 0x64 0793 82 DUP3 0794 01 ADD 0795 52 MSTORE 0796 60 PUSH1 0x84 0798 01 ADD 0799 61 PUSH2 0x031d 079C 56 *JUMP 079D 5B JUMPDEST 079E 60 PUSH1 0x00 07A0 83 DUP4 07A1 51 MLOAD 07A2 67 PUSH8 0xffffffffffffffff 07AB 81 DUP2 07AC 11 GT 07AD 15 ISZERO 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 0x41 07BF 60 PUSH1 0x04 07C1 52 MSTORE 07C2 60 PUSH1 0x24 07C4 60 PUSH1 0x00 07C6 FD *REVERT 07C7 5B JUMPDEST 07C8 60 PUSH1 0x40 07CA 51 MLOAD 07CB 90 SWAP1 07CC 80 DUP1 07CD 82 DUP3 07CE 52 MSTORE 07CF 80 DUP1 07D0 60 PUSH1 0x20 07D2 02 MUL 07D3 60 PUSH1 0x20 07D5 01 ADD 07D6 82 DUP3 07D7 01 ADD 07D8 60 PUSH1 0x40 07DA 52 MSTORE 07DB 80 DUP1 07DC 15 ISZERO 07DD 61 PUSH2 0x07f0 07E0 57 *JUMPI 07E1 81 DUP2 07E2 60 PUSH1 0x20 07E4 01 ADD 07E5 60 PUSH1 0x20 07E7 82 DUP3 07E8 02 MUL 07E9 80 DUP1 07EA 36 CALLDATASIZE 07EB 83 DUP4 07EC 37 CALLDATACOPY 07ED 01 ADD 07EE 90 SWAP1 07EF 50 POP 07F0 5B JUMPDEST 07F1 50 POP 07F2 90 SWAP1 07F3 50 POP 07F4 60 PUSH1 0x00 07F6 5B JUMPDEST 07F7 84 DUP5 07F8 51 MLOAD 07F9 81 DUP2 07FA 10 LT 07FB 15 ISZERO 07FC 61 PUSH2 0x0892 07FF 57 *JUMPI 0800 61 PUSH2 0x0857 0803 85 DUP6 0804 82 DUP3 0805 81 DUP2 0806 51 MLOAD 0807 81 DUP2 0808 10 LT 0809 61 PUSH2 0x0822 080C 57 *JUMPI 080D 63 PUSH4 0x4e487b71 0812 60 PUSH1 0xe0 0814 1B SHL 0815 60 PUSH1 0x00 0817 52 MSTORE 0818 60 PUSH1 0x32 081A 60 PUSH1 0x04 081C 52 MSTORE 081D 60 PUSH1 0x24 081F 60 PUSH1 0x00 0821 FD *REVERT 0822 5B JUMPDEST 0823 60 PUSH1 0x20 0825 02 MUL 0826 60 PUSH1 0x20 0828 01 ADD 0829 01 ADD 082A 51 MLOAD 082B 85 DUP6 082C 83 DUP4 082D 81 DUP2 082E 51 MLOAD 082F 81 DUP2 0830 10 LT 0831 61 PUSH2 0x084a 0834 57 *JUMPI 0835 63 PUSH4 0x4e487b71 083A 60 PUSH1 0xe0 083C 1B SHL 083D 60 PUSH1 0x00 083F 52 MSTORE 0840 60 PUSH1 0x32 0842 60 PUSH1 0x04 0844 52 MSTORE 0845 60 PUSH1 0x24 0847 60 PUSH1 0x00 0849 FD *REVERT 084A 5B JUMPDEST 084B 60 PUSH1 0x20 084D 02 MUL 084E 60 PUSH1 0x20 0850 01 ADD 0851 01 ADD 0852 51 MLOAD 0853 61 PUSH2 0x02b5 0856 56 *JUMP 0857 5B JUMPDEST 0858 82 DUP3 0859 82 DUP3 085A 81 DUP2 085B 51 MLOAD 085C 81 DUP2 085D 10 LT 085E 61 PUSH2 0x0877 0861 57 *JUMPI 0862 63 PUSH4 0x4e487b71 0867 60 PUSH1 0xe0 0869 1B SHL 086A 60 PUSH1 0x00 086C 52 MSTORE 086D 60 PUSH1 0x32 086F 60 PUSH1 0x04 0871 52 MSTORE 0872 60 PUSH1 0x24 0874 60 PUSH1 0x00 0876 FD *REVERT 0877 5B JUMPDEST 0878 60 PUSH1 0x20 087A 90 SWAP1 087B 81 DUP2 087C 02 MUL 087D 91 SWAP2 087E 90 SWAP1 087F 91 SWAP2 0880 01 ADD 0881 01 ADD 0882 52 MSTORE 0883 61 PUSH2 0x088b 0886 81 DUP2 0887 61 PUSH2 0x1a78 088A 56 *JUMP 088B 5B JUMPDEST 088C 90 SWAP1 088D 50 POP 088E 61 PUSH2 0x07f6 0891 56 *JUMP 0892 5B JUMPDEST 0893 50 POP 0894 93 SWAP4 0895 92 SWAP3 0896 50 POP 0897 50 POP 0898 50 POP 0899 56 *JUMP label_089A: // Incoming call from 0x0200, returns to 0x019E // Inputs[2] // { // @089D storage[0x03] // @08A7 msg.sender // } 089A 5B JUMPDEST 089B 60 PUSH1 0x03 089D 54 SLOAD 089E 60 PUSH1 0x01 08A0 60 PUSH1 0x01 08A2 60 PUSH1 0xa0 08A4 1B SHL 08A5 03 SUB 08A6 16 AND 08A7 33 CALLER 08A8 14 EQ 08A9 61 PUSH2 0x08c4 08AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08c4, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_08AD: // Incoming jump from 0x08AC, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @08AF memory[0x40:0x60] } 08AD 60 PUSH1 0x40 08AF 51 MLOAD 08B0 62 PUSH3 0x461bcd 08B4 60 PUSH1 0xe5 08B6 1B SHL 08B7 81 DUP2 08B8 52 MSTORE 08B9 60 PUSH1 0x04 08BB 01 ADD 08BC 61 PUSH2 0x031d 08BF 90 SWAP1 08C0 61 PUSH2 0x199f 08C3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @08B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @08BF stack[0] = 0x031d // @08BF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x199f, returns to 0x031D label_08C4: // Incoming jump from 0x08AC, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] 08C4 5B JUMPDEST 08C5 61 PUSH2 0x08ce 08C8 60 PUSH1 0x00 08CA 61 PUSH2 0x0d2a 08CD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @08C5 stack[0] = 0x08ce // @08C8 stack[1] = 0x00 // } // Block ends with call to 0x0d2a, returns to 0x08CE label_08CE: // Incoming return from call to 0x0D2A at 0x08CD // Inputs[1] { @08CF stack[-1] } 08CE 5B JUMPDEST 08CF 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_08D0: // Incoming call from 0x0223, returns to 0x016B // Inputs[1] { @08D4 storage[0x06] } 08D0 5B JUMPDEST 08D1 60 PUSH1 0x06 08D3 80 DUP1 08D4 54 SLOAD 08D5 61 PUSH2 0x03ab 08D8 90 SWAP1 08D9 61 PUSH2 0x1a10 08DC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08D1 stack[0] = 0x06 // @08D8 stack[1] = 0x03ab // @08D8 stack[2] = storage[0x06] // } // Block ends with call to 0x1a10, returns to 0x03AB label_08DD: // Incoming jump from 0x0236 // Inputs[3] // { // @08E1 msg.sender // @08E2 stack[-2] // @08E3 stack[-1] // } 08DD 5B JUMPDEST 08DE 61 PUSH2 0x08e8 08E1 33 CALLER 08E2 83 DUP4 08E3 83 DUP4 08E4 61 PUSH2 0x0d7c 08E7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @08DE stack[0] = 0x08e8 // @08E1 stack[1] = msg.sender // @08E2 stack[2] = stack[-2] // @08E3 stack[3] = stack[-1] // } // Block ends with call to 0x0d7c, returns to 0x08E8 label_08E8: // Incoming return from call to 0x0D7C at 0x08E7 // Inputs[1] { @08EB stack[-3] } 08E8 5B JUMPDEST 08E9 50 POP 08EA 50 POP 08EB 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_08EC: // Incoming jump from 0x0252 // Inputs[3] // { // @08F4 stack[-1] // @08FA memory[0x00:0x40] // @08FC storage[keccak256(memory[0x00:0x40])] // } 08EC 5B JUMPDEST 08ED 60 PUSH1 0x07 08EF 60 PUSH1 0x20 08F1 52 MSTORE 08F2 60 PUSH1 0x00 08F4 90 SWAP1 08F5 81 DUP2 08F6 52 MSTORE 08F7 60 PUSH1 0x40 08F9 90 SWAP1 08FA 20 SHA3 08FB 80 DUP1 08FC 54 SLOAD 08FD 61 PUSH2 0x03ab 0900 90 SWAP1 0901 61 PUSH2 0x1a10 0904 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @08F1 memory[0x20:0x40] = 0x07 // @08F6 memory[0x00:0x20] = stack[-1] // @08FA stack[-1] = keccak256(memory[0x00:0x40]) // @0900 stack[1] = storage[keccak256(memory[0x00:0x40])] // @0900 stack[0] = 0x03ab // } // Block ends with call to 0x1a10, returns to 0x03AB label_0905: // Incoming jump from 0x02A1 // Inputs[2] // { // @090E stack[-5] // @0910 msg.sender // } 0905 5B JUMPDEST 0906 60 PUSH1 0x01 0908 60 PUSH1 0x01 090A 60 PUSH1 0xa0 090C 1B SHL 090D 03 SUB 090E 85 DUP6 090F 16 AND 0910 33 CALLER 0911 14 EQ 0912 80 DUP1 0913 61 PUSH2 0x0921 0916 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0911 stack[0] = msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 } // Block ends with conditional jump to 0x0921, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 label_0917: // Incoming jump from 0x0916, if not msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @091B stack[-6] // @091C msg.sender // } 0917 50 POP 0918 61 PUSH2 0x0921 091B 85 DUP6 091C 33 CALLER 091D 61 PUSH2 0x0261 0920 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0918 stack[-1] = 0x0921 // @091B stack[0] = stack[-6] // @091C stack[1] = msg.sender // } // Block ends with call to 0x0261, returns to 0x0921 label_0921: // Incoming jump from 0x0916, if msg.sender == stack[-5] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x0261 at 0x0920 // Inputs[1] { @0925 stack[-1] } 0921 5B JUMPDEST 0922 61 PUSH2 0x097f 0925 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x097f, if stack[-1] label_0926: // Incoming jump from 0x0925, if not stack[-1] // Inputs[1] { @0928 memory[0x40:0x60] } 0926 60 PUSH1 0x40 0928 51 MLOAD 0929 62 PUSH3 0x461bcd 092D 60 PUSH1 0xe5 092F 1B SHL 0930 81 DUP2 0931 52 MSTORE 0932 60 PUSH1 0x20 0934 60 PUSH1 0x04 0936 82 DUP3 0937 01 ADD 0938 52 MSTORE 0939 60 PUSH1 0x29 093B 60 PUSH1 0x24 093D 82 DUP3 093E 01 ADD 093F 52 MSTORE 0940 7F PUSH32 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 0961 60 PUSH1 0x44 0963 82 DUP3 0964 01 ADD 0965 52 MSTORE 0966 68 PUSH9 0x08185c1c1c9bdd9959 0970 60 PUSH1 0xba 0972 1B SHL 0973 60 PUSH1 0x64 0975 82 DUP3 0976 01 ADD 0977 52 MSTORE 0978 60 PUSH1 0x84 097A 01 ADD 097B 61 PUSH2 0x031d 097E 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0931 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0938 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @093F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0965 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2063616c6c6572206973206e6f74206f776e6572206e6f72 // @0977 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x08185c1c1c9bdd9959 << 0xba // @097A stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031d label_097F: // Incoming jump from 0x0925, if stack[-1] // Inputs[5] // { // @0983 stack[-5] // @0984 stack[-4] // @0985 stack[-3] // @0986 stack[-2] // @0987 stack[-1] // } 097F 5B JUMPDEST 0980 61 PUSH2 0x0731 0983 85 DUP6 0984 85 DUP6 0985 85 DUP6 0986 85 DUP6 0987 85 DUP6 0988 61 PUSH2 0x0e5d 098B 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0980 stack[0] = 0x0731 // @0983 stack[1] = stack[-5] // @0984 stack[2] = stack[-4] // @0985 stack[3] = stack[-3] // @0986 stack[4] = stack[-2] // @0987 stack[5] = stack[-1] // } // Block ends with call to 0x0e5d, returns to 0x0731 label_098C: // Incoming jump from 0x02B4 // Inputs[2] // { // @098F storage[0x03] // @0999 msg.sender // } 098C 5B JUMPDEST 098D 60 PUSH1 0x03 098F 54 SLOAD 0990 60 PUSH1 0x01 0992 60 PUSH1 0x01 0994 60 PUSH1 0xa0 0996 1B SHL 0997 03 SUB 0998 16 AND 0999 33 CALLER 099A 14 EQ 099B 61 PUSH2 0x09b6 099E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09b6, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] label_099F: // Incoming jump from 0x099E, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @09A1 memory[0x40:0x60] } 099F 60 PUSH1 0x40 09A1 51 MLOAD 09A2 62 PUSH3 0x461bcd 09A6 60 PUSH1 0xe5 09A8 1B SHL 09A9 81 DUP2 09AA 52 MSTORE 09AB 60 PUSH1 0x04 09AD 01 ADD 09AE 61 PUSH2 0x031d 09B1 90 SWAP1 09B2 61 PUSH2 0x199f 09B5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @09AA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09B1 stack[0] = 0x031d // @09B1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x199f, returns to 0x031D label_09B6: // Incoming jump from 0x099E, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x03] // Inputs[1] { @09BF stack[-1] } 09B6 5B JUMPDEST 09B7 60 PUSH1 0x01 09B9 60 PUSH1 0x01 09BB 60 PUSH1 0xa0 09BD 1B SHL 09BE 03 SUB 09BF 81 DUP2 09C0 16 AND 09C1 61 PUSH2 0x0a1b 09C4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a1b, if stack[-1] & (0x01 << 0xa0) - 0x01 label_09C5: // Incoming jump from 0x09C4, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @09C7 memory[0x40:0x60] } 09C5 60 PUSH1 0x40 09C7 51 MLOAD 09C8 62 PUSH3 0x461bcd 09CC 60 PUSH1 0xe5 09CE 1B SHL 09CF 81 DUP2 09D0 52 MSTORE 09D1 60 PUSH1 0x20 09D3 60 PUSH1 0x04 09D5 82 DUP3 09D6 01 ADD 09D7 52 MSTORE 09D8 60 PUSH1 0x26 09DA 60 PUSH1 0x24 09DC 82 DUP3 09DD 01 ADD 09DE 52 MSTORE 09DF 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 0A00 60 PUSH1 0x44 0A02 82 DUP3 0A03 01 ADD 0A04 52 MSTORE 0A05 65 PUSH6 0x646472657373 0A0C 60 PUSH1 0xd0 0A0E 1B SHL 0A0F 60 PUSH1 0x64 0A11 82 DUP3 0A12 01 ADD 0A13 52 MSTORE 0A14 60 PUSH1 0x84 0A16 01 ADD 0A17 61 PUSH2 0x031d 0A1A 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @09D0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @09D7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @09DE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @0A04 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @0A13 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @0A16 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031d label_0A1B: // Incoming jump from 0x09C4, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A1F stack[-1] } 0A1B 5B JUMPDEST 0A1C 61 PUSH2 0x0a24 0A1F 81 DUP2 0A20 61 PUSH2 0x0d2a 0A23 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A1C stack[0] = 0x0a24 // @0A1F stack[1] = stack[-1] // } // Block ends with call to 0x0d2a, returns to 0x0A24 label_0A24: // Incoming return from call to 0x0D2A at 0x0A23 // Incoming jump from 0x1B72, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0A26 stack[-2] } 0A24 5B JUMPDEST 0A25 50 POP 0A26 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0A27: // Incoming jump from 0x05F4 // Inputs[1] { @0A30 stack[-4] } 0A27 5B JUMPDEST 0A28 60 PUSH1 0x01 0A2A 60 PUSH1 0x01 0A2C 60 PUSH1 0xa0 0A2E 1B SHL 0A2F 03 SUB 0A30 84 DUP5 0A31 16 AND 0A32 61 PUSH2 0x0a87 0A35 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a87, if stack[-4] & (0x01 << 0xa0) - 0x01 label_0A36: // Incoming jump from 0x0A35, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0A38 memory[0x40:0x60] } 0A36 60 PUSH1 0x40 0A38 51 MLOAD 0A39 62 PUSH3 0x461bcd 0A3D 60 PUSH1 0xe5 0A3F 1B SHL 0A40 81 DUP2 0A41 52 MSTORE 0A42 60 PUSH1 0x20 0A44 60 PUSH1 0x04 0A46 82 DUP3 0A47 01 ADD 0A48 52 MSTORE 0A49 60 PUSH1 0x21 0A4B 60 PUSH1 0x24 0A4D 82 DUP3 0A4E 01 ADD 0A4F 52 MSTORE 0A50 7F PUSH32 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 0A71 60 PUSH1 0x44 0A73 82 DUP3 0A74 01 ADD 0A75 52 MSTORE 0A76 60 PUSH1 0x73 0A78 60 PUSH1 0xf8 0A7A 1B SHL 0A7B 60 PUSH1 0x64 0A7D 82 DUP3 0A7E 01 ADD 0A7F 52 MSTORE 0A80 60 PUSH1 0x84 0A82 01 ADD 0A83 61 PUSH2 0x031d 0A86 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0A41 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0A48 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0A4F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @0A75 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a206d696e7420746f20746865207a65726f20616464726573 // @0A7F memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x73 << 0xf8 // @0A82 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031d label_0A87: // Incoming jump from 0x0A35, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @0A88 msg.sender // @0A8F stack[-4] // @0A93 stack[-3] // } 0A87 5B JUMPDEST 0A88 33 CALLER 0A89 61 PUSH2 0x0aa1 0A8C 81 DUP2 0A8D 60 PUSH1 0x00 0A8F 87 DUP8 0A90 61 PUSH2 0x0a98 0A93 88 DUP9 0A94 61 PUSH2 0x0f7a 0A97 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0A88 stack[0] = msg.sender // @0A89 stack[1] = 0x0aa1 // @0A8C stack[2] = msg.sender // @0A8D stack[3] = 0x00 // @0A8F stack[4] = stack[-4] // @0A90 stack[5] = 0x0a98 // @0A93 stack[6] = stack[-3] // } // Block ends with call to 0x0f7a, returns to 0x0A98 label_0A98: // Incoming return from call to 0x0F7A at 0x0E92 // Incoming return from call to 0x0F7A at 0x0A97 // Inputs[1] { @0A9C stack[-8] } 0A98 5B JUMPDEST 0A99 61 PUSH2 0x0731 0A9C 88 DUP9 0A9D 61 PUSH2 0x0f7a 0AA0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A99 stack[0] = 0x0731 // @0A9C stack[1] = stack[-8] // } // Block ends with call to 0x0f7a, returns to 0x0731 label_0AA1: // Incoming return from call to 0x0A98 at 0x0A97 // Inputs[6] // { // @0AA4 stack[-4] // @0AB0 memory[0x00:0x40] // @0AB9 stack[-5] // @0AC1 memory[0x00:0x40] // @0AC3 storage[keccak256(memory[0x00:0x40])] // @0AC4 stack[-3] // } 0AA1 5B JUMPDEST 0AA2 60 PUSH1 0x00 0AA4 84 DUP5 0AA5 81 DUP2 0AA6 52 MSTORE 0AA7 60 PUSH1 0x20 0AA9 81 DUP2 0AAA 81 DUP2 0AAB 52 MSTORE 0AAC 60 PUSH1 0x40 0AAE 80 DUP1 0AAF 83 DUP4 0AB0 20 SHA3 0AB1 60 PUSH1 0x01 0AB3 60 PUSH1 0x01 0AB5 60 PUSH1 0xa0 0AB7 1B SHL 0AB8 03 SUB 0AB9 89 DUP10 0ABA 16 AND 0ABB 84 DUP5 0ABC 52 MSTORE 0ABD 90 SWAP1 0ABE 91 SWAP2 0ABF 52 MSTORE 0AC0 81 DUP2 0AC1 20 SHA3 0AC2 80 DUP1 0AC3 54 SLOAD 0AC4 85 DUP6 0AC5 92 SWAP3 0AC6 90 SWAP1 0AC7 61 PUSH2 0x0ad1 0ACA 90 SWAP1 0ACB 84 DUP5 0ACC 90 SWAP1 0ACD 61 PUSH2 0x19f8 0AD0 56 *JUMP // Stack delta = +6 // Outputs[10] // { // @0AA6 memory[0x00:0x20] = stack[-4] // @0AAB memory[0x20:0x40] = 0x00 // @0ABC memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @0ABF memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0AC1 stack[1] = keccak256(memory[0x00:0x40]) // @0AC5 stack[0] = stack[-3] // @0AC6 stack[2] = 0x00 // @0ACA stack[3] = 0x0ad1 // @0ACC stack[4] = stack[-3] // @0ACC stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x19f8, returns to 0x0AD1 label_0AD1: // Incoming return from call to 0x19F8 at 0x0AD0 // Inputs[11] // { // @0AD2 stack[-2] // @0AD2 stack[-1] // @0AD3 stack[-3] // @0ADA memory[0x40:0x60] // @0ADB stack[-8] // @0AE2 stack[-7] // @0AEE stack[-9] // @0AF5 stack[-5] // @0B1D memory[0x40:0x60] // @0B22 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0B2C stack[-6] // } 0AD1 5B JUMPDEST 0AD2 90 SWAP1 0AD3 91 SWAP2 0AD4 55 SSTORE 0AD5 50 POP 0AD6 50 POP 0AD7 60 PUSH1 0x40 0AD9 80 DUP1 0ADA 51 MLOAD 0ADB 85 DUP6 0ADC 81 DUP2 0ADD 52 MSTORE 0ADE 60 PUSH1 0x20 0AE0 81 DUP2 0AE1 01 ADD 0AE2 85 DUP6 0AE3 90 SWAP1 0AE4 52 MSTORE 0AE5 60 PUSH1 0x01 0AE7 60 PUSH1 0x01 0AE9 60 PUSH1 0xa0 0AEB 1B SHL 0AEC 03 SUB 0AED 80 DUP1 0AEE 88 DUP9 0AEF 16 AND 0AF0 92 SWAP3 0AF1 60 PUSH1 0x00 0AF3 92 SWAP3 0AF4 91 SWAP2 0AF5 85 DUP6 0AF6 16 AND 0AF7 91 SWAP2 0AF8 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 0B19 91 SWAP2 0B1A 01 ADD 0B1B 60 PUSH1 0x40 0B1D 51 MLOAD 0B1E 80 DUP1 0B1F 91 SWAP2 0B20 03 SUB 0B21 90 SWAP1 0B22 A4 LOG4 0B23 61 PUSH2 0x0731 0B26 81 DUP2 0B27 60 PUSH1 0x00 0B29 87 DUP8 0B2A 87 DUP8 0B2B 87 DUP8 0B2C 87 DUP8 0B2D 61 PUSH2 0x0fd3 0B30 56 *JUMP // Stack delta = +3 // Outputs[11] // { // @0AD4 storage[stack[-3]] = stack[-1] // @0ADD memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-8] // @0AE4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-7] // @0B22 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]); // @0B23 stack[-4] = 0x0731 // @0B26 stack[-3] = stack[-5] // @0B27 stack[-2] = 0x00 // @0B29 stack[-1] = stack[-9] // @0B2A stack[0] = stack[-8] // @0B2B stack[1] = stack[-7] // @0B2C stack[2] = stack[-6] // } // Block ends with call to 0x0fd3, returns to 0x0731 0B31 5B JUMPDEST 0B32 81 DUP2 0B33 51 MLOAD 0B34 83 DUP4 0B35 51 MLOAD 0B36 14 EQ 0B37 61 PUSH2 0x0b93 0B3A 57 *JUMPI 0B3B 60 PUSH1 0x40 0B3D 51 MLOAD 0B3E 62 PUSH3 0x461bcd 0B42 60 PUSH1 0xe5 0B44 1B SHL 0B45 81 DUP2 0B46 52 MSTORE 0B47 60 PUSH1 0x20 0B49 60 PUSH1 0x04 0B4B 82 DUP3 0B4C 01 ADD 0B4D 52 MSTORE 0B4E 60 PUSH1 0x28 0B50 60 PUSH1 0x24 0B52 82 DUP3 0B53 01 ADD 0B54 52 MSTORE 0B55 7F PUSH32 0x455243313135353a2069647320616e6420616d6f756e7473206c656e67746820 0B76 60 PUSH1 0x44 0B78 82 DUP3 0B79 01 ADD 0B7A 52 MSTORE 0B7B 67 PUSH8 0x0dad2e6dac2e8c6d 0B84 60 PUSH1 0xc3 0B86 1B SHL 0B87 60 PUSH1 0x64 0B89 82 DUP3 0B8A 01 ADD 0B8B 52 MSTORE 0B8C 60 PUSH1 0x84 0B8E 01 ADD 0B8F 61 PUSH2 0x031d 0B92 56 *JUMP 0B93 5B JUMPDEST 0B94 60 PUSH1 0x01 0B96 60 PUSH1 0x01 0B98 60 PUSH1 0xa0 0B9A 1B SHL 0B9B 03 SUB 0B9C 84 DUP5 0B9D 16 AND 0B9E 61 PUSH2 0x0bb9 0BA1 57 *JUMPI 0BA2 60 PUSH1 0x40 0BA4 51 MLOAD 0BA5 62 PUSH3 0x461bcd 0BA9 60 PUSH1 0xe5 0BAB 1B SHL 0BAC 81 DUP2 0BAD 52 MSTORE 0BAE 60 PUSH1 0x04 0BB0 01 ADD 0BB1 61 PUSH2 0x031d 0BB4 90 SWAP1 0BB5 61 PUSH2 0x1910 0BB8 56 *JUMP 0BB9 5B JUMPDEST 0BBA 33 CALLER 0BBB 60 PUSH1 0x00 0BBD 5B JUMPDEST 0BBE 84 DUP5 0BBF 51 MLOAD 0BC0 81 DUP2 0BC1 10 LT 0BC2 15 ISZERO 0BC3 61 PUSH2 0x0cbc 0BC6 57 *JUMPI 0BC7 60 PUSH1 0x00 0BC9 85 DUP6 0BCA 82 DUP3 0BCB 81 DUP2 0BCC 51 MLOAD 0BCD 81 DUP2 0BCE 10 LT 0BCF 61 PUSH2 0x0be8 0BD2 57 *JUMPI 0BD3 63 PUSH4 0x4e487b71 0BD8 60 PUSH1 0xe0 0BDA 1B SHL 0BDB 60 PUSH1 0x00 0BDD 52 MSTORE 0BDE 60 PUSH1 0x32 0BE0 60 PUSH1 0x04 0BE2 52 MSTORE 0BE3 60 PUSH1 0x24 0BE5 60 PUSH1 0x00 0BE7 FD *REVERT 0BE8 5B JUMPDEST 0BE9 60 PUSH1 0x20 0BEB 02 MUL 0BEC 60 PUSH1 0x20 0BEE 01 ADD 0BEF 01 ADD 0BF0 51 MLOAD 0BF1 90 SWAP1 0BF2 50 POP 0BF3 60 PUSH1 0x00 0BF5 85 DUP6 0BF6 83 DUP4 0BF7 81 DUP2 0BF8 51 MLOAD 0BF9 81 DUP2 0BFA 10 LT 0BFB 61 PUSH2 0x0c14 0BFE 57 *JUMPI 0BFF 63 PUSH4 0x4e487b71 0C04 60 PUSH1 0xe0 0C06 1B SHL 0C07 60 PUSH1 0x00 0C09 52 MSTORE 0C0A 60 PUSH1 0x32 0C0C 60 PUSH1 0x04 0C0E 52 MSTORE 0C0F 60 PUSH1 0x24 0C11 60 PUSH1 0x00 0C13 FD *REVERT 0C14 5B JUMPDEST 0C15 60 PUSH1 0x20 0C17 90 SWAP1 0C18 81 DUP2 0C19 02 MUL 0C1A 91 SWAP2 0C1B 90 SWAP1 0C1C 91 SWAP2 0C1D 01 ADD 0C1E 81 DUP2 0C1F 01 ADD 0C20 51 MLOAD 0C21 60 PUSH1 0x00 0C23 84 DUP5 0C24 81 DUP2 0C25 52 MSTORE 0C26 80 DUP1 0C27 83 DUP4 0C28 52 MSTORE 0C29 60 PUSH1 0x40 0C2B 80 DUP1 0C2C 82 DUP3 0C2D 20 SHA3 0C2E 60 PUSH1 0x01 0C30 60 PUSH1 0x01 0C32 60 PUSH1 0xa0 0C34 1B SHL 0C35 03 SUB 0C36 8E DUP15 0C37 16 AND 0C38 83 DUP4 0C39 52 MSTORE 0C3A 90 SWAP1 0C3B 93 SWAP4 0C3C 52 MSTORE 0C3D 91 SWAP2 0C3E 90 SWAP1 0C3F 91 SWAP2 0C40 20 SHA3 0C41 54 SLOAD 0C42 90 SWAP1 0C43 91 SWAP2 0C44 50 POP 0C45 81 DUP2 0C46 81 DUP2 0C47 10 LT 0C48 15 ISZERO 0C49 61 PUSH2 0x0c64 0C4C 57 *JUMPI 0C4D 60 PUSH1 0x40 0C4F 51 MLOAD 0C50 62 PUSH3 0x461bcd 0C54 60 PUSH1 0xe5 0C56 1B SHL 0C57 81 DUP2 0C58 52 MSTORE 0C59 60 PUSH1 0x04 0C5B 01 ADD 0C5C 61 PUSH2 0x031d 0C5F 90 SWAP1 0C60 61 PUSH2 0x1955 0C63 56 *JUMP 0C64 5B JUMPDEST 0C65 60 PUSH1 0x00 0C67 83 DUP4 0C68 81 DUP2 0C69 52 MSTORE 0C6A 60 PUSH1 0x20 0C6C 81 DUP2 0C6D 81 DUP2 0C6E 52 MSTORE 0C6F 60 PUSH1 0x40 0C71 80 DUP1 0C72 83 DUP4 0C73 20 SHA3 0C74 60 PUSH1 0x01 0C76 60 PUSH1 0x01 0C78 60 PUSH1 0xa0 0C7A 1B SHL 0C7B 03 SUB 0C7C 8E DUP15 0C7D 81 DUP2 0C7E 16 AND 0C7F 85 DUP6 0C80 52 MSTORE 0C81 92 SWAP3 0C82 52 MSTORE 0C83 80 DUP1 0C84 83 DUP4 0C85 20 SHA3 0C86 85 DUP6 0C87 85 DUP6 0C88 03 SUB 0C89 90 SWAP1 0C8A 55 SSTORE 0C8B 90 SWAP1 0C8C 8B DUP12 0C8D 16 AND 0C8E 82 DUP3 0C8F 52 MSTORE 0C90 81 DUP2 0C91 20 SHA3 0C92 80 DUP1 0C93 54 SLOAD 0C94 84 DUP5 0C95 92 SWAP3 0C96 90 SWAP1 0C97 61 PUSH2 0x0ca1 0C9A 90 SWAP1 0C9B 84 DUP5 0C9C 90 SWAP1 0C9D 61 PUSH2 0x19f8 0CA0 56 *JUMP 0CA1 5B JUMPDEST 0CA2 92 SWAP3 0CA3 50 POP 0CA4 50 POP 0CA5 81 DUP2 0CA6 90 SWAP1 0CA7 55 SSTORE 0CA8 50 POP 0CA9 50 POP 0CAA 50 POP 0CAB 50 POP 0CAC 80 DUP1 0CAD 61 PUSH2 0x0cb5 0CB0 90 SWAP1 0CB1 61 PUSH2 0x1a78 0CB4 56 *JUMP 0CB5 5B JUMPDEST 0CB6 90 SWAP1 0CB7 50 POP 0CB8 61 PUSH2 0x0bbd 0CBB 56 *JUMP 0CBC 5B JUMPDEST 0CBD 50 POP 0CBE 84 DUP5 0CBF 60 PUSH1 0x01 0CC1 60 PUSH1 0x01 0CC3 60 PUSH1 0xa0 0CC5 1B SHL 0CC6 03 SUB 0CC7 16 AND 0CC8 86 DUP7 0CC9 60 PUSH1 0x01 0CCB 60 PUSH1 0x01 0CCD 60 PUSH1 0xa0 0CCF 1B SHL 0CD0 03 SUB 0CD1 16 AND 0CD2 82 DUP3 0CD3 60 PUSH1 0x01 0CD5 60 PUSH1 0x01 0CD7 60 PUSH1 0xa0 0CD9 1B SHL 0CDA 03 SUB 0CDB 16 AND 0CDC 7F PUSH32 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb 0CFD 87 DUP8 0CFE 87 DUP8 0CFF 60 PUSH1 0x40 0D01 51 MLOAD 0D02 61 PUSH2 0x0d0c 0D05 92 SWAP3 0D06 91 SWAP2 0D07 90 SWAP1 0D08 61 PUSH2 0x185d 0D0B 56 *JUMP 0D0C 5B JUMPDEST 0D0D 60 PUSH1 0x40 0D0F 51 MLOAD 0D10 80 DUP1 0D11 91 SWAP2 0D12 03 SUB 0D13 90 SWAP1 0D14 A4 LOG4 0D15 61 PUSH2 0x0d22 0D18 81 DUP2 0D19 87 DUP8 0D1A 87 DUP8 0D1B 87 DUP8 0D1C 87 DUP8 0D1D 87 DUP8 0D1E 61 PUSH2 0x113e 0D21 56 *JUMP label_0D22: // Incoming jump from 0x0FE3, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @0D29 stack[-7] } 0D22 5B JUMPDEST 0D23 50 POP 0D24 50 POP 0D25 50 POP 0D26 50 POP 0D27 50 POP 0D28 50 POP 0D29 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_0D2A: // Incoming call from 0x0A23, returns to 0x0A24 // Incoming call from 0x08CD, returns to 0x08CE // Inputs[5] // { // @0D2E storage[0x03] // @0D37 stack[-1] // @0D4C memory[0x40:0x60] // @0D78 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0D7B stack[-2] // } 0D2A 5B JUMPDEST 0D2B 60 PUSH1 0x03 0D2D 80 DUP1 0D2E 54 SLOAD 0D2F 60 PUSH1 0x01 0D31 60 PUSH1 0x01 0D33 60 PUSH1 0xa0 0D35 1B SHL 0D36 03 SUB 0D37 83 DUP4 0D38 81 DUP2 0D39 16 AND 0D3A 60 PUSH1 0x01 0D3C 60 PUSH1 0x01 0D3E 60 PUSH1 0xa0 0D40 1B SHL 0D41 03 SUB 0D42 19 NOT 0D43 83 DUP4 0D44 16 AND 0D45 81 DUP2 0D46 17 OR 0D47 90 SWAP1 0D48 93 SWAP4 0D49 55 SSTORE 0D4A 60 PUSH1 0x40 0D4C 51 MLOAD 0D4D 91 SWAP2 0D4E 16 AND 0D4F 91 SWAP2 0D50 90 SWAP1 0D51 82 DUP3 0D52 90 SWAP1 0D53 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 0D74 90 SWAP1 0D75 60 PUSH1 0x00 0D77 90 SWAP1 0D78 A3 LOG3 0D79 50 POP 0D7A 50 POP 0D7B 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @0D49 storage[0x03] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x03] & ~((0x01 << 0xa0) - 0x01)) // @0D78 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x03] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_0D7C: // Incoming call from 0x08E7, returns to 0x08E8 // Inputs[2] // { // @0D7D stack[-2] // @0D87 stack[-3] // } 0D7C 5B JUMPDEST 0D7D 81 DUP2 0D7E 60 PUSH1 0x01 0D80 60 PUSH1 0x01 0D82 60 PUSH1 0xa0 0D84 1B SHL 0D85 03 SUB 0D86 16 AND 0D87 83 DUP4 0D88 60 PUSH1 0x01 0D8A 60 PUSH1 0x01 0D8C 60 PUSH1 0xa0 0D8E 1B SHL 0D8F 03 SUB 0D90 16 AND 0D91 14 EQ 0D92 15 ISZERO 0D93 61 PUSH2 0x0df0 0D96 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0df0, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) label_0D97: // Incoming jump from 0x0D96, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[1] { @0D99 memory[0x40:0x60] } 0D97 60 PUSH1 0x40 0D99 51 MLOAD 0D9A 62 PUSH3 0x461bcd 0D9E 60 PUSH1 0xe5 0DA0 1B SHL 0DA1 81 DUP2 0DA2 52 MSTORE 0DA3 60 PUSH1 0x20 0DA5 60 PUSH1 0x04 0DA7 82 DUP3 0DA8 01 ADD 0DA9 52 MSTORE 0DAA 60 PUSH1 0x29 0DAC 60 PUSH1 0x24 0DAE 82 DUP3 0DAF 01 ADD 0DB0 52 MSTORE 0DB1 7F PUSH32 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 0DD2 60 PUSH1 0x44 0DD4 82 DUP3 0DD5 01 ADD 0DD6 52 MSTORE 0DD7 68 PUSH9 0x103337b91039b2b633 0DE1 60 PUSH1 0xb9 0DE3 1B SHL 0DE4 60 PUSH1 0x64 0DE6 82 DUP3 0DE7 01 ADD 0DE8 52 MSTORE 0DE9 60 PUSH1 0x84 0DEB 01 ADD 0DEC 61 PUSH2 0x031d 0DEF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0DA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DA9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0DB0 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0DD6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a2073657474696e6720617070726f76616c20737461747573 // @0DE8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x103337b91039b2b633 << 0xb9 // @0DEB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031d label_0DF0: // Incoming jump from 0x0D96, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2]) // Inputs[10] // { // @0DF9 stack[-3] // @0E0C memory[0x00:0x40] // @0E0E stack[-2] // @0E19 memory[0x00:0x40] // @0E1B storage[keccak256(memory[0x00:0x40])] // @0E20 stack[-1] // @0E2A memory[0x40:0x60] // @0E53 memory[0x40:0x60] // @0E58 memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]] // @0E5C stack[-4] // } 0DF0 5B JUMPDEST 0DF1 60 PUSH1 0x01 0DF3 60 PUSH1 0x01 0DF5 60 PUSH1 0xa0 0DF7 1B SHL 0DF8 03 SUB 0DF9 83 DUP4 0DFA 81 DUP2 0DFB 16 AND 0DFC 60 PUSH1 0x00 0DFE 81 DUP2 0DFF 81 DUP2 0E00 52 MSTORE 0E01 60 PUSH1 0x01 0E03 60 PUSH1 0x20 0E05 90 SWAP1 0E06 81 DUP2 0E07 52 MSTORE 0E08 60 PUSH1 0x40 0E0A 80 DUP1 0E0B 83 DUP4 0E0C 20 SHA3 0E0D 94 SWAP5 0E0E 87 DUP8 0E0F 16 AND 0E10 80 DUP1 0E11 84 DUP5 0E12 52 MSTORE 0E13 94 SWAP5 0E14 82 DUP3 0E15 52 MSTORE 0E16 91 SWAP2 0E17 82 DUP3 0E18 90 SWAP1 0E19 20 SHA3 0E1A 80 DUP1 0E1B 54 SLOAD 0E1C 60 PUSH1 0xff 0E1E 19 NOT 0E1F 16 AND 0E20 86 DUP7 0E21 15 ISZERO 0E22 15 ISZERO 0E23 90 SWAP1 0E24 81 DUP2 0E25 17 OR 0E26 90 SWAP1 0E27 91 SWAP2 0E28 55 SSTORE 0E29 91 SWAP2 0E2A 51 MLOAD 0E2B 91 SWAP2 0E2C 82 DUP3 0E2D 52 MSTORE 0E2E 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0E4F 91 SWAP2 0E50 01 ADD 0E51 60 PUSH1 0x40 0E53 51 MLOAD 0E54 80 DUP1 0E55 91 SWAP2 0E56 03 SUB 0E57 90 SWAP1 0E58 A3 LOG3 0E59 50 POP 0E5A 50 POP 0E5B 50 POP 0E5C 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @0E00 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @0E07 memory[0x20:0x40] = 0x01 // @0E12 memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @0E15 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0E28 storage[keccak256(memory[0x00:0x40])] = !!stack[-1] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0E2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0E58 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (memory[0x40:0x60] + 0x20) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-3] & (0x01 << 0xa0) - 0x01, stack[-2] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-4] label_0E5D: // Incoming call from 0x098B, returns to 0x0731 // Inputs[1] { @0E66 stack[-4] } 0E5D 5B JUMPDEST 0E5E 60 PUSH1 0x01 0E60 60 PUSH1 0x01 0E62 60 PUSH1 0xa0 0E64 1B SHL 0E65 03 SUB 0E66 84 DUP5 0E67 16 AND 0E68 61 PUSH2 0x0e83 0E6B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e83, if stack[-4] & (0x01 << 0xa0) - 0x01 label_0E6C: // Incoming jump from 0x0E6B, if not stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0E6E memory[0x40:0x60] } 0E6C 60 PUSH1 0x40 0E6E 51 MLOAD 0E6F 62 PUSH3 0x461bcd 0E73 60 PUSH1 0xe5 0E75 1B SHL 0E76 81 DUP2 0E77 52 MSTORE 0E78 60 PUSH1 0x04 0E7A 01 ADD 0E7B 61 PUSH2 0x031d 0E7E 90 SWAP1 0E7F 61 PUSH2 0x1910 0E82 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E77 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E7E stack[0] = 0x031d // @0E7E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1910, returns to 0x031D label_0E83: // Incoming jump from 0x0E6B, if stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0E84 msg.sender // @0E89 stack[-5] // @0E8A stack[-4] // @0E8E stack[-3] // } 0E83 5B JUMPDEST 0E84 33 CALLER 0E85 61 PUSH2 0x0e93 0E88 81 DUP2 0E89 87 DUP8 0E8A 87 DUP8 0E8B 61 PUSH2 0x0a98 0E8E 88 DUP9 0E8F 61 PUSH2 0x0f7a 0E92 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @0E84 stack[0] = msg.sender // @0E85 stack[1] = 0x0e93 // @0E88 stack[2] = msg.sender // @0E89 stack[3] = stack[-5] // @0E8A stack[4] = stack[-4] // @0E8B stack[5] = 0x0a98 // @0E8E stack[6] = stack[-3] // } // Block ends with call to 0x0f7a, returns to 0x0A98 label_0E93: // Incoming return from call to 0x0A98 at 0x0E92 // Inputs[6] // { // @0E96 stack[-4] // @0EA2 memory[0x00:0x40] // @0EAB stack[-6] // @0EB3 memory[0x00:0x40] // @0EB4 storage[keccak256(memory[0x00:0x40])] // @0EB5 stack[-3] // } 0E93 5B JUMPDEST 0E94 60 PUSH1 0x00 0E96 84 DUP5 0E97 81 DUP2 0E98 52 MSTORE 0E99 60 PUSH1 0x20 0E9B 81 DUP2 0E9C 81 DUP2 0E9D 52 MSTORE 0E9E 60 PUSH1 0x40 0EA0 80 DUP1 0EA1 83 DUP4 0EA2 20 SHA3 0EA3 60 PUSH1 0x01 0EA5 60 PUSH1 0x01 0EA7 60 PUSH1 0xa0 0EA9 1B SHL 0EAA 03 SUB 0EAB 8A DUP11 0EAC 16 AND 0EAD 84 DUP5 0EAE 52 MSTORE 0EAF 90 SWAP1 0EB0 91 SWAP2 0EB1 52 MSTORE 0EB2 90 SWAP1 0EB3 20 SHA3 0EB4 54 SLOAD 0EB5 83 DUP4 0EB6 81 DUP2 0EB7 10 LT 0EB8 15 ISZERO 0EB9 61 PUSH2 0x0ed4 0EBC 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @0E98 memory[0x00:0x20] = stack[-4] // @0E9D memory[0x20:0x40] = 0x00 // @0EAE memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0EB1 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0EB4 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0ed4, if !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) label_0EBD: // Incoming jump from 0x0EBC, if not !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[1] { @0EBF memory[0x40:0x60] } 0EBD 60 PUSH1 0x40 0EBF 51 MLOAD 0EC0 62 PUSH3 0x461bcd 0EC4 60 PUSH1 0xe5 0EC6 1B SHL 0EC7 81 DUP2 0EC8 52 MSTORE 0EC9 60 PUSH1 0x04 0ECB 01 ADD 0ECC 61 PUSH2 0x031d 0ECF 90 SWAP1 0ED0 61 PUSH2 0x1955 0ED3 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0EC8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0ECF stack[0] = 0x031d // @0ECF stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1955, returns to 0x031D label_0ED4: // Incoming jump from 0x0EBC, if !(storage[keccak256(memory[0x00:0x40])] < stack[-3]) // Inputs[9] // { // @0ED7 stack[-5] // @0EE3 memory[0x00:0x40] // @0EEC stack[-7] // @0EF5 memory[0x00:0x40] // @0EF6 stack[-4] // @0EF7 stack[-1] // @0EFC stack[-6] // @0F01 memory[0x00:0x40] // @0F03 storage[keccak256(memory[0x00:0x40])] // } 0ED4 5B JUMPDEST 0ED5 60 PUSH1 0x00 0ED7 85 DUP6 0ED8 81 DUP2 0ED9 52 MSTORE 0EDA 60 PUSH1 0x20 0EDC 81 DUP2 0EDD 81 DUP2 0EDE 52 MSTORE 0EDF 60 PUSH1 0x40 0EE1 80 DUP1 0EE2 83 DUP4 0EE3 20 SHA3 0EE4 60 PUSH1 0x01 0EE6 60 PUSH1 0x01 0EE8 60 PUSH1 0xa0 0EEA 1B SHL 0EEB 03 SUB 0EEC 8B DUP12 0EED 81 DUP2 0EEE 16 AND 0EEF 85 DUP6 0EF0 52 MSTORE 0EF1 92 SWAP3 0EF2 52 MSTORE 0EF3 80 DUP1 0EF4 83 DUP4 0EF5 20 SHA3 0EF6 87 DUP8 0EF7 85 DUP6 0EF8 03 SUB 0EF9 90 SWAP1 0EFA 55 SSTORE 0EFB 90 SWAP1 0EFC 88 DUP9 0EFD 16 AND 0EFE 82 DUP3 0EFF 52 MSTORE 0F00 81 DUP2 0F01 20 SHA3 0F02 80 DUP1 0F03 54 SLOAD 0F04 86 DUP7 0F05 92 SWAP3 0F06 90 SWAP1 0F07 61 PUSH2 0x0f11 0F0A 90 SWAP1 0F0B 84 DUP5 0F0C 90 SWAP1 0F0D 61 PUSH2 0x19f8 0F10 56 *JUMP // Stack delta = +6 // Outputs[12] // { // @0ED9 memory[0x00:0x20] = stack[-5] // @0EDE memory[0x20:0x40] = 0x00 // @0EF0 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-7] // @0EF2 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0EFA storage[keccak256(memory[0x00:0x40])] = stack[-1] - stack[-4] // @0EFF memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0F01 stack[1] = keccak256(memory[0x00:0x40]) // @0F05 stack[0] = stack[-4] // @0F06 stack[2] = 0x00 // @0F0A stack[3] = 0x0f11 // @0F0C stack[4] = stack[-4] // @0F0C stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x19f8, returns to 0x0F11 label_0F11: // Incoming return from call to 0x19F8 at 0x0F10 // Inputs[12] // { // @0F12 stack[-1] // @0F12 stack[-2] // @0F13 stack[-3] // @0F1A memory[0x40:0x60] // @0F1B stack[-9] // @0F22 stack[-8] // @0F2E stack[-10] // @0F31 stack[-11] // @0F36 stack[-6] // @0F5E memory[0x40:0x60] // @0F63 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + memory[0x40:0x60]) - memory[0x40:0x60]] // @0F6C stack[-7] // } 0F11 5B JUMPDEST 0F12 90 SWAP1 0F13 91 SWAP2 0F14 55 SSTORE 0F15 50 POP 0F16 50 POP 0F17 60 PUSH1 0x40 0F19 80 DUP1 0F1A 51 MLOAD 0F1B 86 DUP7 0F1C 81 DUP2 0F1D 52 MSTORE 0F1E 60 PUSH1 0x20 0F20 81 DUP2 0F21 01 ADD 0F22 86 DUP7 0F23 90 SWAP1 0F24 52 MSTORE 0F25 60 PUSH1 0x01 0F27 60 PUSH1 0x01 0F29 60 PUSH1 0xa0 0F2B 1B SHL 0F2C 03 SUB 0F2D 80 DUP1 0F2E 89 DUP10 0F2F 16 AND 0F30 92 SWAP3 0F31 8A DUP11 0F32 82 DUP3 0F33 16 AND 0F34 92 SWAP3 0F35 91 SWAP2 0F36 86 DUP7 0F37 16 AND 0F38 91 SWAP2 0F39 7F PUSH32 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62 0F5A 91 SWAP2 0F5B 01 ADD 0F5C 60 PUSH1 0x40 0F5E 51 MLOAD 0F5F 80 DUP1 0F60 91 SWAP2 0F61 03 SUB 0F62 90 SWAP1 0F63 A4 LOG4 0F64 61 PUSH2 0x0f71 0F67 82 DUP3 0F68 88 DUP9 0F69 88 DUP9 0F6A 88 DUP9 0F6B 88 DUP9 0F6C 88 DUP9 0F6D 61 PUSH2 0x0fd3 0F70 56 *JUMP // Stack delta = +3 // Outputs[11] // { // @0F14 storage[stack[-3]] = stack[-1] // @0F1D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-9] // @0F24 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-8] // @0F63 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]); // @0F64 stack[-4] = 0x0f71 // @0F67 stack[-3] = stack[-6] // @0F68 stack[-2] = stack[-11] // @0F69 stack[-1] = stack[-10] // @0F6A stack[0] = stack[-9] // @0F6B stack[1] = stack[-8] // @0F6C stack[2] = stack[-7] // } // Block ends with call to 0x0fd3, returns to 0x0F71 label_0F71: // Incoming jump from 0x1126, if 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x0FD3 at 0x0F70 // Inputs[1] { @0F79 stack[-8] } 0F71 5B JUMPDEST 0F72 50 POP 0F73 50 POP 0F74 50 POP 0F75 50 POP 0F76 50 POP 0F77 50 POP 0F78 50 POP 0F79 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_0F7A: // Incoming call from 0x0A97, returns to 0x0A98 // Incoming call from 0x0AA0, returns to 0x0731 // Incoming call from 0x0E92, returns to 0x0A98 // Inputs[5] // { // @0F7E memory[0x40:0x60] // @0F98 msg.data.length // @0F9A msg.data[msg.data.length:msg.data.length + 0x20] // @0FA1 stack[-1] // @0FA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 0F7A 5B JUMPDEST 0F7B 60 PUSH1 0x40 0F7D 80 DUP1 0F7E 51 MLOAD 0F7F 60 PUSH1 0x01 0F81 80 DUP1 0F82 82 DUP3 0F83 52 MSTORE 0F84 81 DUP2 0F85 83 DUP4 0F86 01 ADD 0F87 90 SWAP1 0F88 92 SWAP3 0F89 52 MSTORE 0F8A 60 PUSH1 0x60 0F8C 91 SWAP2 0F8D 60 PUSH1 0x00 0F8F 91 SWAP2 0F90 90 SWAP1 0F91 60 PUSH1 0x20 0F93 80 DUP1 0F94 83 DUP4 0F95 01 ADD 0F96 90 SWAP1 0F97 80 DUP1 0F98 36 CALLDATASIZE 0F99 83 DUP4 0F9A 37 CALLDATACOPY 0F9B 01 ADD 0F9C 90 SWAP1 0F9D 50 POP 0F9E 50 POP 0F9F 90 SWAP1 0FA0 50 POP 0FA1 82 DUP3 0FA2 81 DUP2 0FA3 60 PUSH1 0x00 0FA5 81 DUP2 0FA6 51 MLOAD 0FA7 81 DUP2 0FA8 10 LT 0FA9 61 PUSH2 0x0fc2 0FAC 57 *JUMPI // Stack delta = +5 // Outputs[8] // { // @0F83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @0F89 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0F8C stack[0] = 0x60 // @0F9A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = msg.data[msg.data.length:msg.data.length + 0x20] // @0F9F stack[1] = memory[0x40:0x60] // @0FA1 stack[2] = stack[-1] // @0FA2 stack[3] = memory[0x40:0x60] // @0FA3 stack[4] = 0x00 // } // Block ends with conditional jump to 0x0fc2, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] label_0FAD: // Incoming jump from 0x0FAC, if not 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[1] { @0FC1 memory[0x00:0x24] } 0FAD 63 PUSH4 0x4e487b71 0FB2 60 PUSH1 0xe0 0FB4 1B SHL 0FB5 60 PUSH1 0x00 0FB7 52 MSTORE 0FB8 60 PUSH1 0x32 0FBA 60 PUSH1 0x04 0FBC 52 MSTORE 0FBD 60 PUSH1 0x24 0FBF 60 PUSH1 0x00 0FC1 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0FB7 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0FBC memory[0x04:0x24] = 0x32 // @0FC1 revert(memory[0x00:0x24]); // } // Block terminates label_0FC2: // Incoming jump from 0x0FAC, if 0x00 < memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // Inputs[6] // { // @0FC5 stack[-1] // @0FC8 stack[-2] // @0FCD stack[-3] // @0FCE stack[-7] // @0FCE stack[-4] // @0FCF stack[-6] // } 0FC2 5B JUMPDEST 0FC3 60 PUSH1 0x20 0FC5 90 SWAP1 0FC6 81 DUP2 0FC7 02 MUL 0FC8 91 SWAP2 0FC9 90 SWAP1 0FCA 91 SWAP2 0FCB 01 ADD 0FCC 01 ADD 0FCD 52 MSTORE 0FCE 92 SWAP3 0FCF 91 SWAP2 0FD0 50 POP 0FD1 50 POP 0FD2 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0FCD memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0FCE stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_0FD3: // Incoming call from 0x0B30, returns to 0x0731 // Incoming call from 0x0F70, returns to 0x0F71 // Inputs[2] // { // @0FDC stack[-4] // @0FDE address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // } 0FD3 5B JUMPDEST 0FD4 60 PUSH1 0x01 0FD6 60 PUSH1 0x01 0FD8 60 PUSH1 0xa0 0FDA 1B SHL 0FDB 03 SUB 0FDC 84 DUP5 0FDD 16 AND 0FDE 3B EXTCODESIZE 0FDF 15 ISZERO 0FE0 61 PUSH2 0x0d22 0FE3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d22, if !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length label_0FE4: // Incoming jump from 0x0FE3, if not !address(stack[-4] & (0x01 << 0xa0) - 0x01).code.length // Inputs[7] // { // @0FE6 memory[0x40:0x60] // @0FF9 stack[-4] // @1006 stack[-6] // @1008 stack[-5] // @100A stack[-3] // @100C stack[-2] // @100E stack[-1] // } 0FE4 60 PUSH1 0x40 0FE6 51 MLOAD 0FE7 63 PUSH4 0xf23a6e61 0FEC 60 PUSH1 0xe0 0FEE 1B SHL 0FEF 81 DUP2 0FF0 52 MSTORE 0FF1 60 PUSH1 0x01 0FF3 60 PUSH1 0x01 0FF5 60 PUSH1 0xa0 0FF7 1B SHL 0FF8 03 SUB 0FF9 85 DUP6 0FFA 16 AND 0FFB 90 SWAP1 0FFC 63 PUSH4 0xf23a6e61 1001 90 SWAP1 1002 61 PUSH2 0x1017 1005 90 SWAP1 1006 89 DUP10 1007 90 SWAP1 1008 89 DUP10 1009 90 SWAP1 100A 88 DUP9 100B 90 SWAP1 100C 88 DUP9 100D 90 SWAP1 100E 88 DUP9 100F 90 SWAP1 1010 60 PUSH1 0x04 1012 01 ADD 1013 61 PUSH2 0x1805 1016 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @0FF0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xf23a6e61 << 0xe0 // @0FFB stack[0] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1001 stack[1] = 0xf23a6e61 // @1005 stack[2] = 0x1017 // @1007 stack[3] = stack[-6] // @1009 stack[4] = stack[-5] // @100B stack[5] = stack[-3] // @100D stack[6] = stack[-2] // @100F stack[7] = stack[-1] // @1012 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x1805, returns to 0x1017 label_1017: // Incoming return from call to 0x1805 at 0x1016 // Inputs[4] // { // @101C memory[0x40:0x60] // @101E stack[-1] // @1023 stack[-3] // @1025 address(stack[-3]).code.length // } 1017 5B JUMPDEST 1018 60 PUSH1 0x20 101A 60 PUSH1 0x40 101C 51 MLOAD 101D 80 DUP1 101E 83 DUP4 101F 03 SUB 1020 81 DUP2 1021 60 PUSH1 0x00 1023 87 DUP8 1024 80 DUP1 1025 3B EXTCODESIZE 1026 15 ISZERO 1027 80 DUP1 1028 15 ISZERO 1029 61 PUSH2 0x1031 102C 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1018 stack[0] = 0x20 // @101C stack[1] = memory[0x40:0x60] // @101F stack[2] = stack[-1] - memory[0x40:0x60] // @1020 stack[3] = memory[0x40:0x60] // @1021 stack[4] = 0x00 // @1023 stack[5] = stack[-3] // @1026 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1031, if !!address(stack[-3]).code.length label_102D: // Incoming jump from 0x102C, if not !!address(stack[-3]).code.length // Inputs[1] { @1030 memory[0x00:0x00] } 102D 60 PUSH1 0x00 102F 80 DUP1 1030 FD *REVERT // Stack delta = +0 // Outputs[1] { @1030 revert(memory[0x00:0x00]); } // Block terminates label_1031: // Incoming jump from 0x102C, if !!address(stack[-3]).code.length // Inputs[10] // { // @1033 msg.gas // @1034 memory[stack[-4]:stack[-4] + stack[-5]] // @1034 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1034 stack[-4] // @1034 stack[-2] // @1034 stack[-5] // @1034 stack[-6] // @1034 stack[-7] // @1034 stack[-3] // @1035 stack[-10] // } 1031 5B JUMPDEST 1032 50 POP 1033 5A GAS 1034 F1 CALL 1035 92 SWAP3 1036 50 POP 1037 50 POP 1038 50 POP 1039 80 DUP1 103A 15 ISZERO 103B 61 PUSH2 0x1061 103E 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1034 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1035 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 0x1061, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_103F: // Incoming jump from 0x103E, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1043 memory[0x40:0x60] // @1046 returndata.length // } 103F 50 POP 1040 60 PUSH1 0x40 1042 80 DUP1 1043 51 MLOAD 1044 60 PUSH1 0x1f 1046 3D RETURNDATASIZE 1047 90 SWAP1 1048 81 DUP2 1049 01 ADD 104A 60 PUSH1 0x1f 104C 19 NOT 104D 16 AND 104E 82 DUP3 104F 01 ADD 1050 90 SWAP1 1051 92 SWAP3 1052 52 MSTORE 1053 61 PUSH2 0x105e 1056 91 SWAP2 1057 81 DUP2 1058 01 ADD 1059 90 SWAP1 105A 61 PUSH2 0x1678 105D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1052 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1056 stack[-1] = 0x105e // @1059 stack[1] = memory[0x40:0x60] // @1059 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x1678 105E 5B JUMPDEST 105F 60 PUSH1 0x01 label_1061: // Incoming jump from 0x103E, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1065 stack[-1] } 1061 5B JUMPDEST 1062 61 PUSH2 0x110e 1065 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x110e, if stack[-1] label_1066: // Incoming jump from 0x1065, if not stack[-1] 1066 61 PUSH2 0x106d 1069 61 PUSH2 0x1abf 106C 56 *JUMP // Stack delta = +1 // Outputs[1] { @1066 stack[0] = 0x106d } // Block ends with call to 0x1abf, returns to 0x106D label_106D: // Incoming return from call to 0x1ABF at 0x106C // Inputs[1] { @106E stack[-1] } 106D 5B JUMPDEST 106E 80 DUP1 106F 63 PUSH4 0x08c379a0 1074 14 EQ 1075 15 ISZERO 1076 61 PUSH2 0x10a7 1079 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10a7, if !(0x08c379a0 == stack[-1]) label_107A: // Incoming jump from 0x1079, if not !(0x08c379a0 == stack[-1]) 107A 50 POP 107B 61 PUSH2 0x1082 107E 61 PUSH2 0x1ad7 1081 56 *JUMP // Stack delta = +0 // Outputs[1] { @107B stack[-1] = 0x1082 } // Block ends with call to 0x1ad7, returns to 0x1082 label_1082: // Incoming return from call to 0x1AD7 at 0x1081 // Incoming return from call to 0x1AD7 at 0x1081 // Inputs[1] { @1083 stack[-1] } 1082 5B JUMPDEST 1083 80 DUP1 1084 61 PUSH2 0x108d 1087 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x108d, if stack[-1] label_1088: // Incoming jump from 0x1087, if not stack[-1] 1088 50 POP 1089 61 PUSH2 0x10a9 108C 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to 0x10a9 label_108D: // Incoming jump from 0x1087, if stack[-1] // Inputs[2] // { // @108E stack[-1] // @1091 memory[0x40:0x60] // } 108D 5B JUMPDEST 108E 80 DUP1 108F 60 PUSH1 0x40 1091 51 MLOAD 1092 62 PUSH3 0x461bcd 1096 60 PUSH1 0xe5 1098 1B SHL 1099 81 DUP2 109A 52 MSTORE 109B 60 PUSH1 0x04 109D 01 ADD 109E 61 PUSH2 0x031d 10A1 91 SWAP2 10A2 90 SWAP1 10A3 61 PUSH2 0x188b 10A6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @109A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10A1 stack[0] = 0x031d // @10A2 stack[1] = stack[-1] // @10A2 stack[2] = 0x04 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x188b label_10A7: // Incoming jump from 0x1079, if !(0x08c379a0 == stack[-1]) // Inputs[1] { @10AC memory[0x40:0x60] } 10A7 5B JUMPDEST 10A8 50 POP 10A9 5B JUMPDEST 10AA 60 PUSH1 0x40 10AC 51 MLOAD 10AD 62 PUSH3 0x461bcd 10B1 60 PUSH1 0xe5 10B3 1B SHL 10B4 81 DUP2 10B5 52 MSTORE 10B6 60 PUSH1 0x20 10B8 60 PUSH1 0x04 10BA 82 DUP3 10BB 01 ADD 10BC 52 MSTORE 10BD 60 PUSH1 0x34 10BF 60 PUSH1 0x24 10C1 82 DUP3 10C2 01 ADD 10C3 52 MSTORE 10C4 7F PUSH32 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 10E5 60 PUSH1 0x44 10E7 82 DUP3 10E8 01 ADD 10E9 52 MSTORE 10EA 73 PUSH20 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 10FF 60 PUSH1 0x61 1101 1B SHL 1102 60 PUSH1 0x64 1104 82 DUP3 1105 01 ADD 1106 52 MSTORE 1107 60 PUSH1 0x84 1109 01 ADD 110A 61 PUSH2 0x031d 110D 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @10B5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @10BC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @10C3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x34 // @10E9 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243313135353a207472616e7366657220746f206e6f6e2045524331313535 // @1106 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2932b1b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x61 // @1109 stack[-1] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x031d label_110E: // Incoming jump from 0x1065, if stack[-1] // Inputs[1] { @1118 stack[-1] } 110E 5B JUMPDEST 110F 60 PUSH1 0x01 1111 60 PUSH1 0x01 1113 60 PUSH1 0xe0 1115 1B SHL 1116 03 SUB 1117 19 NOT 1118 81 DUP2 1119 16 AND 111A 63 PUSH4 0xf23a6e61 111F 60 PUSH1 0xe0 1121 1B SHL 1122 14 EQ 1123 61 PUSH2 0x0f71 1126 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f71, if 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1127: // Incoming jump from 0x1126, if not 0xf23a6e61 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1129 memory[0x40:0x60] } 1127 60 PUSH1 0x40 1129 51 MLOAD 112A 62 PUSH3 0x461bcd 112E 60 PUSH1 0xe5 1130 1B SHL 1131 81 DUP2 1132 52 MSTORE 1133 60 PUSH1 0x04 1135 01 ADD 1136 61 PUSH2 0x031d 1139 90 SWAP1 113A 61 PUSH2 0x189e 113D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1132 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1139 stack[0] = 0x031d // @1139 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x189e, returns to 0x031D 113E 5B JUMPDEST 113F 60 PUSH1 0x01 1141 60 PUSH1 0x01 1143 60 PUSH1 0xa0 1145 1B SHL 1146 03 SUB 1147 84 DUP5 1148 16 AND 1149 3B EXTCODESIZE 114A 15 ISZERO 114B 61 PUSH2 0x0d22 114E 57 *JUMPI 114F 60 PUSH1 0x40 1151 51 MLOAD 1152 63 PUSH4 0xbc197c81 1157 60 PUSH1 0xe0 1159 1B SHL 115A 81 DUP2 115B 52 MSTORE 115C 60 PUSH1 0x01 115E 60 PUSH1 0x01 1160 60 PUSH1 0xa0 1162 1B SHL 1163 03 SUB 1164 85 DUP6 1165 16 AND 1166 90 SWAP1 1167 63 PUSH4 0xbc197c81 116C 90 SWAP1 116D 61 PUSH2 0x1182 1170 90 SWAP1 1171 89 DUP10 1172 90 SWAP1 1173 89 DUP10 1174 90 SWAP1 1175 88 DUP9 1176 90 SWAP1 1177 88 DUP9 1178 90 SWAP1 1179 88 DUP9 117A 90 SWAP1 117B 60 PUSH1 0x04 117D 01 ADD 117E 61 PUSH2 0x17a7 1181 56 *JUMP 1182 5B JUMPDEST 1183 60 PUSH1 0x20 1185 60 PUSH1 0x40 1187 51 MLOAD 1188 80 DUP1 1189 83 DUP4 118A 03 SUB 118B 81 DUP2 118C 60 PUSH1 0x00 118E 87 DUP8 118F 80 DUP1 1190 3B EXTCODESIZE 1191 15 ISZERO 1192 80 DUP1 1193 15 ISZERO 1194 61 PUSH2 0x119c 1197 57 *JUMPI 1198 60 PUSH1 0x00 119A 80 DUP1 119B FD *REVERT 119C 5B JUMPDEST 119D 50 POP 119E 5A GAS 119F F1 CALL 11A0 92 SWAP3 11A1 50 POP 11A2 50 POP 11A3 50 POP 11A4 80 DUP1 11A5 15 ISZERO 11A6 61 PUSH2 0x11cc 11A9 57 *JUMPI 11AA 50 POP 11AB 60 PUSH1 0x40 11AD 80 DUP1 11AE 51 MLOAD 11AF 60 PUSH1 0x1f 11B1 3D RETURNDATASIZE 11B2 90 SWAP1 11B3 81 DUP2 11B4 01 ADD 11B5 60 PUSH1 0x1f 11B7 19 NOT 11B8 16 AND 11B9 82 DUP3 11BA 01 ADD 11BB 90 SWAP1 11BC 92 SWAP3 11BD 52 MSTORE 11BE 61 PUSH2 0x11c9 11C1 91 SWAP2 11C2 81 DUP2 11C3 01 ADD 11C4 90 SWAP1 11C5 61 PUSH2 0x1678 11C8 56 *JUMP 11C9 5B JUMPDEST 11CA 60 PUSH1 0x01 11CC 5B JUMPDEST 11CD 61 PUSH2 0x11d8 11D0 57 *JUMPI 11D1 61 PUSH2 0x106d 11D4 61 PUSH2 0x1abf 11D7 56 *JUMP 11D8 5B JUMPDEST 11D9 60 PUSH1 0x01 11DB 60 PUSH1 0x01 11DD 60 PUSH1 0xe0 11DF 1B SHL 11E0 03 SUB 11E1 19 NOT 11E2 81 DUP2 11E3 16 AND 11E4 63 PUSH4 0xbc197c81 11E9 60 PUSH1 0xe0 11EB 1B SHL 11EC 14 EQ 11ED 61 PUSH2 0x0f71 11F0 57 *JUMPI 11F1 60 PUSH1 0x40 11F3 51 MLOAD 11F4 62 PUSH3 0x461bcd 11F8 60 PUSH1 0xe5 11FA 1B SHL 11FB 81 DUP2 11FC 52 MSTORE 11FD 60 PUSH1 0x04 11FF 01 ADD 1200 61 PUSH2 0x031d 1203 90 SWAP1 1204 61 PUSH2 0x189e 1207 56 *JUMP label_1208: // Incoming jump from 0x0538 // Incoming jump from 0x0663 // Inputs[2] // { // @1209 stack[-3] // @120B storage[stack[-3]] // } 1208 5B JUMPDEST 1209 82 DUP3 120A 80 DUP1 120B 54 SLOAD 120C 61 PUSH2 0x1214 120F 90 SWAP1 1210 61 PUSH2 0x1a10 1213 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1209 stack[0] = stack[-3] // @120F stack[1] = 0x1214 // @120F stack[2] = storage[stack[-3]] // } // Block ends with call to 0x1a10, returns to 0x1214 label_1214: // Incoming return from call to 0x1A10 at 0x1213 // Inputs[5] // { // @1215 stack[-1] // @1215 stack[-2] // @121D memory[0x00:0x20] // @1228 stack[-4] // @1229 stack[-3] // } 1214 5B JUMPDEST 1215 90 SWAP1 1216 60 PUSH1 0x00 1218 52 MSTORE 1219 60 PUSH1 0x20 121B 60 PUSH1 0x00 121D 20 SHA3 121E 90 SWAP1 121F 60 PUSH1 0x1f 1221 01 ADD 1222 60 PUSH1 0x20 1224 90 SWAP1 1225 04 DIV 1226 81 DUP2 1227 01 ADD 1228 92 SWAP3 1229 82 DUP3 122A 61 PUSH2 0x1236 122D 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1218 memory[0x00:0x20] = stack[-2] // @121E stack[-2] = keccak256(memory[0x00:0x20]) // @1228 stack[-1] = stack[-4] // @1228 stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x1236, if stack[-3] label_122E: // Incoming jump from 0x122D, if not stack[-3] // Inputs[1] { @1230 stack[-5] } 122E 60 PUSH1 0x00 1230 85 DUP6 1231 55 SSTORE 1232 61 PUSH2 0x127c 1235 56 *JUMP // Stack delta = +0 // Outputs[1] { @1231 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x127c label_1236: // Incoming jump from 0x122D, if stack[-3] // Inputs[1] { @1237 stack[-3] } 1236 5B JUMPDEST 1237 82 DUP3 1238 60 PUSH1 0x1f 123A 10 LT 123B 61 PUSH2 0x124f 123E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x124f, if 0x1f < stack[-3] label_123F: // Incoming jump from 0x123E, if not 0x1f < stack[-3] // Inputs[4] // { // @123F stack[-1] // @1240 memory[stack[-1]:stack[-1] + 0x20] // @1245 stack[-3] // @1249 stack[-5] // } 123F 80 DUP1 1240 51 MLOAD 1241 60 PUSH1 0xff 1243 19 NOT 1244 16 AND 1245 83 DUP4 1246 80 DUP1 1247 01 ADD 1248 17 OR 1249 85 DUP6 124A 55 SSTORE 124B 61 PUSH2 0x127c 124E 56 *JUMP // Stack delta = +0 // Outputs[1] { @124A storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x127c label_124F: // Incoming jump from 0x123E, if 0x1f < stack[-3] // Inputs[2] // { // @1250 stack[-3] // @1256 stack[-5] // } 124F 5B JUMPDEST 1250 82 DUP3 1251 80 DUP1 1252 01 ADD 1253 60 PUSH1 0x01 1255 01 ADD 1256 85 DUP6 1257 55 SSTORE 1258 82 DUP3 1259 15 ISZERO 125A 61 PUSH2 0x127c 125D 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1257 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x127c, if !stack[-3] label_125E: // Incoming jump from 0x125D, if not !stack[-3] // Inputs[2] // { // @125E stack[-3] // @125E stack[-1] // } 125E 91 SWAP2 125F 82 DUP3 1260 01 ADD 1261 5B JUMPDEST 1262 82 DUP3 1263 81 DUP2 1264 11 GT 1265 15 ISZERO 1266 61 PUSH2 0x127c 1269 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @125E stack[-3] = stack[-1] // @1260 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x127c, if !(stack[-1] + stack[-3] > stack[-1]) label_126A: // Incoming jump from 0x1269, if not !(stack[-1] + stack[-3] > stack[-1]) // Incoming jump from 0x1269, if not !(stack[-1] > stack[-3]) // Inputs[4] // { // @126A stack[-3] // @126B memory[stack[-3]:stack[-3] + 0x20] // @126C stack[-2] // @126E stack[-1] // } 126A 82 DUP3 126B 51 MLOAD 126C 82 DUP3 126D 55 SSTORE 126E 91 SWAP2 126F 60 PUSH1 0x20 1271 01 ADD 1272 91 SWAP2 1273 90 SWAP1 1274 60 PUSH1 0x01 1276 01 ADD 1277 90 SWAP1 1278 61 PUSH2 0x1261 127B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @126D storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @1272 stack[-3] = 0x20 + stack[-3] // @1277 stack[-2] = 0x01 + stack[-2] // @1277 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x1261 label_127C: // Incoming jump from 0x124E // Incoming jump from 0x1269, if !(stack[-1] > stack[-3]) // Incoming jump from 0x125D, if !stack[-3] // Incoming jump from 0x1235 // Incoming jump from 0x1269, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @1281 stack[-4] // @1282 stack[-3] // } 127C 5B JUMPDEST 127D 50 POP 127E 61 PUSH2 0x1288 1281 92 SWAP3 1282 91 SWAP2 1283 50 POP 1284 61 PUSH2 0x128c 1287 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1281 stack[-4] = 0x1288 // @1282 stack[-3] = stack[-4] // } // Block ends with call to 0x128c, returns to 0x1288 label_1288: // Incoming jump from 0x1295, if !(stack[-2] > stack[-1]) // Incoming jump from 0x1295, if !(stack[-2] > stack[-1]) // Incoming return from call to 0x128C at 0x1287 // Inputs[2] // { // @128A stack[-3] // @128A stack[-2] // } 1288 5B JUMPDEST 1289 50 POP 128A 90 SWAP1 128B 56 *JUMP // Stack delta = -2 // Outputs[1] { @128A stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_128C: // Incoming call from 0x1287, returns to 0x1288 // Inputs[2] // { // @128E stack[-1] // @128F stack[-2] // } 128C 5B JUMPDEST 128D 5B JUMPDEST 128E 80 DUP1 128F 82 DUP3 1290 11 GT 1291 15 ISZERO 1292 61 PUSH2 0x1288 1295 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1288, if !(stack[-2] > stack[-1]) label_1296: // Incoming jump from 0x1295, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x1295, if not !(stack[-2] > stack[-1]) // Inputs[1] { @1298 stack[-1] } 1296 60 PUSH1 0x00 1298 81 DUP2 1299 55 SSTORE 129A 60 PUSH1 0x01 129C 01 ADD 129D 61 PUSH2 0x128d 12A0 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1299 storage[stack[-1]] = 0x00 // @129C stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x128d label_12A1: // Incoming call from 0x1412, returns to 0x1413 // Incoming call from 0x161A, returns to 0x161B // Incoming call from 0x1420, returns to 0x1421 // Incoming call from 0x14C6, returns to 0x14C7 // Incoming call from 0x1550, returns to 0x1551 // Incoming call from 0x13B9, returns to 0x13BA // Incoming call from 0x14B8, returns to 0x14B9 // Incoming call from 0x1516, returns to 0x1517 // Incoming call from 0x157B, returns to 0x157C // Incoming call from 0x13DB, returns to 0x13DC // Incoming call from 0x13E9, returns to 0x13EA // Inputs[2] // { // @12A2 stack[-1] // @12A3 msg.data[stack[-1]:stack[-1] + 0x20] // } 12A1 5B JUMPDEST 12A2 80 DUP1 12A3 35 CALLDATALOAD 12A4 60 PUSH1 0x01 12A6 60 PUSH1 0x01 12A8 60 PUSH1 0xa0 12AA 1B SHL 12AB 03 SUB 12AC 81 DUP2 12AD 16 AND 12AE 81 DUP2 12AF 14 EQ 12B0 61 PUSH2 0x12b8 12B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12A3 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x12b8, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_12B4: // Incoming jump from 0x12B3, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12B7 memory[0x00:0x00] } 12B4 60 PUSH1 0x00 12B6 80 DUP1 12B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @12B7 revert(memory[0x00:0x00]); } // Block terminates label_12B8: // Incoming jump from 0x12B3, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @12B9 stack[-1] // @12B9 stack[-3] // @12BA stack[-2] // } 12B8 5B JUMPDEST 12B9 91 SWAP2 12BA 90 SWAP1 12BB 50 POP 12BC 56 *JUMP // Stack delta = -2 // Outputs[1] { @12B9 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_12BD: // Incoming call from 0x1448, returns to 0x1449 // Incoming call from 0x1651, returns to 0x1652 // Incoming call from 0x1469, returns to 0x146A // Inputs[2] // { // @12C0 stack[-2] // @12C3 stack[-1] // } 12BD 5B JUMPDEST 12BE 60 PUSH1 0x00 12C0 82 DUP3 12C1 60 PUSH1 0x1f 12C3 83 DUP4 12C4 01 ADD 12C5 12 SLT 12C6 61 PUSH2 0x12cd 12C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @12BE stack[0] = 0x00 } // Block ends with conditional jump to 0x12cd, if stack[-1] + 0x1f i< stack[-2] label_12CA: // Incoming jump from 0x12C9, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @12CA stack[-1] // @12CC memory[stack[-1]:stack[-1] + stack[-1]] // } 12CA 80 DUP1 12CB 81 DUP2 12CC FD *REVERT // Stack delta = +0 // Outputs[1] { @12CC revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_12CD: // Incoming jump from 0x12C9, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @12CE stack[-2] // @12CF msg.data[stack[-2]:stack[-2] + 0x20] // } 12CD 5B JUMPDEST 12CE 81 DUP2 12CF 35 CALLDATALOAD 12D0 60 PUSH1 0x20 12D2 61 PUSH2 0x12da 12D5 82 DUP3 12D6 61 PUSH2 0x19d4 12D9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12CF stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @12D0 stack[1] = 0x20 // @12D2 stack[2] = 0x12da // @12D5 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x19d4, returns to 0x12DA label_12DA: // Incoming return from call to 0x19D4 at 0x12D9 // Inputs[2] // { // @12DD memory[0x40:0x60] // @12E1 stack[-1] // } 12DA 5B JUMPDEST 12DB 60 PUSH1 0x40 12DD 51 MLOAD 12DE 61 PUSH2 0x12e7 12E1 82 DUP3 12E2 82 DUP3 12E3 61 PUSH2 0x1a4b 12E6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @12DD stack[0] = memory[0x40:0x60] // @12DE stack[1] = 0x12e7 // @12E1 stack[2] = stack[-1] // @12E2 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1a4b, returns to 0x12E7 label_12E7: // Incoming return from call to 0x1A4B at 0x12E6 // Inputs[6] // { // @12E8 stack[-4] // @12E9 stack[-1] // @12EB stack[-3] // @12EE stack[-2] // @12F0 stack[-6] // @12FC stack[-7] // } 12E7 5B JUMPDEST 12E8 83 DUP4 12E9 81 DUP2 12EA 52 MSTORE 12EB 82 DUP3 12EC 81 DUP2 12ED 01 ADD 12EE 91 SWAP2 12EF 50 POP 12F0 85 DUP6 12F1 83 DUP4 12F2 01 ADD 12F3 60 PUSH1 0x05 12F5 85 DUP6 12F6 90 SWAP1 12F7 1B SHL 12F8 87 DUP8 12F9 01 ADD 12FA 84 DUP5 12FB 01 ADD 12FC 88 DUP9 12FD 10 LT 12FE 15 ISZERO 12FF 61 PUSH2 0x1306 1302 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @12EA memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @12EE stack[-2] = stack[-1] + stack[-3] // @12F2 stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1306, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_1303: // Incoming jump from 0x1302, if not !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1303 stack[-6] // @1305 memory[stack[-6]:stack[-6] + stack[-6]] // } 1303 85 DUP6 1304 86 DUP7 1305 FD *REVERT // Stack delta = +0 // Outputs[1] { @1305 revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_1306: // Incoming jump from 0x1302, if !(stack[-7] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1307 stack[-6] // @1309 stack[-5] // } 1306 5B JUMPDEST 1307 85 DUP6 1308 5B JUMPDEST 1309 85 DUP6 130A 81 DUP2 130B 10 LT 130C 15 ISZERO 130D 61 PUSH2 0x1324 1310 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1307 stack[0] = stack[-6] } // Block ends with conditional jump to 0x1324, if !(stack[-6] < stack[-5]) label_1311: // Incoming jump from 0x1310, if not !(stack[-6] < stack[-5]) // Incoming jump from 0x1310, if not !(stack[-1] < stack[-6]) // Inputs[5] // { // @1311 stack[-2] // @1312 msg.data[stack[-2]:stack[-2] + 0x20] // @1313 stack[-4] // @1315 stack[-1] // @1316 stack[-5] // } 1311 81 DUP2 1312 35 CALLDATALOAD 1313 84 DUP5 1314 52 MSTORE 1315 92 SWAP3 1316 84 DUP5 1317 01 ADD 1318 92 SWAP3 1319 90 SWAP1 131A 84 DUP5 131B 01 ADD 131C 90 SWAP1 131D 60 PUSH1 0x01 131F 01 ADD 1320 61 PUSH2 0x1308 1323 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1314 memory[stack[-4]:stack[-4] + 0x20] = msg.data[stack[-2]:stack[-2] + 0x20] // @1318 stack[-4] = stack[-5] + stack[-4] // @131C stack[-2] = stack[-5] + stack[-2] // @131F stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1308 label_1324: // Incoming jump from 0x1310, if !(stack[-6] < stack[-5]) // Incoming jump from 0x1310, if !(stack[-1] < stack[-6]) // Inputs[4] // { // @1326 stack[-2] // @1326 stack[-3] // @1327 stack[-10] // @1328 stack[-9] // } 1324 5B JUMPDEST 1325 50 POP 1326 90 SWAP1 1327 97 SWAP8 1328 96 SWAP7 1329 50 POP 132A 50 POP 132B 50 POP 132C 50 POP 132D 50 POP 132E 50 POP 132F 50 POP 1330 56 *JUMP // Stack delta = -9 // Outputs[1] { @1327 stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_1331: // Incoming call from 0x148B, returns to 0x148C // Incoming call from 0x14FB, returns to 0x148C // Incoming call from 0x1721, returns to 0x1652 // Incoming call from 0x16C6, returns to 0x16C7 // Inputs[2] // { // @1334 stack[-2] // @1337 stack[-1] // } 1331 5B JUMPDEST 1332 60 PUSH1 0x00 1334 82 DUP3 1335 60 PUSH1 0x1f 1337 83 DUP4 1338 01 ADD 1339 12 SLT 133A 61 PUSH2 0x1341 133D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1332 stack[0] = 0x00 } // Block ends with conditional jump to 0x1341, if stack[-1] + 0x1f i< stack[-2] label_133E: // Incoming jump from 0x133D, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @133E stack[-1] // @1340 memory[stack[-1]:stack[-1] + stack[-1]] // } 133E 80 DUP1 133F 81 DUP2 1340 FD *REVERT // Stack delta = +0 // Outputs[1] { @1340 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1341: // Incoming jump from 0x133D, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @1342 stack[-2] // @1343 msg.data[stack[-2]:stack[-2] + 0x20] // } 1341 5B JUMPDEST 1342 81 DUP2 1343 35 CALLDATALOAD 1344 67 PUSH8 0xffffffffffffffff 134D 81 DUP2 134E 11 GT 134F 15 ISZERO 1350 61 PUSH2 0x135b 1353 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1343 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x135b, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_1354: // Incoming jump from 0x1353, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 1354 61 PUSH2 0x135b 1357 61 PUSH2 0x1aa9 135A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1354 stack[0] = 0x135b } // Block ends with unconditional jump to 0x1aa9 label_135B: // Incoming jump from 0x1353, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @135E memory[0x40:0x60] // @1364 stack[-1] // } 135B 5B JUMPDEST 135C 60 PUSH1 0x40 135E 51 MLOAD 135F 61 PUSH2 0x1372 1362 60 PUSH1 0x1f 1364 83 DUP4 1365 01 ADD 1366 60 PUSH1 0x1f 1368 19 NOT 1369 16 AND 136A 60 PUSH1 0x20 136C 01 ADD 136D 82 DUP3 136E 61 PUSH2 0x1a4b 1371 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @135E stack[0] = memory[0x40:0x60] // @135F stack[1] = 0x1372 // @136C stack[2] = 0x20 + (~0x1f & stack[-1] + 0x1f) // @136D stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1a4b, returns to 0x1372 label_1372: // Incoming return from call to 0x1A4B at 0x1371 // Inputs[4] // { // @1373 stack[-2] // @1374 stack[-1] // @1376 stack[-5] // @137A stack[-4] // } 1372 5B JUMPDEST 1373 81 DUP2 1374 81 DUP2 1375 52 MSTORE 1376 84 DUP5 1377 60 PUSH1 0x20 1379 83 DUP4 137A 86 DUP7 137B 01 ADD 137C 01 ADD 137D 11 GT 137E 15 ISZERO 137F 61 PUSH2 0x1386 1382 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1375 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x1386, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_1383: // Incoming jump from 0x1382, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[2] // { // @1383 stack[-3] // @1385 memory[stack[-3]:stack[-3] + stack[-3]] // } 1383 82 DUP3 1384 83 DUP4 1385 FD *REVERT // Stack delta = +0 // Outputs[1] { @1385 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1386: // Incoming jump from 0x1382, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[7] // { // @1387 stack[-2] // @138A stack[-4] // @138E stack[-1] // @1390 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @1397 stack[-3] // @139B stack[-6] // @139C stack[-5] // } 1386 5B JUMPDEST 1387 81 DUP2 1388 60 PUSH1 0x20 138A 85 DUP6 138B 01 ADD 138C 60 PUSH1 0x20 138E 83 DUP4 138F 01 ADD 1390 37 CALLDATACOPY 1391 90 SWAP1 1392 81 DUP2 1393 01 ADD 1394 60 PUSH1 0x20 1396 01 ADD 1397 91 SWAP2 1398 90 SWAP1 1399 91 SWAP2 139A 52 MSTORE 139B 92 SWAP3 139C 91 SWAP2 139D 50 POP 139E 50 POP 139F 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @1390 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @139A memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] = stack[-3] // @139B stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_13A0: // Incoming call from 0x02AF, returns to 0x02B0 // Inputs[2] // { // @13A5 stack[-1] // @13A6 stack[-2] // } 13A0 5B JUMPDEST 13A1 60 PUSH1 0x00 13A3 60 PUSH1 0x20 13A5 82 DUP3 13A6 84 DUP5 13A7 03 SUB 13A8 12 SLT 13A9 15 ISZERO 13AA 61 PUSH2 0x13b1 13AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @13A1 stack[0] = 0x00 } // Block ends with conditional jump to 0x13b1, if !(stack[-2] - stack[-1] i< 0x20) label_13AE: // Incoming jump from 0x13AD, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @13AE stack[-1] // @13B0 memory[stack[-1]:stack[-1] + stack[-1]] // } 13AE 80 DUP1 13AF 81 DUP2 13B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @13B0 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_13B1: // Incoming jump from 0x13AD, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @13B5 stack[-2] } 13B1 5B JUMPDEST 13B2 61 PUSH2 0x13ba 13B5 82 DUP3 13B6 61 PUSH2 0x12a1 13B9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13B2 stack[0] = 0x13ba // @13B5 stack[1] = stack[-2] // } // Block ends with call to 0x12a1, returns to 0x13BA label_13BA: // Incoming return from call to 0x1B61 at 0x1677 // Incoming return from call to 0x12A1 at 0x13B9 // Incoming return from call to 0x175C at 0x189D // Incoming return from call to 0x1B61 at 0x1693 // Inputs[3] // { // @13BB stack[-1] // @13BB stack[-5] // @13BC stack[-4] // } 13BA 5B JUMPDEST 13BB 93 SWAP4 13BC 92 SWAP3 13BD 50 POP 13BE 50 POP 13BF 50 POP 13C0 56 *JUMP // Stack delta = -4 // Outputs[1] { @13BB stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_13C1: // Incoming call from 0x0260, returns to 0x0261 // Inputs[2] // { // @13C7 stack[-1] // @13C8 stack[-2] // } 13C1 5B JUMPDEST 13C2 60 PUSH1 0x00 13C4 80 DUP1 13C5 60 PUSH1 0x40 13C7 83 DUP4 13C8 85 DUP6 13C9 03 SUB 13CA 12 SLT 13CB 15 ISZERO 13CC 61 PUSH2 0x13d3 13CF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @13C2 stack[0] = 0x00 // @13C4 stack[1] = 0x00 // } // Block ends with conditional jump to 0x13d3, if !(stack[-2] - stack[-1] i< 0x40) label_13D0: // Incoming jump from 0x13CF, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @13D0 stack[-1] // @13D2 memory[stack[-1]:stack[-1] + stack[-1]] // } 13D0 80 DUP1 13D1 81 DUP2 13D2 FD *REVERT // Stack delta = +0 // Outputs[1] { @13D2 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_13D3: // Incoming jump from 0x13CF, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @13D7 stack[-3] } 13D3 5B JUMPDEST 13D4 61 PUSH2 0x13dc 13D7 83 DUP4 13D8 61 PUSH2 0x12a1 13DB 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13D4 stack[0] = 0x13dc // @13D7 stack[1] = stack[-3] // } // Block ends with call to 0x12a1, returns to 0x13DC label_13DC: // Incoming return from call to 0x12A1 at 0x13DB // Inputs[3] // { // @13DD stack[-3] // @13DD stack[-1] // @13E4 stack[-4] // } 13DC 5B JUMPDEST 13DD 91 SWAP2 13DE 50 POP 13DF 61 PUSH2 0x13ea 13E2 60 PUSH1 0x20 13E4 84 DUP5 13E5 01 ADD 13E6 61 PUSH2 0x12a1 13E9 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @13DD stack[-3] = stack[-1] // @13DF stack[-1] = 0x13ea // @13E5 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x12a1, returns to 0x13EA label_13EA: // Incoming return from call to 0x12A1 at 0x13E9 // Inputs[6] // { // @13EB stack[-1] // @13EB stack[-2] // @13ED stack[-5] // @13EF stack[-6] // @13EF stack[-3] // @13F0 stack[-4] // } 13EA 5B JUMPDEST 13EB 90 SWAP1 13EC 50 POP 13ED 92 SWAP3 13EE 50 POP 13EF 92 SWAP3 13F0 90 SWAP1 13F1 50 POP 13F2 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @13ED stack[-5] = stack[-1] // @13EF stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_13F3: // Incoming jump from 0x01D3 // Inputs[2] // { // @13FE stack[-1] // @13FF stack[-2] // } 13F3 5B JUMPDEST 13F4 60 PUSH1 0x00 13F6 80 DUP1 13F7 60 PUSH1 0x00 13F9 80 DUP1 13FA 60 PUSH1 0x00 13FC 60 PUSH1 0xa0 13FE 86 DUP7 13FF 88 DUP9 1400 03 SUB 1401 12 SLT 1402 15 ISZERO 1403 61 PUSH2 0x140a 1406 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @13F4 stack[0] = 0x00 // @13F6 stack[1] = 0x00 // @13F7 stack[2] = 0x00 // @13F9 stack[3] = 0x00 // @13FA stack[4] = 0x00 // } // Block ends with conditional jump to 0x140a, if !(stack[-2] - stack[-1] i< 0xa0) label_1407: // Incoming jump from 0x1406, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @1407 stack[-1] // @1409 memory[stack[-1]:stack[-1] + stack[-1]] // } 1407 80 DUP1 1408 81 DUP2 1409 FD *REVERT // Stack delta = +0 // Outputs[1] { @1409 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_140A: // Incoming jump from 0x1406, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @140E stack[-6] } 140A 5B JUMPDEST 140B 61 PUSH2 0x1413 140E 86 DUP7 140F 61 PUSH2 0x12a1 1412 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @140B stack[0] = 0x1413 // @140E stack[1] = stack[-6] // } // Block ends with call to 0x12a1, returns to 0x1413 label_1413: // Incoming return from call to 0x12A1 at 0x1412 // Inputs[3] // { // @1414 stack[-6] // @1414 stack[-1] // @141B stack[-7] // } 1413 5B JUMPDEST 1414 94 SWAP5 1415 50 POP 1416 61 PUSH2 0x1421 1419 60 PUSH1 0x20 141B 87 DUP8 141C 01 ADD 141D 61 PUSH2 0x12a1 1420 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1414 stack[-6] = stack[-1] // @1416 stack[-1] = 0x1421 // @141C stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x12a1, returns to 0x1421 label_1421: // Incoming return from call to 0x12A1 at 0x1420 // Inputs[4] // { // @1422 stack[-1] // @1422 stack[-5] // @1426 stack[-7] // @1428 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 1421 5B JUMPDEST 1422 93 SWAP4 1423 50 POP 1424 60 PUSH1 0x40 1426 86 DUP7 1427 01 ADD 1428 35 CALLDATALOAD 1429 67 PUSH8 0xffffffffffffffff 1432 80 DUP1 1433 82 DUP3 1434 11 GT 1435 15 ISZERO 1436 61 PUSH2 0x143d 1439 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1422 stack[-5] = stack[-1] // @1428 stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @1429 stack[0] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x143d, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) label_143A: // Incoming jump from 0x1439, if not !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @143A stack[-3] // @143C memory[stack[-3]:stack[-3] + stack[-3]] // } 143A 82 DUP3 143B 83 DUP4 143C FD *REVERT // Stack delta = +0 // Outputs[1] { @143C revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_143D: // Incoming jump from 0x1439, if !(msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @1441 stack[-9] // @1442 stack[-2] // @1443 stack[-8] // } 143D 5B JUMPDEST 143E 61 PUSH2 0x1449 1441 89 DUP10 1442 83 DUP4 1443 8A DUP11 1444 01 ADD 1445 61 PUSH2 0x12bd 1448 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @143E stack[0] = 0x1449 // @1441 stack[1] = stack[-9] // @1444 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x12bd, returns to 0x1449 label_1449: // Incoming return from call to 0x12BD at 0x1448 // Inputs[6] // { // @144A stack[-6] // @144A stack[-1] // @144E stack[-9] // @1450 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @1451 stack[-3] // @1453 stack[-2] // } 1449 5B JUMPDEST 144A 94 SWAP5 144B 50 POP 144C 60 PUSH1 0x60 144E 88 DUP9 144F 01 ADD 1450 35 CALLDATALOAD 1451 91 SWAP2 1452 50 POP 1453 80 DUP1 1454 82 DUP3 1455 11 GT 1456 15 ISZERO 1457 61 PUSH2 0x145e 145A 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @144A stack[-6] = stack[-1] // @1451 stack[-3] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x145e, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) label_145B: // Incoming jump from 0x145A, if not !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[2] // { // @145B stack[-3] // @145D memory[stack[-3]:stack[-3] + stack[-3]] // } 145B 82 DUP3 145C 83 DUP4 145D FD *REVERT // Stack delta = +0 // Outputs[1] { @145D revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_145E: // Incoming jump from 0x145A, if !(msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] > stack[-2]) // Inputs[3] // { // @1462 stack[-9] // @1463 stack[-2] // @1464 stack[-8] // } 145E 5B JUMPDEST 145F 61 PUSH2 0x146a 1462 89 DUP10 1463 83 DUP4 1464 8A DUP11 1465 01 ADD 1466 61 PUSH2 0x12bd 1469 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @145F stack[0] = 0x146a // @1462 stack[1] = stack[-9] // @1465 stack[2] = stack[-8] + stack[-2] // } // Block ends with call to 0x12bd, returns to 0x146A label_146A: // Incoming return from call to 0x12BD at 0x1469 // Inputs[6] // { // @146B stack[-1] // @146B stack[-5] // @146F stack[-9] // @1471 msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // @1472 stack[-3] // @1474 stack[-2] // } 146A 5B JUMPDEST 146B 93 SWAP4 146C 50 POP 146D 60 PUSH1 0x80 146F 88 DUP9 1470 01 ADD 1471 35 CALLDATALOAD 1472 91 SWAP2 1473 50 POP 1474 80 DUP1 1475 82 DUP3 1476 11 GT 1477 15 ISZERO 1478 61 PUSH2 0x147f 147B 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @146B stack[-5] = stack[-1] // @1472 stack[-3] = msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x147f, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) label_147C: // Incoming jump from 0x147B, if not !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[2] // { // @147C stack[-3] // @147E memory[stack[-3]:stack[-3] + stack[-3]] // } 147C 82 DUP3 147D 83 DUP4 147E FD *REVERT // Stack delta = +0 // Outputs[1] { @147E revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_147F: // Incoming jump from 0x147B, if !(msg.data[stack[-9] + 0x80:stack[-9] + 0x80 + 0x20] > stack[-2]) // Inputs[3] // { // @1484 stack[-9] // @1485 stack[-2] // @1486 stack[-8] // } 147F 5B JUMPDEST 1480 50 POP 1481 61 PUSH2 0x148c 1484 88 DUP9 1485 82 DUP3 1486 89 DUP10 1487 01 ADD 1488 61 PUSH2 0x1331 148B 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1481 stack[-1] = 0x148c // @1484 stack[0] = stack[-9] // @1487 stack[1] = stack[-8] + stack[-2] // } // Block ends with call to 0x1331, returns to 0x148C label_148C: // Incoming return from call to 0x1331 at 0x148B // Incoming return from call to 0x1331 at 0x14FB // Inputs[9] // { // @148D stack[-1] // @148D stack[-3] // @1490 stack[-6] // @1491 stack[-9] // @1493 stack[-7] // @1493 stack[-4] // @1494 stack[-10] // @1495 stack[-5] // @1496 stack[-8] // } 148C 5B JUMPDEST 148D 91 SWAP2 148E 50 POP 148F 50 POP 1490 92 SWAP3 1491 95 SWAP6 1492 50 POP 1493 92 SWAP3 1494 95 SWAP6 1495 90 SWAP1 1496 93 SWAP4 1497 50 POP 1498 56 *JUMP // Stack delta = -5 // Outputs[5] // { // @1490 stack[-6] = stack[-1] // @1491 stack[-9] = stack[-6] // @1493 stack[-7] = stack[-4] // @1494 stack[-10] = stack[-7] // @1496 stack[-8] = stack[-5] // } // Block ends with unconditional jump to stack[-10] label_1499: // Incoming call from 0x029C, returns to 0x029D // Inputs[2] // { // @14A4 stack[-1] // @14A5 stack[-2] // } 1499 5B JUMPDEST 149A 60 PUSH1 0x00 149C 80 DUP1 149D 60 PUSH1 0x00 149F 80 DUP1 14A0 60 PUSH1 0x00 14A2 60 PUSH1 0xa0 14A4 86 DUP7 14A5 88 DUP9 14A6 03 SUB 14A7 12 SLT 14A8 15 ISZERO 14A9 61 PUSH2 0x14b0 14AC 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @149A stack[0] = 0x00 // @149C stack[1] = 0x00 // @149D stack[2] = 0x00 // @149F stack[3] = 0x00 // @14A0 stack[4] = 0x00 // } // Block ends with conditional jump to 0x14b0, if !(stack[-2] - stack[-1] i< 0xa0) label_14AD: // Incoming jump from 0x14AC, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @14AD stack[-1] // @14AF memory[stack[-1]:stack[-1] + stack[-1]] // } 14AD 80 DUP1 14AE 81 DUP2 14AF FD *REVERT // Stack delta = +0 // Outputs[1] { @14AF revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_14B0: // Incoming jump from 0x14AC, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @14B4 stack[-6] } 14B0 5B JUMPDEST 14B1 61 PUSH2 0x14b9 14B4 86 DUP7 14B5 61 PUSH2 0x12a1 14B8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14B1 stack[0] = 0x14b9 // @14B4 stack[1] = stack[-6] // } // Block ends with call to 0x12a1, returns to 0x14B9 label_14B9: // Incoming return from call to 0x12A1 at 0x14B8 // Inputs[3] // { // @14BA stack[-6] // @14BA stack[-1] // @14C1 stack[-7] // } 14B9 5B JUMPDEST 14BA 94 SWAP5 14BB 50 POP 14BC 61 PUSH2 0x14c7 14BF 60 PUSH1 0x20 14C1 87 DUP8 14C2 01 ADD 14C3 61 PUSH2 0x12a1 14C6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @14BA stack[-6] = stack[-1] // @14BC stack[-1] = 0x14c7 // @14C2 stack[0] = stack[-7] + 0x20 // } // Block ends with call to 0x12a1, returns to 0x14C7 label_14C7: // Incoming return from call to 0x12A1 at 0x14C6 // Inputs[8] // { // @14C8 stack[-5] // @14C8 stack[-1] // @14CC stack[-7] // @14CE msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @14CF stack[-4] // @14D5 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @14D6 stack[-3] // @14DC msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 14C7 5B JUMPDEST 14C8 93 SWAP4 14C9 50 POP 14CA 60 PUSH1 0x40 14CC 86 DUP7 14CD 01 ADD 14CE 35 CALLDATALOAD 14CF 92 SWAP3 14D0 50 POP 14D1 60 PUSH1 0x60 14D3 86 DUP7 14D4 01 ADD 14D5 35 CALLDATALOAD 14D6 91 SWAP2 14D7 50 POP 14D8 60 PUSH1 0x80 14DA 86 DUP7 14DB 01 ADD 14DC 35 CALLDATALOAD 14DD 67 PUSH8 0xffffffffffffffff 14E6 81 DUP2 14E7 11 GT 14E8 15 ISZERO 14E9 61 PUSH2 0x14f0 14EC 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @14C8 stack[-5] = stack[-1] // @14CF stack[-4] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @14D6 stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @14DC stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with conditional jump to 0x14f0, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) label_14ED: // Incoming jump from 0x14EC, if not !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @14ED stack[-2] // @14EF memory[stack[-2]:stack[-2] + stack[-2]] // } 14ED 81 DUP2 14EE 82 DUP3 14EF FD *REVERT // Stack delta = +0 // Outputs[1] { @14EF revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_14F0: // Incoming jump from 0x14EC, if !(msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @14F4 stack[-8] // @14F5 stack[-1] // @14F6 stack[-7] // } 14F0 5B JUMPDEST 14F1 61 PUSH2 0x148c 14F4 88 DUP9 14F5 82 DUP3 14F6 89 DUP10 14F7 01 ADD 14F8 61 PUSH2 0x1331 14FB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @14F1 stack[0] = 0x148c // @14F4 stack[1] = stack[-8] // @14F7 stack[2] = stack[-7] + stack[-1] // } // Block ends with call to 0x1331, returns to 0x148C label_14FC: // Incoming call from 0x0231, returns to 0x0232 // Inputs[2] // { // @1502 stack[-1] // @1503 stack[-2] // } 14FC 5B JUMPDEST 14FD 60 PUSH1 0x00 14FF 80 DUP1 1500 60 PUSH1 0x40 1502 83 DUP4 1503 85 DUP6 1504 03 SUB 1505 12 SLT 1506 15 ISZERO 1507 61 PUSH2 0x150e 150A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @14FD stack[0] = 0x00 // @14FF stack[1] = 0x00 // } // Block ends with conditional jump to 0x150e, if !(stack[-2] - stack[-1] i< 0x40) label_150B: // Incoming jump from 0x150A, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @150B stack[-2] // @150D memory[stack[-2]:stack[-2] + stack[-2]] // } 150B 81 DUP2 150C 82 DUP3 150D FD *REVERT // Stack delta = +0 // Outputs[1] { @150D revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_150E: // Incoming jump from 0x150A, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1512 stack[-3] } 150E 5B JUMPDEST 150F 61 PUSH2 0x1517 1512 83 DUP4 1513 61 PUSH2 0x12a1 1516 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @150F stack[0] = 0x1517 // @1512 stack[1] = stack[-3] // } // Block ends with call to 0x12a1, returns to 0x1517 label_1517: // Incoming return from call to 0x12A1 at 0x1516 // Inputs[4] // { // @1518 stack[-1] // @1518 stack[-3] // @151C stack[-4] // @151E msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1517 5B JUMPDEST 1518 91 SWAP2 1519 50 POP 151A 60 PUSH1 0x20 151C 83 DUP4 151D 01 ADD 151E 35 CALLDATALOAD 151F 80 DUP1 1520 15 ISZERO 1521 15 ISZERO 1522 81 DUP2 1523 14 EQ 1524 61 PUSH2 0x152b 1527 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1518 stack[-3] = stack[-1] // @151E stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x152b, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_1528: // Incoming jump from 0x1527, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @1528 stack[-2] // @152A memory[stack[-2]:stack[-2] + stack[-2]] // } 1528 81 DUP2 1529 82 DUP3 152A FD *REVERT // Stack delta = +0 // Outputs[1] { @152A revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_152B: // Incoming jump from 0x1527, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @152C stack[-1] // @152D stack[-2] // @1530 stack[-5] // @1532 stack[-3] // @1532 stack[-6] // @1533 stack[-4] // } 152B 5B JUMPDEST 152C 80 DUP1 152D 91 SWAP2 152E 50 POP 152F 50 POP 1530 92 SWAP3 1531 50 POP 1532 92 SWAP3 1533 90 SWAP1 1534 50 POP 1535 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1530 stack[-5] = stack[-1] // @1532 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1536: // Incoming call from 0x0127, returns to 0x0128 // Inputs[2] // { // @153C stack[-1] // @153D stack[-2] // } 1536 5B JUMPDEST 1537 60 PUSH1 0x00 1539 80 DUP1 153A 60 PUSH1 0x40 153C 83 DUP4 153D 85 DUP6 153E 03 SUB 153F 12 SLT 1540 15 ISZERO 1541 61 PUSH2 0x1548 1544 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1537 stack[0] = 0x00 // @1539 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1548, if !(stack[-2] - stack[-1] i< 0x40) label_1545: // Incoming jump from 0x1544, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1545 stack[-2] // @1547 memory[stack[-2]:stack[-2] + stack[-2]] // } 1545 81 DUP2 1546 82 DUP3 1547 FD *REVERT // Stack delta = +0 // Outputs[1] { @1547 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1548: // Incoming jump from 0x1544, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @154C stack[-3] } 1548 5B JUMPDEST 1549 61 PUSH2 0x1551 154C 83 DUP4 154D 61 PUSH2 0x12a1 1550 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1549 stack[0] = 0x1551 // @154C stack[1] = stack[-3] // } // Block ends with call to 0x12a1, returns to 0x1551 label_1551: // Incoming return from call to 0x12A1 at 0x1550 // Inputs[5] // { // @1552 stack[-1] // @1552 stack[-6] // @1555 stack[-4] // @1559 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @155A stack[-5] // } 1551 5B JUMPDEST 1552 94 SWAP5 1553 60 PUSH1 0x20 1555 93 SWAP4 1556 90 SWAP1 1557 93 SWAP4 1558 01 ADD 1559 35 CALLDATALOAD 155A 93 SWAP4 155B 50 POP 155C 50 POP 155D 50 POP 155E 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1552 stack[-6] = stack[-1] // @155A stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_155F: // Incoming call from 0x01AD, returns to 0x01AE // Inputs[2] // { // @1567 stack[-1] // @1568 stack[-2] // } 155F 5B JUMPDEST 1560 60 PUSH1 0x00 1562 80 DUP1 1563 60 PUSH1 0x00 1565 60 PUSH1 0x60 1567 84 DUP5 1568 86 DUP7 1569 03 SUB 156A 12 SLT 156B 15 ISZERO 156C 61 PUSH2 0x1573 156F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1560 stack[0] = 0x00 // @1562 stack[1] = 0x00 // @1563 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1573, if !(stack[-2] - stack[-1] i< 0x60) label_1570: // Incoming jump from 0x156F, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @1570 stack[-3] // @1572 memory[stack[-3]:stack[-3] + stack[-3]] // } 1570 82 DUP3 1571 83 DUP4 1572 FD *REVERT // Stack delta = +0 // Outputs[1] { @1572 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1573: // Incoming jump from 0x156F, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1577 stack[-4] } 1573 5B JUMPDEST 1574 61 PUSH2 0x157c 1577 84 DUP5 1578 61 PUSH2 0x12a1 157B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1574 stack[0] = 0x157c // @1577 stack[1] = stack[-4] // } // Block ends with call to 0x12a1, returns to 0x157C label_157C: // Incoming return from call to 0x12A1 at 0x157B // Inputs[7] // { // @157D stack[-7] // @157D stack[-1] // @1580 stack[-5] // @1582 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @1583 stack[-6] // @158A msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @158C stack[-4] // } 157C 5B JUMPDEST 157D 95 SWAP6 157E 60 PUSH1 0x20 1580 85 DUP6 1581 01 ADD 1582 35 CALLDATALOAD 1583 95 SWAP6 1584 50 POP 1585 60 PUSH1 0x40 1587 90 SWAP1 1588 94 SWAP5 1589 01 ADD 158A 35 CALLDATALOAD 158B 93 SWAP4 158C 92 SWAP3 158D 50 POP 158E 50 POP 158F 50 POP 1590 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @157D stack[-7] = stack[-1] // @1583 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @158B stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_1591: // Incoming jump from 0x01E6 // Inputs[2] // { // @1597 stack[-1] // @1598 stack[-2] // } 1591 5B JUMPDEST 1592 60 PUSH1 0x00 1594 80 DUP1 1595 60 PUSH1 0x40 1597 83 DUP4 1598 85 DUP6 1599 03 SUB 159A 12 SLT 159B 15 ISZERO 159C 61 PUSH2 0x15a3 159F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1592 stack[0] = 0x00 // @1594 stack[1] = 0x00 // } // Block ends with conditional jump to 0x15a3, if !(stack[-2] - stack[-1] i< 0x40) label_15A0: // Incoming jump from 0x159F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @15A0 stack[-2] // @15A2 memory[stack[-2]:stack[-2] + stack[-2]] // } 15A0 81 DUP2 15A1 82 DUP3 15A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @15A2 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_15A3: // Incoming jump from 0x159F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @15A4 stack[-3] // @15A5 msg.data[stack[-3]:stack[-3] + 0x20] // } 15A3 5B JUMPDEST 15A4 82 DUP3 15A5 35 CALLDATALOAD 15A6 67 PUSH8 0xffffffffffffffff 15AF 80 DUP1 15B0 82 DUP3 15B1 11 GT 15B2 15 ISZERO 15B3 61 PUSH2 0x15ba 15B6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @15A5 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @15A6 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x15ba, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_15B7: // Incoming jump from 0x15B6, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @15B7 stack[-4] // @15B9 memory[stack[-4]:stack[-4] + stack[-4]] // } 15B7 83 DUP4 15B8 84 DUP5 15B9 FD *REVERT // Stack delta = +0 // Outputs[1] { @15B9 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_15BA: // Incoming jump from 0x15B6, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @15BB stack[-2] // @15BC stack[-5] // @15C0 stack[-6] // } 15BA 5B JUMPDEST 15BB 81 DUP2 15BC 85 DUP6 15BD 01 ADD 15BE 91 SWAP2 15BF 50 POP 15C0 85 DUP6 15C1 60 PUSH1 0x1f 15C3 83 DUP4 15C4 01 ADD 15C5 12 SLT 15C6 61 PUSH2 0x15cd 15C9 57 *JUMPI // Stack delta = +0 // Outputs[1] { @15BE stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x15cd, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_15CA: // Incoming jump from 0x15C9, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @15CA stack[-4] // @15CC memory[stack[-4]:stack[-4] + stack[-4]] // } 15CA 83 DUP4 15CB 84 DUP5 15CC FD *REVERT // Stack delta = +0 // Outputs[1] { @15CC revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_15CD: // Incoming jump from 0x15C9, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @15CE stack[-2] // @15CF msg.data[stack[-2]:stack[-2] + 0x20] // } 15CD 5B JUMPDEST 15CE 81 DUP2 15CF 35 CALLDATALOAD 15D0 60 PUSH1 0x20 15D2 61 PUSH2 0x15da 15D5 82 DUP3 15D6 61 PUSH2 0x19d4 15D9 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15CF stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @15D0 stack[1] = 0x20 // @15D2 stack[2] = 0x15da // @15D5 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x19d4, returns to 0x15DA label_15DA: // Incoming return from call to 0x19D4 at 0x15D9 // Inputs[2] // { // @15DD memory[0x40:0x60] // @15E1 stack[-1] // } 15DA 5B JUMPDEST 15DB 60 PUSH1 0x40 15DD 51 MLOAD 15DE 61 PUSH2 0x15e7 15E1 82 DUP3 15E2 82 DUP3 15E3 61 PUSH2 0x1a4b 15E6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @15DD stack[0] = memory[0x40:0x60] // @15DE stack[1] = 0x15e7 // @15E1 stack[2] = stack[-1] // @15E2 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x1a4b, returns to 0x15E7 label_15E7: // Incoming return from call to 0x1A4B at 0x15E6 // Inputs[6] // { // @15E8 stack[-4] // @15E9 stack[-1] // @15EB stack[-3] // @15EE stack[-2] // @15F0 stack[-6] // @15FC stack[-10] // } 15E7 5B JUMPDEST 15E8 83 DUP4 15E9 81 DUP2 15EA 52 MSTORE 15EB 82 DUP3 15EC 81 DUP2 15ED 01 ADD 15EE 91 SWAP2 15EF 50 POP 15F0 85 DUP6 15F1 83 DUP4 15F2 01 ADD 15F3 60 PUSH1 0x05 15F5 85 DUP6 15F6 90 SWAP1 15F7 1B SHL 15F8 87 DUP8 15F9 01 ADD 15FA 84 DUP5 15FB 01 ADD 15FC 8B DUP12 15FD 10 LT 15FE 15 ISZERO 15FF 61 PUSH2 0x1606 1602 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @15EA memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @15EE stack[-2] = stack[-1] + stack[-3] // @15F2 stack[0] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x1606, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) label_1603: // Incoming jump from 0x1602, if not !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[2] // { // @1603 stack[-9] // @1605 memory[stack[-9]:stack[-9] + stack[-9]] // } 1603 88 DUP9 1604 89 DUP10 1605 FD *REVERT // Stack delta = +0 // Outputs[1] { @1605 revert(memory[stack[-9]:stack[-9] + stack[-9]]); } // Block terminates label_1606: // Incoming jump from 0x1602, if !(stack[-10] < stack[-3] + stack[-6] + (stack[-4] << 0x05)) // Inputs[3] // { // @1607 stack[-9] // @1608 stack[-7] // @160B stack[-5] // } 1606 5B JUMPDEST 1607 88 DUP9 1608 96 SWAP7 1609 50 POP 160A 5B JUMPDEST 160B 84 DUP5 160C 87 DUP8 160D 10 LT 160E 15 ISZERO 160F 61 PUSH2 0x162f 1612 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1608 stack[-7] = stack[-9] } // Block ends with conditional jump to 0x162f, if !(stack[-9] < stack[-5]) label_1613: // Incoming jump from 0x1612, if not !(stack[-9] < stack[-5]) // Incoming jump from 0x1612, if not !(stack[-7] < stack[-5]) // Inputs[1] { @1616 stack[-1] } 1613 61 PUSH2 0x161b 1616 81 DUP2 1617 61 PUSH2 0x12a1 161A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1613 stack[0] = 0x161b // @1616 stack[1] = stack[-1] // } // Block ends with call to 0x12a1, returns to 0x161B label_161B: // Incoming return from call to 0x12A1 at 0x161A // Inputs[5] // { // @161C stack[-4] // @161D stack[-1] // @1620 stack[-8] // @1621 stack[-2] // @1626 stack[-5] // } 161B 5B JUMPDEST 161C 83 DUP4 161D 52 MSTORE 161E 60 PUSH1 0x01 1620 96 SWAP7 1621 90 SWAP1 1622 96 SWAP7 1623 01 ADD 1624 95 SWAP6 1625 91 SWAP2 1626 83 DUP4 1627 01 ADD 1628 91 SWAP2 1629 83 DUP4 162A 01 ADD 162B 61 PUSH2 0x160a 162E 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @161D memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @1624 stack[-8] = 0x01 + stack[-8] // @1628 stack[-4] = stack[-5] + stack[-4] // @162A stack[-2] = stack[-5] + stack[-2] // } // Block ends with unconditional jump to 0x160a label_162F: // Incoming jump from 0x1612, if !(stack[-9] < stack[-5]) // Incoming jump from 0x1612, if !(stack[-7] < stack[-5]) // Inputs[7] // { // @1631 stack[-9] // @1631 stack[-2] // @1634 stack[-10] // @1635 stack[-4] // @1636 msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // @1637 stack[-7] // @163A stack[-6] // } 162F 5B JUMPDEST 1630 50 POP 1631 96 SWAP7 1632 50 POP 1633 50 POP 1634 86 DUP7 1635 01 ADD 1636 35 CALLDATALOAD 1637 92 SWAP3 1638 50 POP 1639 50 POP 163A 80 DUP1 163B 82 DUP3 163C 11 GT 163D 15 ISZERO 163E 61 PUSH2 0x1645 1641 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1631 stack[-9] = stack[-2] // @1637 stack[-7] = msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] // } // Block ends with conditional jump to 0x1645, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) label_1642: // Incoming jump from 0x1641, if not !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[2] // { // @1642 stack[-3] // @1644 memory[stack[-3]:stack[-3] + stack[-3]] // } 1642 82 DUP3 1643 83 DUP4 1644 FD *REVERT // Stack delta = +0 // Outputs[1] { @1644 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_1645: // Incoming jump from 0x1641, if !(msg.data[stack[-10] + stack[-4]:stack[-10] + stack[-4] + 0x20] > stack[-6]) // Inputs[3] // { // @164A stack[-6] // @164B stack[-2] // @164C stack[-5] // } 1645 5B JUMPDEST 1646 50 POP 1647 61 PUSH2 0x1652 164A 85 DUP6 164B 82 DUP3 164C 86 DUP7 164D 01 ADD 164E 61 PUSH2 0x12bd 1651 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1647 stack[-1] = 0x1652 // @164A stack[0] = stack[-6] // @164D stack[1] = stack[-5] + stack[-2] // } // Block ends with call to 0x12bd, returns to 0x1652 label_1652: // Incoming return from call to 0x1331 at 0x1721 // Incoming return from call to 0x12BD at 0x1651 // Inputs[6] // { // @1653 stack[-3] // @1653 stack[-1] // @1656 stack[-6] // @1658 stack[-4] // @1658 stack[-7] // @1659 stack[-5] // } 1652 5B JUMPDEST 1653 91 SWAP2 1654 50 POP 1655 50 POP 1656 92 SWAP3 1657 50 POP 1658 92 SWAP3 1659 90 SWAP1 165A 50 POP 165B 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1656 stack[-6] = stack[-1] // @1658 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_165C: // Incoming call from 0x014D, returns to 0x014E // Inputs[2] // { // @1661 stack[-1] // @1662 stack[-2] // } 165C 5B JUMPDEST 165D 60 PUSH1 0x00 165F 60 PUSH1 0x20 1661 82 DUP3 1662 84 DUP5 1663 03 SUB 1664 12 SLT 1665 15 ISZERO 1666 61 PUSH2 0x166d 1669 57 *JUMPI // Stack delta = +1 // Outputs[1] { @165D stack[0] = 0x00 } // Block ends with conditional jump to 0x166d, if !(stack[-2] - stack[-1] i< 0x20) label_166A: // Incoming jump from 0x1669, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @166A stack[-1] // @166C memory[stack[-1]:stack[-1] + stack[-1]] // } 166A 80 DUP1 166B 81 DUP2 166C FD *REVERT // Stack delta = +0 // Outputs[1] { @166C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_166D: // Incoming jump from 0x1669, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @166E stack[-2] // @166F msg.data[stack[-2]:stack[-2] + 0x20] // } 166D 5B JUMPDEST 166E 81 DUP2 166F 35 CALLDATALOAD 1670 61 PUSH2 0x13ba 1673 81 DUP2 1674 61 PUSH2 0x1b61 1677 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @166F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1670 stack[1] = 0x13ba // @1673 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1b61, returns to 0x13BA label_1678: // Incoming jump from 0x105D // Inputs[2] // { // @167D stack[-1] // @167E stack[-2] // } 1678 5B JUMPDEST 1679 60 PUSH1 0x00 167B 60 PUSH1 0x20 167D 82 DUP3 167E 84 DUP5 167F 03 SUB 1680 12 SLT 1681 15 ISZERO 1682 61 PUSH2 0x1689 1685 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1679 stack[0] = 0x00 } // Block ends with conditional jump to 0x1689, if !(stack[-2] - stack[-1] i< 0x20) label_1686: // Incoming jump from 0x1685, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1686 stack[-1] // @1688 memory[stack[-1]:stack[-1] + stack[-1]] // } 1686 80 DUP1 1687 81 DUP2 1688 FD *REVERT // Stack delta = +0 // Outputs[1] { @1688 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_1689: // Incoming jump from 0x1685, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @168A stack[-2] // @168B memory[stack[-2]:stack[-2] + 0x20] // } 1689 5B JUMPDEST 168A 81 DUP2 168B 51 MLOAD 168C 61 PUSH2 0x13ba 168F 81 DUP2 1690 61 PUSH2 0x1b61 1693 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @168B stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @168C stack[1] = 0x13ba // @168F stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1b61, returns to 0x13BA label_1694: // Incoming call from 0x0198, returns to 0x0199 // Inputs[2] // { // @1699 stack[-1] // @169A stack[-2] // } 1694 5B JUMPDEST 1695 60 PUSH1 0x00 1697 60 PUSH1 0x20 1699 82 DUP3 169A 84 DUP5 169B 03 SUB 169C 12 SLT 169D 15 ISZERO 169E 61 PUSH2 0x16a5 16A1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1695 stack[0] = 0x00 } // Block ends with conditional jump to 0x16a5, if !(stack[-2] - stack[-1] i< 0x20) label_16A2: // Incoming jump from 0x16A1, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @16A2 stack[-1] // @16A4 memory[stack[-1]:stack[-1] + stack[-1]] // } 16A2 80 DUP1 16A3 81 DUP2 16A4 FD *REVERT // Stack delta = +0 // Outputs[1] { @16A4 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_16A5: // Incoming jump from 0x16A1, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @16A6 stack[-2] // @16A7 msg.data[stack[-2]:stack[-2] + 0x20] // } 16A5 5B JUMPDEST 16A6 81 DUP2 16A7 35 CALLDATALOAD 16A8 67 PUSH8 0xffffffffffffffff 16B1 81 DUP2 16B2 11 GT 16B3 15 ISZERO 16B4 61 PUSH2 0x16bb 16B7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16A7 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x16bb, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_16B8: // Incoming jump from 0x16B7, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @16B8 stack[-2] // @16BA memory[stack[-2]:stack[-2] + stack[-2]] // } 16B8 81 DUP2 16B9 82 DUP3 16BA FD *REVERT // Stack delta = +0 // Outputs[1] { @16BA revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_16BB: // Incoming jump from 0x16B7, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @16BF stack[-4] // @16C0 stack[-1] // @16C1 stack[-3] // } 16BB 5B JUMPDEST 16BC 61 PUSH2 0x16c7 16BF 84 DUP5 16C0 82 DUP3 16C1 85 DUP6 16C2 01 ADD 16C3 61 PUSH2 0x1331 16C6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @16BC stack[0] = 0x16c7 // @16BF stack[1] = stack[-4] // @16C2 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x1331, returns to 0x16C7 label_16C7: // Incoming return from call to 0x1331 at 0x16C6 // Inputs[3] // { // @16C8 stack[-1] // @16C8 stack[-6] // @16C9 stack[-5] // } 16C7 5B JUMPDEST 16C8 94 SWAP5 16C9 93 SWAP4 16CA 50 POP 16CB 50 POP 16CC 50 POP 16CD 50 POP 16CE 56 *JUMP // Stack delta = -5 // Outputs[1] { @16C8 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_16CF: // Incoming call from 0x024D, returns to 0x024E // Incoming call from 0x0185, returns to 0x0186 // Inputs[2] // { // @16D4 stack[-1] // @16D5 stack[-2] // } 16CF 5B JUMPDEST 16D0 60 PUSH1 0x00 16D2 60 PUSH1 0x20 16D4 82 DUP3 16D5 84 DUP5 16D6 03 SUB 16D7 12 SLT 16D8 15 ISZERO 16D9 61 PUSH2 0x16e0 16DC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16D0 stack[0] = 0x00 } // Block ends with conditional jump to 0x16e0, if !(stack[-2] - stack[-1] i< 0x20) label_16DD: // Incoming jump from 0x16DC, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @16DD stack[-1] // @16DF memory[stack[-1]:stack[-1] + stack[-1]] // } 16DD 80 DUP1 16DE 81 DUP2 16DF FD *REVERT // Stack delta = +0 // Outputs[1] { @16DF revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_16E0: // Incoming jump from 0x16DC, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @16E2 stack[-2] // @16E2 msg.data[stack[-2]:stack[-2] + 0x20] // @16E3 stack[-4] // @16E4 stack[-3] // } 16E0 5B JUMPDEST 16E1 50 POP 16E2 35 CALLDATALOAD 16E3 91 SWAP2 16E4 90 SWAP1 16E5 50 POP 16E6 56 *JUMP // Stack delta = -3 // Outputs[1] { @16E3 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_16E7: // Incoming call from 0x01C0, returns to 0x01C1 // Inputs[2] // { // @16ED stack[-1] // @16EE stack[-2] // } 16E7 5B JUMPDEST 16E8 60 PUSH1 0x00 16EA 80 DUP1 16EB 60 PUSH1 0x40 16ED 83 DUP4 16EE 85 DUP6 16EF 03 SUB 16F0 12 SLT 16F1 15 ISZERO 16F2 61 PUSH2 0x16f9 16F5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @16E8 stack[0] = 0x00 // @16EA stack[1] = 0x00 // } // Block ends with conditional jump to 0x16f9, if !(stack[-2] - stack[-1] i< 0x40) label_16F6: // Incoming jump from 0x16F5, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @16F6 stack[-2] // @16F8 memory[stack[-2]:stack[-2] + stack[-2]] // } 16F6 81 DUP2 16F7 82 DUP3 16F8 FD *REVERT // Stack delta = +0 // Outputs[1] { @16F8 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_16F9: // Incoming jump from 0x16F5, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @16FA stack[-3] // @16FB msg.data[stack[-3]:stack[-3] + 0x20] // @16FC stack[-2] // @1702 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 16F9 5B JUMPDEST 16FA 82 DUP3 16FB 35 CALLDATALOAD 16FC 91 SWAP2 16FD 50 POP 16FE 60 PUSH1 0x20 1700 83 DUP4 1701 01 ADD 1702 35 CALLDATALOAD 1703 67 PUSH8 0xffffffffffffffff 170C 81 DUP2 170D 11 GT 170E 15 ISZERO 170F 61 PUSH2 0x1716 1712 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @16FC stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @1702 stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1716, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) label_1713: // Incoming jump from 0x1712, if not !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @1713 stack[-2] // @1715 memory[stack[-2]:stack[-2] + stack[-2]] // } 1713 81 DUP2 1714 82 DUP3 1715 FD *REVERT // Stack delta = +0 // Outputs[1] { @1715 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_1716: // Incoming jump from 0x1712, if !(msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @171A stack[-5] // @171B stack[-1] // @171C stack[-4] // } 1716 5B JUMPDEST 1717 61 PUSH2 0x1652 171A 85 DUP6 171B 82 DUP3 171C 86 DUP7 171D 01 ADD 171E 61 PUSH2 0x1331 1721 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1717 stack[0] = 0x1652 // @171A stack[1] = stack[-5] // @171D stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x1331, returns to 0x1652 1722 5B JUMPDEST 1723 60 PUSH1 0x00 1725 81 DUP2 1726 51 MLOAD 1727 80 DUP1 1728 84 DUP5 1729 52 MSTORE 172A 60 PUSH1 0x20 172C 80 DUP1 172D 85 DUP6 172E 01 ADD 172F 94 SWAP5 1730 50 POP 1731 80 DUP1 1732 84 DUP5 1733 01 ADD 1734 83 DUP4 1735 5B JUMPDEST 1736 83 DUP4 1737 81 DUP2 1738 10 LT 1739 15 ISZERO 173A 61 PUSH2 0x1751 173D 57 *JUMPI 173E 81 DUP2 173F 51 MLOAD 1740 87 DUP8 1741 52 MSTORE 1742 95 SWAP6 1743 82 DUP3 1744 01 ADD 1745 95 SWAP6 1746 90 SWAP1 1747 82 DUP3 1748 01 ADD 1749 90 SWAP1 174A 60 PUSH1 0x01 174C 01 ADD 174D 61 PUSH2 0x1735 1750 56 *JUMP 1751 5B JUMPDEST 1752 50 POP 1753 94 SWAP5 1754 95 SWAP6 1755 94 SWAP5 1756 50 POP 1757 50 POP 1758 50 POP 1759 50 POP 175A 50 POP 175B 56 *JUMP label_175C: // Incoming call from 0x189D, returns to 0x13BA // Incoming call from 0x183E, returns to 0x183F // Inputs[3] // { // @175F stack[-1] // @1760 memory[stack[-1]:stack[-1] + 0x20] // @1762 stack[-2] // } 175C 5B JUMPDEST 175D 60 PUSH1 0x00 175F 81 DUP2 1760 51 MLOAD 1761 80 DUP1 1762 84 DUP5 1763 52 MSTORE 1764 81 DUP2 1765 5B JUMPDEST 1766 81 DUP2 1767 81 DUP2 1768 10 LT 1769 15 ISZERO 176A 61 PUSH2 0x1781 176D 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @175D stack[0] = 0x00 // @1760 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1763 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1764 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1781, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_176E: // Incoming jump from 0x176D, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x176D, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @1770 stack[-1] // @1771 stack[-4] // @1775 memory[0x20 + stack[-4] + stack[-1]:0x20 + stack[-4] + stack[-1] + 0x20] // @1776 stack[-5] // } 176E 60 PUSH1 0x20 1770 81 DUP2 1771 85 DUP6 1772 01 ADD 1773 81 DUP2 1774 01 ADD 1775 51 MLOAD 1776 86 DUP7 1777 83 DUP4 1778 01 ADD 1779 82 DUP3 177A 01 ADD 177B 52 MSTORE 177C 01 ADD 177D 61 PUSH2 0x1765 1780 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @177B memory[0x20 + stack[-1] + stack[-5]:0x20 + stack[-1] + stack[-5] + 0x20] = memory[0x20 + stack[-4] + stack[-1]:0x20 + stack[-4] + stack[-1] + 0x20] // @177C stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1765 label_1781: // Incoming jump from 0x176D, if !(stack[-1] < stack[-2]) // Incoming jump from 0x176D, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[2] // { // @1782 stack[-2] // @1783 stack[-1] // } 1781 5B JUMPDEST 1782 81 DUP2 1783 81 DUP2 1784 11 GT 1785 15 ISZERO 1786 61 PUSH2 0x1792 1789 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1792, if !(stack[-1] > stack[-2]) label_178A: // Incoming jump from 0x1789, if not !(stack[-1] > stack[-2]) // Inputs[4] // { // @178A stack[-3] // @178D stack[-2] // @178E stack[-5] // @17A2 stack[-6] // } 178A 82 DUP3 178B 60 PUSH1 0x20 178D 83 DUP4 178E 87 DUP8 178F 01 ADD 1790 01 ADD 1791 52 MSTORE 1792 5B JUMPDEST 1793 50 POP 1794 60 PUSH1 0x1f 1796 01 ADD 1797 60 PUSH1 0x1f 1799 19 NOT 179A 16 AND 179B 92 SWAP3 179C 90 SWAP1 179D 92 SWAP3 179E 01 ADD 179F 60 PUSH1 0x20 17A1 01 ADD 17A2 92 SWAP3 17A3 91 SWAP2 17A4 50 POP 17A5 50 POP 17A6 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1791 memory[stack[-5] + stack[-2] + 0x20:stack[-5] + stack[-2] + 0x20 + 0x20] = stack[-3] // @17A2 stack[-6] = 0x20 + (~0x1f & 0x1f + stack[-2]) + stack[-5] // } // Block ends with unconditional jump to stack[-6] 17A7 5B JUMPDEST 17A8 60 PUSH1 0x01 17AA 60 PUSH1 0x01 17AC 60 PUSH1 0xa0 17AE 1B SHL 17AF 03 SUB 17B0 86 DUP7 17B1 81 DUP2 17B2 16 AND 17B3 82 DUP3 17B4 52 MSTORE 17B5 85 DUP6 17B6 16 AND 17B7 60 PUSH1 0x20 17B9 82 DUP3 17BA 01 ADD 17BB 52 MSTORE 17BC 60 PUSH1 0xa0 17BE 60 PUSH1 0x40 17C0 82 DUP3 17C1 01 ADD 17C2 81 DUP2 17C3 90 SWAP1 17C4 52 MSTORE 17C5 60 PUSH1 0x00 17C7 90 SWAP1 17C8 61 PUSH2 0x17d3 17CB 90 SWAP1 17CC 83 DUP4 17CD 01 ADD 17CE 86 DUP7 17CF 61 PUSH2 0x1722 17D2 56 *JUMP 17D3 5B JUMPDEST 17D4 82 DUP3 17D5 81 DUP2 17D6 03 SUB 17D7 60 PUSH1 0x60 17D9 84 DUP5 17DA 01 ADD 17DB 52 MSTORE 17DC 61 PUSH2 0x17e5 17DF 81 DUP2 17E0 86 DUP7 17E1 61 PUSH2 0x1722 17E4 56 *JUMP 17E5 5B JUMPDEST 17E6 90 SWAP1 17E7 50 POP 17E8 82 DUP3 17E9 81 DUP2 17EA 03 SUB 17EB 60 PUSH1 0x80 17ED 84 DUP5 17EE 01 ADD 17EF 52 MSTORE 17F0 61 PUSH2 0x17f9 17F3 81 DUP2 17F4 85 DUP6 17F5 61 PUSH2 0x175c 17F8 56 *JUMP 17F9 5B JUMPDEST 17FA 98 SWAP9 17FB 97 SWAP8 17FC 50 POP 17FD 50 POP 17FE 50 POP 17FF 50 POP 1800 50 POP 1801 50 POP 1802 50 POP 1803 50 POP 1804 56 *JUMP label_1805: // Incoming call from 0x1016, returns to 0x1017 // Inputs[6] // { // @180E stack[-6] // @1811 stack[-1] // @1813 stack[-5] // @181E stack[-4] // @1825 stack[-3] // @183A stack[-2] // } 1805 5B JUMPDEST 1806 60 PUSH1 0x01 1808 60 PUSH1 0x01 180A 60 PUSH1 0xa0 180C 1B SHL 180D 03 SUB 180E 86 DUP7 180F 81 DUP2 1810 16 AND 1811 82 DUP3 1812 52 MSTORE 1813 85 DUP6 1814 16 AND 1815 60 PUSH1 0x20 1817 82 DUP3 1818 01 ADD 1819 52 MSTORE 181A 60 PUSH1 0x40 181C 81 DUP2 181D 01 ADD 181E 84 DUP5 181F 90 SWAP1 1820 52 MSTORE 1821 60 PUSH1 0x60 1823 81 DUP2 1824 01 ADD 1825 83 DUP4 1826 90 SWAP1 1827 52 MSTORE 1828 60 PUSH1 0xa0 182A 60 PUSH1 0x80 182C 82 DUP3 182D 01 ADD 182E 81 DUP2 182F 90 SWAP1 1830 52 MSTORE 1831 60 PUSH1 0x00 1833 90 SWAP1 1834 61 PUSH2 0x183f 1837 90 SWAP1 1838 83 DUP4 1839 01 ADD 183A 84 DUP5 183B 61 PUSH2 0x175c 183E 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1812 memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1819 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1820 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-4] // @1827 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = stack[-3] // @1830 memory[stack[-1] + 0x80:stack[-1] + 0x80 + 0x20] = 0xa0 // @1833 stack[0] = 0x00 // @1837 stack[1] = 0x183f // @1839 stack[2] = stack[-1] + 0xa0 // @183A stack[3] = stack[-2] // } // Block ends with call to 0x175c, returns to 0x183F label_183F: // Incoming return from call to 0x175C at 0x183E // Inputs[3] // { // @1840 stack[-1] // @1840 stack[-9] // @1841 stack[-8] // } 183F 5B JUMPDEST 1840 97 SWAP8 1841 96 SWAP7 1842 50 POP 1843 50 POP 1844 50 POP 1845 50 POP 1846 50 POP 1847 50 POP 1848 50 POP 1849 56 *JUMP // Stack delta = -8 // Outputs[1] { @1840 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] 184A 5B JUMPDEST 184B 60 PUSH1 0x20 184D 81 DUP2 184E 52 MSTORE 184F 60 PUSH1 0x00 1851 61 PUSH2 0x13ba 1854 60 PUSH1 0x20 1856 83 DUP4 1857 01 ADD 1858 84 DUP5 1859 61 PUSH2 0x1722 185C 56 *JUMP 185D 5B JUMPDEST 185E 60 PUSH1 0x40 1860 81 DUP2 1861 52 MSTORE 1862 60 PUSH1 0x00 1864 61 PUSH2 0x1870 1867 60 PUSH1 0x40 1869 83 DUP4 186A 01 ADD 186B 85 DUP6 186C 61 PUSH2 0x1722 186F 56 *JUMP 1870 5B JUMPDEST 1871 82 DUP3 1872 81 DUP2 1873 03 SUB 1874 60 PUSH1 0x20 1876 84 DUP5 1877 01 ADD 1878 52 MSTORE 1879 61 PUSH2 0x1882 187C 81 DUP2 187D 85 DUP6 187E 61 PUSH2 0x1722 1881 56 *JUMP 1882 5B JUMPDEST 1883 95 SWAP6 1884 94 SWAP5 1885 50 POP 1886 50 POP 1887 50 POP 1888 50 POP 1889 50 POP 188A 56 *JUMP label_188B: // Incoming jump from 0x10A6 // Incoming jump from 0x0177 // Inputs[2] // { // @188E stack[-1] // @1899 stack[-2] // } 188B 5B JUMPDEST 188C 60 PUSH1 0x20 188E 81 DUP2 188F 52 MSTORE 1890 60 PUSH1 0x00 1892 61 PUSH2 0x13ba 1895 60 PUSH1 0x20 1897 83 DUP4 1898 01 ADD 1899 84 DUP5 189A 61 PUSH2 0x175c 189D 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @188F memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1890 stack[0] = 0x00 // @1892 stack[1] = 0x13ba // @1898 stack[2] = stack[-1] + 0x20 // @1899 stack[3] = stack[-2] // } // Block ends with call to 0x175c, returns to 0x13BA label_189E: // Incoming call from 0x113D, returns to 0x031D // Inputs[2] // { // @18A2 stack[-1] // @18E4 stack[-2] // } 189E 5B JUMPDEST 189F 60 PUSH1 0x20 18A1 80 DUP1 18A2 82 DUP3 18A3 52 MSTORE 18A4 60 PUSH1 0x28 18A6 90 SWAP1 18A7 82 DUP3 18A8 01 ADD 18A9 52 MSTORE 18AA 7F PUSH32 0x455243313135353a204552433131353552656365697665722072656a65637465 18CB 60 PUSH1 0x40 18CD 82 DUP3 18CE 01 ADD 18CF 52 MSTORE 18D0 67 PUSH8 0x6420746f6b656e73 18D9 60 PUSH1 0xc0 18DB 1B SHL 18DC 60 PUSH1 0x60 18DE 82 DUP3 18DF 01 ADD 18E0 52 MSTORE 18E1 60 PUSH1 0x80 18E3 01 ADD 18E4 90 SWAP1 18E5 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @18A3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @18A9 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x28 // @18CF memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a204552433131353552656365697665722072656a65637465 // @18E0 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6420746f6b656e73 << 0xc0 // @18E4 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_18E6: // Incoming call from 0x05D9, returns to 0x031D // Incoming call from 0x044E, returns to 0x031D // Incoming call from 0x0644, returns to 0x031D // Inputs[2] // { // @18EA stack[-1] // @190E stack[-2] // } 18E6 5B JUMPDEST 18E7 60 PUSH1 0x20 18E9 80 DUP1 18EA 82 DUP3 18EB 52 MSTORE 18EC 60 PUSH1 0x10 18EE 90 SWAP1 18EF 82 DUP3 18F0 01 ADD 18F1 52 MSTORE 18F2 6F PUSH16 0x125b9d985b1a59081d1bdad95b881a59 1903 60 PUSH1 0x82 1905 1B SHL 1906 60 PUSH1 0x40 1908 82 DUP3 1909 01 ADD 190A 52 MSTORE 190B 60 PUSH1 0x60 190D 01 ADD 190E 90 SWAP1 190F 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @18EB memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @18F1 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x10 // @190A memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x125b9d985b1a59081d1bdad95b881a59 << 0x82 // @190E stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1910: // Incoming call from 0x0E82, returns to 0x031D // Inputs[2] // { // @1914 stack[-1] // @1953 stack[-2] // } 1910 5B JUMPDEST 1911 60 PUSH1 0x20 1913 80 DUP1 1914 82 DUP3 1915 52 MSTORE 1916 60 PUSH1 0x25 1918 90 SWAP1 1919 82 DUP3 191A 01 ADD 191B 52 MSTORE 191C 7F PUSH32 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 193D 60 PUSH1 0x40 193F 82 DUP3 1940 01 ADD 1941 52 MSTORE 1942 64 PUSH5 0x6472657373 1948 60 PUSH1 0xd8 194A 1B SHL 194B 60 PUSH1 0x60 194D 82 DUP3 194E 01 ADD 194F 52 MSTORE 1950 60 PUSH1 0x80 1952 01 ADD 1953 90 SWAP1 1954 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1915 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @191B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x25 // @1941 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a207472616e7366657220746f20746865207a65726f206164 // @194F memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x6472657373 << 0xd8 // @1953 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_1955: // Incoming call from 0x0ED3, returns to 0x031D // Inputs[2] // { // @1959 stack[-1] // @199D stack[-2] // } 1955 5B JUMPDEST 1956 60 PUSH1 0x20 1958 80 DUP1 1959 82 DUP3 195A 52 MSTORE 195B 60 PUSH1 0x2a 195D 90 SWAP1 195E 82 DUP3 195F 01 ADD 1960 52 MSTORE 1961 7F PUSH32 0x455243313135353a20696e73756666696369656e742062616c616e636520666f 1982 60 PUSH1 0x40 1984 82 DUP3 1985 01 ADD 1986 52 MSTORE 1987 69 PUSH10 0x39103a3930b739b332b9 1992 60 PUSH1 0xb1 1994 1B SHL 1995 60 PUSH1 0x60 1997 82 DUP3 1998 01 ADD 1999 52 MSTORE 199A 60 PUSH1 0x80 199C 01 ADD 199D 90 SWAP1 199E 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @195A memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1960 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x2a // @1986 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x455243313135353a20696e73756666696369656e742062616c616e636520666f // @1999 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x39103a3930b739b332b9 << 0xb1 // @199D stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_199F: // Incoming call from 0x09B5, returns to 0x031D // Incoming call from 0x0623, returns to 0x031D // Incoming call from 0x05B8, returns to 0x031D // Incoming call from 0x08C3, returns to 0x031D // Incoming call from 0x0516, returns to 0x031D // Inputs[2] // { // @19A3 stack[-1] // @19D2 stack[-2] // } 199F 5B JUMPDEST 19A0 60 PUSH1 0x20 19A2 80 DUP1 19A3 82 DUP3 19A4 52 MSTORE 19A5 81 DUP2 19A6 81 DUP2 19A7 01 ADD 19A8 52 MSTORE 19A9 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 19CA 60 PUSH1 0x40 19CC 82 DUP3 19CD 01 ADD 19CE 52 MSTORE 19CF 60 PUSH1 0x60 19D1 01 ADD 19D2 90 SWAP1 19D3 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @19A4 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @19A8 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @19CE memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @19D2 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_19D4: // Incoming call from 0x15D9, returns to 0x15DA // Incoming call from 0x12D9, returns to 0x12DA // Inputs[1] { @19E0 stack[-1] } 19D4 5B JUMPDEST 19D5 60 PUSH1 0x00 19D7 67 PUSH8 0xffffffffffffffff 19E0 82 DUP3 19E1 11 GT 19E2 15 ISZERO 19E3 61 PUSH2 0x19ee 19E6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19D5 stack[0] = 0x00 } // Block ends with conditional jump to 0x19ee, if !(stack[-1] > 0xffffffffffffffff) label_19E7: // Incoming jump from 0x19E6, if not !(stack[-1] > 0xffffffffffffffff) 19E7 61 PUSH2 0x19ee 19EA 61 PUSH2 0x1aa9 19ED 56 *JUMP // Stack delta = +1 // Outputs[1] { @19E7 stack[0] = 0x19ee } // Block ends with unconditional jump to 0x1aa9 label_19EE: // Incoming jump from 0x19E6, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @19F2 stack[-2] // @19F6 stack[-3] // } 19EE 5B JUMPDEST 19EF 50 POP 19F0 60 PUSH1 0x05 19F2 1B SHL 19F3 60 PUSH1 0x20 19F5 01 ADD 19F6 90 SWAP1 19F7 56 *JUMP // Stack delta = -2 // Outputs[1] { @19F6 stack[-3] = 0x20 + (stack[-2] << 0x05) } // Block ends with unconditional jump to stack[-3] label_19F8: // Incoming call from 0x0F10, returns to 0x0F11 // Incoming call from 0x0AD0, returns to 0x0AD1 // Inputs[2] // { // @19FB stack[-2] // @19FD stack[-1] // } 19F8 5B JUMPDEST 19F9 60 PUSH1 0x00 19FB 82 DUP3 19FC 19 NOT 19FD 82 DUP3 19FE 11 GT 19FF 15 ISZERO 1A00 61 PUSH2 0x1a0b 1A03 57 *JUMPI // Stack delta = +1 // Outputs[1] { @19F9 stack[0] = 0x00 } // Block ends with conditional jump to 0x1a0b, if !(stack[-1] > ~stack[-2]) label_1A04: // Incoming jump from 0x1A03, if not !(stack[-1] > ~stack[-2]) 1A04 61 PUSH2 0x1a0b 1A07 61 PUSH2 0x1a93 1A0A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A04 stack[0] = 0x1a0b } // Block ends with unconditional jump to 0x1a93 label_1A0B: // Incoming jump from 0x1A03, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @1A0D stack[-2] // @1A0D stack[-3] // @1A0E stack[-4] // } 1A0B 5B JUMPDEST 1A0C 50 POP 1A0D 01 ADD 1A0E 90 SWAP1 1A0F 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A0E stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_1A10: // Incoming call from 0x08DC, returns to 0x03AB // Incoming call from 0x03AA, returns to 0x03AB // Incoming call from 0x03D6, returns to 0x03D7 // Incoming call from 0x0904, returns to 0x03AB // Incoming call from 0x1213, returns to 0x1214 // Incoming call from 0x0467, returns to 0x0468 // Incoming call from 0x0493, returns to 0x0494 // Inputs[1] { @1A13 stack[-1] } 1A10 5B JUMPDEST 1A11 60 PUSH1 0x01 1A13 81 DUP2 1A14 81 DUP2 1A15 1C SHR 1A16 90 SWAP1 1A17 82 DUP3 1A18 16 AND 1A19 80 DUP1 1A1A 61 PUSH2 0x1a24 1A1D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A16 stack[0] = stack[-1] >> 0x01 // @1A18 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x1a24, if stack[-1] & 0x01 label_1A1E: // Incoming jump from 0x1A1D, if not stack[-1] & 0x01 // Inputs[2] // { // @1A20 stack[-2] // @1A29 stack[-1] // } 1A1E 60 PUSH1 0x7f 1A20 82 DUP3 1A21 16 AND 1A22 91 SWAP2 1A23 50 POP 1A24 5B JUMPDEST 1A25 60 PUSH1 0x20 1A27 82 DUP3 1A28 10 LT 1A29 81 DUP2 1A2A 14 EQ 1A2B 15 ISZERO 1A2C 61 PUSH2 0x1a45 1A2F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1A22 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x1a45, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_1A30: // Incoming jump from 0x1A2F, if not !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1A2F, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[1] { @1A44 memory[0x00:0x24] } 1A30 63 PUSH4 0x4e487b71 1A35 60 PUSH1 0xe0 1A37 1B SHL 1A38 60 PUSH1 0x00 1A3A 52 MSTORE 1A3B 60 PUSH1 0x22 1A3D 60 PUSH1 0x04 1A3F 52 MSTORE 1A40 60 PUSH1 0x24 1A42 60 PUSH1 0x00 1A44 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A3A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1A3F memory[0x04:0x24] = 0x22 // @1A44 revert(memory[0x00:0x24]); // } // Block terminates label_1A45: // Incoming jump from 0x1A2F, if !(stack[-1] == (stack[-2] < 0x20)) // Incoming jump from 0x1A2F, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Inputs[3] // { // @1A47 stack[-2] // @1A47 stack[-4] // @1A48 stack[-3] // } 1A45 5B JUMPDEST 1A46 50 POP 1A47 91 SWAP2 1A48 90 SWAP1 1A49 50 POP 1A4A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1A47 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_1A4B: // Incoming call from 0x12E6, returns to 0x12E7 // Incoming call from 0x1371, returns to 0x1372 // Incoming call from 0x1B55, returns to 0x1B56 // Incoming call from 0x15E6, returns to 0x15E7 // Inputs[2] // { // @1A4E stack[-2] // @1A54 stack[-1] // } 1A4B 5B JUMPDEST 1A4C 60 PUSH1 0x1f 1A4E 82 DUP3 1A4F 01 ADD 1A50 60 PUSH1 0x1f 1A52 19 NOT 1A53 16 AND 1A54 81 DUP2 1A55 01 ADD 1A56 67 PUSH8 0xffffffffffffffff 1A5F 81 DUP2 1A60 11 GT 1A61 82 DUP3 1A62 82 DUP3 1A63 10 LT 1A64 17 OR 1A65 15 ISZERO 1A66 61 PUSH2 0x1a71 1A69 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1A55 stack[0] = stack[-1] + (~0x1f & stack[-2] + 0x1f) } // Block ends with conditional jump to 0x1a71, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) label_1A6A: // Incoming jump from 0x1A69, if not !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) 1A6A 61 PUSH2 0x1a71 1A6D 61 PUSH2 0x1aa9 1A70 56 *JUMP // Stack delta = +1 // Outputs[1] { @1A6A stack[0] = 0x1a71 } // Block ends with unconditional jump to 0x1aa9 label_1A71: // Incoming jump from 0x1A69, if !((stack[-1] + (~0x1f & stack[-2] + 0x1f) < stack[-1]) | (stack[-1] + (~0x1f & stack[-2] + 0x1f) > 0xffffffffffffffff)) // Inputs[2] // { // @1A74 stack[-1] // @1A77 stack[-4] // } 1A71 5B JUMPDEST 1A72 60 PUSH1 0x40 1A74 52 MSTORE 1A75 50 POP 1A76 50 POP 1A77 56 *JUMP // Stack delta = -4 // Outputs[1] { @1A74 memory[0x40:0x60] = stack[-1] } // Block ends with unconditional jump to stack[-4] 1A78 5B JUMPDEST 1A79 60 PUSH1 0x00 1A7B 60 PUSH1 0x00 1A7D 19 NOT 1A7E 82 DUP3 1A7F 14 EQ 1A80 15 ISZERO 1A81 61 PUSH2 0x1a8c 1A84 57 *JUMPI 1A85 61 PUSH2 0x1a8c 1A88 61 PUSH2 0x1a93 1A8B 56 *JUMP 1A8C 5B JUMPDEST 1A8D 50 POP 1A8E 60 PUSH1 0x01 1A90 01 ADD 1A91 90 SWAP1 1A92 56 *JUMP label_1A93: // Incoming jump from 0x1A0A // Inputs[1] { @1AA8 memory[0x00:0x24] } 1A93 5B JUMPDEST 1A94 63 PUSH4 0x4e487b71 1A99 60 PUSH1 0xe0 1A9B 1B SHL 1A9C 60 PUSH1 0x00 1A9E 52 MSTORE 1A9F 60 PUSH1 0x11 1AA1 60 PUSH1 0x04 1AA3 52 MSTORE 1AA4 60 PUSH1 0x24 1AA6 60 PUSH1 0x00 1AA8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1A9E memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1AA3 memory[0x04:0x24] = 0x11 // @1AA8 revert(memory[0x00:0x24]); // } // Block terminates label_1AA9: // Incoming jump from 0x135A // Incoming jump from 0x19ED // Incoming jump from 0x1A70 // Inputs[1] { @1ABE memory[0x00:0x24] } 1AA9 5B JUMPDEST 1AAA 63 PUSH4 0x4e487b71 1AAF 60 PUSH1 0xe0 1AB1 1B SHL 1AB2 60 PUSH1 0x00 1AB4 52 MSTORE 1AB5 60 PUSH1 0x41 1AB7 60 PUSH1 0x04 1AB9 52 MSTORE 1ABA 60 PUSH1 0x24 1ABC 60 PUSH1 0x00 1ABE FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1AB4 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1AB9 memory[0x04:0x24] = 0x41 // @1ABE revert(memory[0x00:0x24]); // } // Block terminates label_1ABF: // Incoming call from 0x106C, returns to 0x106D // Inputs[1] { @1AC4 returndata.length } 1ABF 5B JUMPDEST 1AC0 60 PUSH1 0x00 1AC2 60 PUSH1 0x03 1AC4 3D RETURNDATASIZE 1AC5 11 GT 1AC6 15 ISZERO 1AC7 61 PUSH2 0x1ad4 1ACA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AC0 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ad4, if !(returndata.length > 0x03) label_1ACB: // Incoming jump from 0x1ACA, if not !(returndata.length > 0x03) // Inputs[4] // { // @1ACD stack[-1] // @1ACF returndata[stack[-1]:stack[-1] + 0x04] // @1AD0 memory[stack[-1]:stack[-1] + 0x20] // @1AD5 stack[-2] // } 1ACB 60 PUSH1 0x04 1ACD 81 DUP2 1ACE 82 DUP3 1ACF 3E RETURNDATACOPY 1AD0 51 MLOAD 1AD1 60 PUSH1 0xe0 1AD3 1C SHR 1AD4 5B JUMPDEST 1AD5 90 SWAP1 1AD6 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1ACF memory[stack[-1]:stack[-1] + 0x04] = returndata[stack[-1]:stack[-1] + 0x04] // @1AD5 stack[-2] = memory[stack[-1]:stack[-1] + 0x20] >> 0xe0 // } // Block ends with unconditional jump to stack[-2] label_1AD7: // Incoming call from 0x1081, returns to 0x1082 // Inputs[1] { @1ADC returndata.length } 1AD7 5B JUMPDEST 1AD8 60 PUSH1 0x00 1ADA 60 PUSH1 0x44 1ADC 3D RETURNDATASIZE 1ADD 10 LT 1ADE 15 ISZERO 1ADF 61 PUSH2 0x1ae5 1AE2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1AD8 stack[0] = 0x00 } // Block ends with conditional jump to 0x1ae5, if !(returndata.length < 0x44) label_1AE3: // Incoming jump from 0x1AE2, if not !(returndata.length < 0x44) // Inputs[2] // { // @1AE3 stack[-2] // @1AE3 stack[-1] // } 1AE3 90 SWAP1 1AE4 56 *JUMP // Stack delta = -1 // Outputs[1] { @1AE3 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_1AE5: // Incoming jump from 0x1AE2, if !(returndata.length < 0x44) // Inputs[5] // { // @1AE8 memory[0x40:0x60] // @1AEC returndata.length // @1AF2 returndata[0x04:0x04 + ~0x03 + returndata.length] // @1AF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1AF5 returndata.length // } 1AE5 5B JUMPDEST 1AE6 60 PUSH1 0x40 1AE8 51 MLOAD 1AE9 60 PUSH1 0x03 1AEB 19 NOT 1AEC 3D RETURNDATASIZE 1AED 81 DUP2 1AEE 01 ADD 1AEF 60 PUSH1 0x04 1AF1 83 DUP4 1AF2 3E RETURNDATACOPY 1AF3 81 DUP2 1AF4 51 MLOAD 1AF5 3D RETURNDATASIZE 1AF6 67 PUSH8 0xffffffffffffffff 1AFF 81 DUP2 1B00 60 PUSH1 0x24 1B02 84 DUP5 1B03 01 ADD 1B04 11 GT 1B05 81 DUP2 1B06 84 DUP5 1B07 11 GT 1B08 17 OR 1B09 15 ISZERO 1B0A 61 PUSH2 0x1b15 1B0D 57 *JUMPI // Stack delta = +5 // Outputs[6] // { // @1AE8 stack[0] = memory[0x40:0x60] // @1AEB stack[1] = ~0x03 // @1AF2 memory[memory[0x40:0x60]:memory[0x40:0x60] + ~0x03 + returndata.length] = returndata[0x04:0x04 + ~0x03 + returndata.length] // @1AF4 stack[2] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1AF5 stack[3] = returndata.length // @1AF6 stack[4] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x1b15, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) label_1B0E: // Incoming jump from 0x1B0D, if not !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[2] // { // @1B13 stack[-7] // @1B13 stack[-6] // } 1B0E 50 POP 1B0F 50 POP 1B10 50 POP 1B11 50 POP 1B12 50 POP 1B13 90 SWAP1 1B14 56 *JUMP // Stack delta = -6 // Outputs[1] { @1B13 stack[-7] = stack[-6] } // Block ends with unconditional jump to stack[-7] label_1B15: // Incoming jump from 0x1B0D, if !((memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] > 0xffffffffffffffff) | (memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] + 0x24 > returndata.length)) // Inputs[5] // { // @1B16 stack[-3] // @1B17 stack[-5] // @1B19 stack[-2] // @1B1C memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // @1B1D stack[-1] // } 1B15 5B JUMPDEST 1B16 82 DUP3 1B17 85 DUP6 1B18 01 ADD 1B19 91 SWAP2 1B1A 50 POP 1B1B 81 DUP2 1B1C 51 MLOAD 1B1D 81 DUP2 1B1E 81 DUP2 1B1F 11 GT 1B20 15 ISZERO 1B21 61 PUSH2 0x1b2d 1B24 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1B19 stack[-2] = stack[-5] + stack[-3] // @1B1C stack[0] = memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] // } // Block ends with conditional jump to 0x1b2d, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) label_1B25: // Incoming jump from 0x1B24, if not !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[2] // { // @1B2B stack[-7] // @1B2B stack[-8] // } 1B25 50 POP 1B26 50 POP 1B27 50 POP 1B28 50 POP 1B29 50 POP 1B2A 50 POP 1B2B 90 SWAP1 1B2C 56 *JUMP // Stack delta = -7 // Outputs[1] { @1B2B stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1B2D: // Incoming jump from 0x1B24, if !(memory[stack[-5] + stack[-3]:stack[-5] + stack[-3] + 0x20] > stack[-1]) // Inputs[5] // { // @1B2E stack[-5] // @1B2F returndata.length // @1B30 stack[-6] // @1B35 stack[-1] // @1B36 stack[-3] // } 1B2D 5B JUMPDEST 1B2E 84 DUP5 1B2F 3D RETURNDATASIZE 1B30 87 DUP8 1B31 01 ADD 1B32 01 ADD 1B33 60 PUSH1 0x20 1B35 82 DUP3 1B36 85 DUP6 1B37 01 ADD 1B38 01 ADD 1B39 11 GT 1B3A 15 ISZERO 1B3B 61 PUSH2 0x1b47 1B3E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b47, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) label_1B3F: // Incoming jump from 0x1B3E, if not !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[2] // { // @1B45 stack[-8] // @1B45 stack[-7] // } 1B3F 50 POP 1B40 50 POP 1B41 50 POP 1B42 50 POP 1B43 50 POP 1B44 50 POP 1B45 90 SWAP1 1B46 56 *JUMP // Stack delta = -7 // Outputs[1] { @1B45 stack[-8] = stack[-7] } // Block ends with unconditional jump to stack[-8] label_1B47: // Incoming jump from 0x1B3E, if !(stack[-3] + stack[-1] + 0x20 > stack[-6] + returndata.length + stack[-5]) // Inputs[3] // { // @1B4D stack[-1] // @1B4E stack[-4] // @1B51 stack[-6] // } 1B47 5B JUMPDEST 1B48 61 PUSH2 0x1b56 1B4B 60 PUSH1 0x20 1B4D 82 DUP3 1B4E 86 DUP7 1B4F 01 ADD 1B50 01 ADD 1B51 87 DUP8 1B52 61 PUSH2 0x1a4b 1B55 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B48 stack[0] = 0x1b56 // @1B50 stack[1] = stack[-4] + stack[-1] + 0x20 // @1B51 stack[2] = stack[-6] // } // Block ends with call to 0x1a4b, returns to 0x1B56 label_1B56: // Incoming return from call to 0x1A4B at 0x1B55 // Inputs[4] // { // @1B58 stack[-3] // @1B58 stack[-2] // @1B59 stack[-8] // @1B5A stack[-7] // } 1B56 5B JUMPDEST 1B57 50 POP 1B58 90 SWAP1 1B59 95 SWAP6 1B5A 94 SWAP5 1B5B 50 POP 1B5C 50 POP 1B5D 50 POP 1B5E 50 POP 1B5F 50 POP 1B60 56 *JUMP // Stack delta = -7 // Outputs[1] { @1B59 stack[-8] = stack[-3] } // Block ends with unconditional jump to stack[-8] label_1B61: // Incoming call from 0x1677, returns to 0x13BA // Incoming call from 0x1693, returns to 0x13BA // Inputs[1] { @1B6B stack[-1] } 1B61 5B JUMPDEST 1B62 60 PUSH1 0x01 1B64 60 PUSH1 0x01 1B66 60 PUSH1 0xe0 1B68 1B SHL 1B69 03 SUB 1B6A 19 NOT 1B6B 81 DUP2 1B6C 16 AND 1B6D 81 DUP2 1B6E 14 EQ 1B6F 61 PUSH2 0x0a24 1B72 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a24, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1B73: // Incoming jump from 0x1B72, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1B76 memory[0x00:0x00] } 1B73 60 PUSH1 0x00 1B75 80 DUP1 1B76 FD *REVERT // Stack delta = +0 // Outputs[1] { @1B76 revert(memory[0x00:0x00]); } // Block terminates 1B77 FE *ASSERT 1B78 A2 LOG2 1B79 64 PUSH5 0x6970667358 1B7F 22 22 1B80 12 SLT 1B81 20 SHA3 1B82 39 CODECOPY 1B83 53 MSTORE8 1B84 0A EXP 1B85 50 POP 1B86 9F SWAP16 1B87 84 DUP5 1B88 1F 1F 1B89 F0 CREATE 1B8A 5E 5E 1B8B F4 DELEGATECALL 1B8C EE EE 1B8D A9 A9 1B8E 01 ADD 1B8F B7 B7 1B90 17 OR 1B91 78 PUSH25 0x5cd875d8957157a65df6aa92557a288764736f6c6343000804 1BAB 00 *STOP 1BAC 33 CALLER