Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x01c6 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01c6, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0x55f804b3 0019 11 GT 001A 61 PUSH2 0x00f7 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00f7, if 0x55f804b3 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x55f804b3 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0x95d89b41 0024 11 GT 0025 61 PUSH2 0x0095 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0095, if 0x95d89b41 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0x95d89b41 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xc23dc68f 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xc23dc68f > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xc23dc68f > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xc23dc68f 003A 14 EQ 003B 61 PUSH2 0x052a 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x052a, if 0xc23dc68f == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xc23dc68f == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xc87b56dd 0045 14 EQ 0046 61 PUSH2 0x0557 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0557, if 0xc87b56dd == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xc87b56dd == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe985e9c5 0050 14 EQ 0051 61 PUSH2 0x0577 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0577, if 0xe985e9c5 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xf2fde38b 005B 14 EQ 005C 61 PUSH2 0x05cd 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05cd, if 0xf2fde38b == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xf2fde38b == stack[-1] // Inputs[1] { @0063 memory[0x00:0x00] } 0060 60 PUSH1 0x00 0062 80 DUP1 0063 FD *REVERT // Stack delta = +0 // Outputs[1] { @0063 revert(memory[0x00:0x00]); } // Block terminates label_0064: // Incoming jump from 0x0033, if 0xc23dc68f > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0x95d89b41 006B 14 EQ 006C 61 PUSH2 0x04c2 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04c2, if 0x95d89b41 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0x99a2557a 0076 14 EQ 0077 61 PUSH2 0x04d7 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d7, if 0x99a2557a == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0x99a2557a == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xa22cb465 0081 14 EQ 0082 61 PUSH2 0x04f7 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f7, if 0xa22cb465 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xa22cb465 == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xb88d4fde 008C 14 EQ 008D 61 PUSH2 0x0517 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0517, if 0xb88d4fde == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0094 memory[0x00:0x00] } 0091 60 PUSH1 0x00 0093 80 DUP1 0094 FD *REVERT // Stack delta = +0 // Outputs[1] { @0094 revert(memory[0x00:0x00]); } // Block terminates label_0095: // Incoming jump from 0x0028, if 0x95d89b41 > stack[-1] // Inputs[1] { @0096 stack[-1] } 0095 5B JUMPDEST 0096 80 DUP1 0097 63 PUSH4 0x70a08231 009C 11 GT 009D 61 PUSH2 0x00d1 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00d1, if 0x70a08231 > stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0x70a08231 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0x70a08231 00A7 14 EQ 00A8 61 PUSH2 0x0435 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0435, if 0x70a08231 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x70a08231 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x715018a6 00B2 14 EQ 00B3 61 PUSH2 0x0455 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0455, if 0x715018a6 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x715018a6 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x8462151c 00BD 14 EQ 00BE 61 PUSH2 0x046a 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x046a, if 0x8462151c == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x8462151c == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x8da5cb5b 00C8 14 EQ 00C9 61 PUSH2 0x0497 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0497, if 0x8da5cb5b == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00D0 memory[0x00:0x00] } 00CD 60 PUSH1 0x00 00CF 80 DUP1 00D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @00D0 revert(memory[0x00:0x00]); } // Block terminates label_00D1: // Incoming jump from 0x00A0, if 0x70a08231 > stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D1 5B JUMPDEST 00D2 80 DUP1 00D3 63 PUSH4 0x55f804b3 00D8 14 EQ 00D9 61 PUSH2 0x03c8 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03c8, if 0x55f804b3 == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0x55f804b3 == stack[-1] // Inputs[1] { @00DD stack[-1] } 00DD 80 DUP1 00DE 63 PUSH4 0x5bbb2177 00E3 14 EQ 00E4 61 PUSH2 0x03e8 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e8, if 0x5bbb2177 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x5bbb2177 == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x6352211e 00EE 14 EQ 00EF 61 PUSH2 0x0415 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0415, if 0x6352211e == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x6352211e == stack[-1] // Inputs[1] { @00F6 memory[0x00:0x00] } 00F3 60 PUSH1 0x00 00F5 80 DUP1 00F6 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F6 revert(memory[0x00:0x00]); } // Block terminates label_00F7: // Incoming jump from 0x001D, if 0x55f804b3 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00F8 stack[-1] } 00F7 5B JUMPDEST 00F8 80 DUP1 00F9 63 PUSH4 0x23b872dd 00FE 11 GT 00FF 61 PUSH2 0x0164 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0164, if 0x23b872dd > stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x23b872dd > stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0x3771aaa1 0109 11 GT 010A 61 PUSH2 0x013e 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x013e, if 0x3771aaa1 > stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x3771aaa1 > stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x3771aaa1 0114 14 EQ 0115 61 PUSH2 0x035e 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035e, if 0x3771aaa1 == stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x3771aaa1 == stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x3ccfd60b 011F 14 EQ 0120 61 PUSH2 0x037e 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x037e, if 0x3ccfd60b == stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x41f43434 012A 14 EQ 012B 61 PUSH2 0x0393 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0393, if 0x41f43434 == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x41f43434 == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x42842e0e 0135 14 EQ 0136 61 PUSH2 0x03b5 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b5, if 0x42842e0e == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x42842e0e == stack[-1] // Inputs[1] { @013D memory[0x00:0x00] } 013A 60 PUSH1 0x00 013C 80 DUP1 013D FD *REVERT // Stack delta = +0 // Outputs[1] { @013D revert(memory[0x00:0x00]); } // Block terminates label_013E: // Incoming jump from 0x010D, if 0x3771aaa1 > stack[-1] // Inputs[1] { @013F stack[-1] } 013E 5B JUMPDEST 013F 80 DUP1 0140 63 PUSH4 0x23b872dd 0145 14 EQ 0146 61 PUSH2 0x02ea 0149 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ea, if 0x23b872dd == stack[-1] label_014A: // Incoming jump from 0x0149, if not 0x23b872dd == stack[-1] // Inputs[1] { @014A stack[-1] } 014A 80 DUP1 014B 63 PUSH4 0x2a55205a 0150 14 EQ 0151 61 PUSH2 0x02fd 0154 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fd, if 0x2a55205a == stack[-1] label_0155: // Incoming jump from 0x0154, if not 0x2a55205a == stack[-1] // Inputs[1] { @0155 stack[-1] } 0155 80 DUP1 0156 63 PUSH4 0x359bccf4 015B 14 EQ 015C 61 PUSH2 0x0349 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0349, if 0x359bccf4 == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0x359bccf4 == stack[-1] // Inputs[1] { @0163 memory[0x00:0x00] } 0160 60 PUSH1 0x00 0162 80 DUP1 0163 FD *REVERT // Stack delta = +0 // Outputs[1] { @0163 revert(memory[0x00:0x00]); } // Block terminates label_0164: // Incoming jump from 0x0102, if 0x23b872dd > stack[-1] // Inputs[1] { @0165 stack[-1] } 0164 5B JUMPDEST 0165 80 DUP1 0166 63 PUSH4 0x06fdde03 016B 11 GT 016C 61 PUSH2 0x01a0 016F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a0, if 0x06fdde03 > stack[-1] label_0170: // Incoming jump from 0x016F, if not 0x06fdde03 > stack[-1] // Inputs[1] { @0170 stack[-1] } 0170 80 DUP1 0171 63 PUSH4 0x06fdde03 0176 14 EQ 0177 61 PUSH2 0x0249 017A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0249, if 0x06fdde03 == stack[-1] label_017B: // Incoming jump from 0x017A, if not 0x06fdde03 == stack[-1] // Inputs[1] { @017B stack[-1] } 017B 80 DUP1 017C 63 PUSH4 0x081812fc 0181 14 EQ 0182 61 PUSH2 0x026b 0185 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026b, if 0x081812fc == stack[-1] label_0186: // Incoming jump from 0x0185, if not 0x081812fc == stack[-1] // Inputs[1] { @0186 stack[-1] } 0186 80 DUP1 0187 63 PUSH4 0x095ea7b3 018C 14 EQ 018D 61 PUSH2 0x02b0 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b0, if 0x095ea7b3 == stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x18160ddd 0197 14 EQ 0198 61 PUSH2 0x02c3 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c3, if 0x18160ddd == stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x18160ddd == stack[-1] // Inputs[1] { @019F memory[0x00:0x00] } 019C 60 PUSH1 0x00 019E 80 DUP1 019F FD *REVERT // Stack delta = +0 // Outputs[1] { @019F revert(memory[0x00:0x00]); } // Block terminates label_01A0: // Incoming jump from 0x016F, if 0x06fdde03 > stack[-1] // Inputs[1] { @01A1 stack[-1] } 01A0 5B JUMPDEST 01A1 80 DUP1 01A2 63 PUSH4 0x01ffc9a7 01A7 14 EQ 01A8 61 PUSH2 0x01d2 01AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01d2, if 0x01ffc9a7 == stack[-1] label_01AC: // Incoming jump from 0x01AB, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01AC stack[-1] } 01AC 80 DUP1 01AD 63 PUSH4 0x03710668 01B2 14 EQ 01B3 61 PUSH2 0x0207 01B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0207, if 0x03710668 == stack[-1] label_01B7: // Incoming jump from 0x01B6, if not 0x03710668 == stack[-1] // Inputs[1] { @01B7 stack[-1] } 01B7 80 DUP1 01B8 63 PUSH4 0x04634d8d 01BD 14 EQ 01BE 61 PUSH2 0x0229 01C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0229, if 0x04634d8d == stack[-1] label_01C2: // Incoming jump from 0x01C1, if not 0x04634d8d == stack[-1] // Inputs[1] { @01C5 memory[0x00:0x00] } 01C2 60 PUSH1 0x00 01C4 80 DUP1 01C5 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C5 revert(memory[0x00:0x00]); } // Block terminates label_01C6: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @01C7 msg.data.length } 01C6 5B JUMPDEST 01C7 36 CALLDATASIZE 01C8 61 PUSH2 0x01cd 01CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01cd, if msg.data.length label_01CC: // Incoming jump from 0x01CB, if not msg.data.length 01CC 00 *STOP // Stack delta = +0 // Outputs[1] { @01CC stop(); } // Block terminates label_01CD: // Incoming jump from 0x01CB, if msg.data.length // Inputs[1] { @01D1 memory[0x00:0x00] } 01CD 5B JUMPDEST 01CE 60 PUSH1 0x00 01D0 80 DUP1 01D1 FD *REVERT // Stack delta = +0 // Outputs[1] { @01D1 revert(memory[0x00:0x00]); } // Block terminates label_01D2: // Incoming jump from 0x01AB, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01D3 msg.value } 01D2 5B JUMPDEST 01D3 34 CALLVALUE 01D4 80 DUP1 01D5 15 ISZERO 01D6 61 PUSH2 0x01de 01D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01D3 stack[0] = msg.value } // Block ends with conditional jump to 0x01de, if !msg.value label_01DA: // Incoming jump from 0x01D9, if not !msg.value // Inputs[1] { @01DD memory[0x00:0x00] } 01DA 60 PUSH1 0x00 01DC 80 DUP1 01DD FD *REVERT // Stack delta = +0 // Outputs[1] { @01DD revert(memory[0x00:0x00]); } // Block terminates label_01DE: // Incoming jump from 0x01D9, if !msg.value // Inputs[1] { @01E6 msg.data.length } 01DE 5B JUMPDEST 01DF 50 POP 01E0 61 PUSH2 0x01f2 01E3 61 PUSH2 0x01ed 01E6 36 CALLDATASIZE 01E7 60 PUSH1 0x04 01E9 61 PUSH2 0x1f68 01EC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @01E0 stack[-1] = 0x01f2 // @01E3 stack[0] = 0x01ed // @01E6 stack[1] = msg.data.length // @01E7 stack[2] = 0x04 // } // Block ends with call to 0x1f68, returns to 0x01ED label_01ED: // Incoming return from call to 0x1F68 at 0x01EC 01ED 5B JUMPDEST 01EE 61 PUSH2 0x05ed 01F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05ed label_01F2: // Incoming return from call to 0x01ED at 0x01EC // Incoming return from call to 0x0592 at 0x0591 // Inputs[2] // { // @01F5 memory[0x40:0x60] // @01F6 stack[-1] // } 01F2 5B JUMPDEST 01F3 60 PUSH1 0x40 01F5 51 MLOAD 01F6 90 SWAP1 01F7 15 ISZERO 01F8 15 ISZERO 01F9 81 DUP2 01FA 52 MSTORE 01FB 60 PUSH1 0x20 01FD 01 ADD // Stack delta = +0 // Outputs[2] // { // @01FA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @01FD stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_01FE: // Incoming return from call to 0x2430 at 0x0496 // Incoming jump from 0x02E9 // Incoming jump from 0x02E9 // Incoming jump from 0x0348 // Incoming jump from 0x01FD // Incoming jump from 0x02AF // Incoming return from call to 0x253D at 0x0556 // Incoming return from call to 0x238B at 0x0414 // Inputs[3] // { // @0201 memory[0x40:0x60] // @0203 stack[-1] // @0206 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 01FE 5B JUMPDEST 01FF 60 PUSH1 0x40 0201 51 MLOAD 0202 80 DUP1 0203 91 SWAP2 0204 03 SUB 0205 90 SWAP1 0206 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0206 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0207: // Incoming jump from 0x01B6, if 0x03710668 == stack[-1] // Inputs[1] { @0208 msg.value } 0207 5B JUMPDEST 0208 34 CALLVALUE 0209 80 DUP1 020A 15 ISZERO 020B 61 PUSH2 0x0213 020E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0208 stack[0] = msg.value } // Block ends with conditional jump to 0x0213, if !msg.value label_020F: // Incoming jump from 0x020E, if not !msg.value // Inputs[1] { @0212 memory[0x00:0x00] } 020F 60 PUSH1 0x00 0211 80 DUP1 0212 FD *REVERT // Stack delta = +0 // Outputs[1] { @0212 revert(memory[0x00:0x00]); } // Block terminates label_0213: // Incoming jump from 0x020E, if !msg.value // Inputs[1] { @021B msg.data.length } 0213 5B JUMPDEST 0214 50 POP 0215 61 PUSH2 0x0227 0218 61 PUSH2 0x0222 021B 36 CALLDATASIZE 021C 60 PUSH1 0x04 021E 61 PUSH2 0x2086 0221 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0215 stack[-1] = 0x0227 // @0218 stack[0] = 0x0222 // @021B stack[1] = msg.data.length // @021C stack[2] = 0x04 // } // Block ends with call to 0x2086, returns to 0x0222 label_0222: // Incoming return from call to 0x2086 at 0x0221 0222 5B JUMPDEST 0223 61 PUSH2 0x0649 0226 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0649 label_0227: // Incoming return from call to 0x0379 at 0x0378 // Incoming return from call to 0x02F8 at 0x02F7 // Incoming return from call to 0x02BE at 0x02BD // Incoming return from call to 0x0A5C at 0x0392 // Incoming return from call to 0x0222 at 0x0221 // Incoming return from call to 0x0244 at 0x0243 // Incoming return from call to 0x0525 at 0x0524 // Incoming return from call to 0x05E8 at 0x05E7 0227 5B JUMPDEST 0228 00 *STOP // Stack delta = +0 // Outputs[1] { @0228 stop(); } // Block terminates label_0229: // Incoming jump from 0x01C1, if 0x04634d8d == stack[-1] // Inputs[1] { @022A msg.value } 0229 5B JUMPDEST 022A 34 CALLVALUE 022B 80 DUP1 022C 15 ISZERO 022D 61 PUSH2 0x0235 0230 57 *JUMPI // Stack delta = +1 // Outputs[1] { @022A stack[0] = msg.value } // Block ends with conditional jump to 0x0235, if !msg.value label_0231: // Incoming jump from 0x0230, if not !msg.value // Inputs[1] { @0234 memory[0x00:0x00] } 0231 60 PUSH1 0x00 0233 80 DUP1 0234 FD *REVERT // Stack delta = +0 // Outputs[1] { @0234 revert(memory[0x00:0x00]); } // Block terminates label_0235: // Incoming jump from 0x0230, if !msg.value // Inputs[1] { @023D msg.data.length } 0235 5B JUMPDEST 0236 50 POP 0237 61 PUSH2 0x0227 023A 61 PUSH2 0x0244 023D 36 CALLDATASIZE 023E 60 PUSH1 0x04 0240 61 PUSH2 0x20d4 0243 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0237 stack[-1] = 0x0227 // @023A stack[0] = 0x0244 // @023D stack[1] = msg.data.length // @023E stack[2] = 0x04 // } // Block ends with call to 0x20d4, returns to 0x0244 label_0244: // Incoming return from call to 0x20D4 at 0x0243 0244 5B JUMPDEST 0245 61 PUSH2 0x072f 0248 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x072f label_0249: // Incoming jump from 0x017A, if 0x06fdde03 == stack[-1] // Inputs[1] { @024A msg.value } 0249 5B JUMPDEST 024A 34 CALLVALUE 024B 80 DUP1 024C 15 ISZERO 024D 61 PUSH2 0x0255 0250 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024A stack[0] = msg.value } // Block ends with conditional jump to 0x0255, if !msg.value label_0251: // Incoming jump from 0x0250, if not !msg.value // Inputs[1] { @0254 memory[0x00:0x00] } 0251 60 PUSH1 0x00 0253 80 DUP1 0254 FD *REVERT // Stack delta = +0 // Outputs[1] { @0254 revert(memory[0x00:0x00]); } // Block terminates label_0255: // Incoming jump from 0x0250, if !msg.value 0255 5B JUMPDEST 0256 50 POP 0257 61 PUSH2 0x025e 025A 61 PUSH2 0x0745 025D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0257 stack[-1] = 0x025e } // Block ends with call to 0x0745, returns to 0x025E label_025E: // Incoming return from call to 0x0745 at 0x025D // Incoming return from call to 0x0984 at 0x035D // Incoming return from call to 0x0D95 at 0x04D6 // Inputs[2] // { // @0261 memory[0x40:0x60] // @0265 stack[-1] // } 025E 5B JUMPDEST 025F 60 PUSH1 0x40 0261 51 MLOAD 0262 61 PUSH2 0x01fe 0265 91 SWAP2 0266 90 SWAP1 0267 61 PUSH2 0x216c 026A 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0265 stack[-1] = 0x01fe // @0266 stack[1] = memory[0x40:0x60] // @0266 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x216c label_026B: // Incoming jump from 0x0185, if 0x081812fc == stack[-1] // Inputs[1] { @026C msg.value } 026B 5B JUMPDEST 026C 34 CALLVALUE 026D 80 DUP1 026E 15 ISZERO 026F 61 PUSH2 0x0277 0272 57 *JUMPI // Stack delta = +1 // Outputs[1] { @026C stack[0] = msg.value } // Block ends with conditional jump to 0x0277, if !msg.value label_0273: // Incoming jump from 0x0272, if not !msg.value // Inputs[1] { @0276 memory[0x00:0x00] } 0273 60 PUSH1 0x00 0275 80 DUP1 0276 FD *REVERT // Stack delta = +0 // Outputs[1] { @0276 revert(memory[0x00:0x00]); } // Block terminates label_0277: // Incoming jump from 0x0272, if !msg.value // Inputs[1] { @027F msg.data.length } 0277 5B JUMPDEST 0278 50 POP 0279 61 PUSH2 0x028b 027C 61 PUSH2 0x0286 027F 36 CALLDATASIZE 0280 60 PUSH1 0x04 0282 61 PUSH2 0x217f 0285 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0279 stack[-1] = 0x028b // @027C stack[0] = 0x0286 // @027F stack[1] = msg.data.length // @0280 stack[2] = 0x04 // } // Block ends with call to 0x217f, returns to 0x0286 label_0286: // Incoming return from call to 0x217F at 0x0285 0286 5B JUMPDEST 0287 61 PUSH2 0x07d7 028A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x07d7 label_028B: // Incoming return from call to 0x0286 at 0x0285 // Incoming jump from 0x04C1 // Incoming return from call to 0x0430 at 0x042F // Incoming jump from 0x03B4 // Inputs[2] // { // @028E memory[0x40:0x60] // @02A5 stack[-1] // } 028B 5B JUMPDEST 028C 60 PUSH1 0x40 028E 51 MLOAD 028F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 02A4 90 SWAP1 02A5 91 SWAP2 02A6 16 AND 02A7 81 DUP2 02A8 52 MSTORE 02A9 60 PUSH1 0x20 02AB 01 ADD 02AC 61 PUSH2 0x01fe 02AF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @02AB stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01fe label_02B0: // Incoming jump from 0x0190, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02B7 msg.data.length } 02B0 5B JUMPDEST 02B1 61 PUSH2 0x0227 02B4 61 PUSH2 0x02be 02B7 36 CALLDATASIZE 02B8 60 PUSH1 0x04 02BA 61 PUSH2 0x2198 02BD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02B1 stack[0] = 0x0227 // @02B4 stack[1] = 0x02be // @02B7 stack[2] = msg.data.length // @02B8 stack[3] = 0x04 // } // Block ends with call to 0x2198, returns to 0x02BE label_02BE: // Incoming return from call to 0x2198 at 0x02BD 02BE 5B JUMPDEST 02BF 61 PUSH2 0x0841 02C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0841 label_02C3: // Incoming jump from 0x019B, if 0x18160ddd == stack[-1] // Inputs[1] { @02C4 msg.value } 02C3 5B JUMPDEST 02C4 34 CALLVALUE 02C5 80 DUP1 02C6 15 ISZERO 02C7 61 PUSH2 0x02cf 02CA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C4 stack[0] = msg.value } // Block ends with conditional jump to 0x02cf, if !msg.value label_02CB: // Incoming jump from 0x02CA, if not !msg.value // Inputs[1] { @02CE memory[0x00:0x00] } 02CB 60 PUSH1 0x00 02CD 80 DUP1 02CE FD *REVERT // Stack delta = +0 // Outputs[1] { @02CE revert(memory[0x00:0x00]); } // Block terminates label_02CF: // Incoming jump from 0x02CA, if !msg.value // Inputs[3] // { // @02D3 storage[0x01] // @02D6 storage[0x00] // @02DF memory[0x40:0x60] // } 02CF 5B JUMPDEST 02D0 50 POP 02D1 60 PUSH1 0x01 02D3 54 SLOAD 02D4 60 PUSH1 0x00 02D6 54 SLOAD 02D7 03 SUB 02D8 60 PUSH1 0x00 02DA 19 NOT 02DB 01 ADD 02DC 5B JUMPDEST 02DD 60 PUSH1 0x40 02DF 51 MLOAD 02E0 90 SWAP1 02E1 81 DUP2 02E2 52 MSTORE 02E3 60 PUSH1 0x20 02E5 01 ADD 02E6 61 PUSH2 0x01fe 02E9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x00 + (storage[0x00] - storage[0x01]) // @02E5 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01fe label_02EA: // Incoming jump from 0x0149, if 0x23b872dd == stack[-1] // Inputs[1] { @02F1 msg.data.length } 02EA 5B JUMPDEST 02EB 61 PUSH2 0x0227 02EE 61 PUSH2 0x02f8 02F1 36 CALLDATASIZE 02F2 60 PUSH1 0x04 02F4 61 PUSH2 0x21c2 02F7 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02EB stack[0] = 0x0227 // @02EE stack[1] = 0x02f8 // @02F1 stack[2] = msg.data.length // @02F2 stack[3] = 0x04 // } // Block ends with call to 0x21c2, returns to 0x02F8 label_02F8: // Incoming return from call to 0x21C2 at 0x02F7 02F8 5B JUMPDEST 02F9 61 PUSH2 0x0855 02FC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0855 label_02FD: // Incoming jump from 0x0154, if 0x2a55205a == stack[-1] // Inputs[1] { @02FE msg.value } 02FD 5B JUMPDEST 02FE 34 CALLVALUE 02FF 80 DUP1 0300 15 ISZERO 0301 61 PUSH2 0x0309 0304 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02FE stack[0] = msg.value } // Block ends with conditional jump to 0x0309, if !msg.value label_0305: // Incoming jump from 0x0304, if not !msg.value // Inputs[1] { @0308 memory[0x00:0x00] } 0305 60 PUSH1 0x00 0307 80 DUP1 0308 FD *REVERT // Stack delta = +0 // Outputs[1] { @0308 revert(memory[0x00:0x00]); } // Block terminates label_0309: // Incoming jump from 0x0304, if !msg.value // Inputs[1] { @0311 msg.data.length } 0309 5B JUMPDEST 030A 50 POP 030B 61 PUSH2 0x031d 030E 61 PUSH2 0x0318 0311 36 CALLDATASIZE 0312 60 PUSH1 0x04 0314 61 PUSH2 0x21fe 0317 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @030B stack[-1] = 0x031d // @030E stack[0] = 0x0318 // @0311 stack[1] = msg.data.length // @0312 stack[2] = 0x04 // } // Block ends with call to 0x21fe, returns to 0x0318 label_0318: // Incoming return from call to 0x21FE at 0x0317 0318 5B JUMPDEST 0319 61 PUSH2 0x088d 031C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x088d label_031D: // Incoming return from call to 0x0318 at 0x0317 // Inputs[3] // { // @0321 memory[0x40:0x60] // @0338 stack[-2] // @0340 stack[-1] // } 031D 5B JUMPDEST 031E 60 PUSH1 0x40 0320 80 DUP1 0321 51 MLOAD 0322 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0337 90 SWAP1 0338 93 SWAP4 0339 16 AND 033A 83 DUP4 033B 52 MSTORE 033C 60 PUSH1 0x20 033E 83 DUP4 033F 01 ADD 0340 91 SWAP2 0341 90 SWAP1 0342 91 SWAP2 0343 52 MSTORE 0344 01 ADD 0345 61 PUSH2 0x01fe 0348 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @033B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @0343 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] // @0344 stack[-2] = 0x40 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x01fe label_0349: // Incoming jump from 0x015F, if 0x359bccf4 == stack[-1] // Inputs[1] { @034A msg.value } 0349 5B JUMPDEST 034A 34 CALLVALUE 034B 80 DUP1 034C 15 ISZERO 034D 61 PUSH2 0x0355 0350 57 *JUMPI // Stack delta = +1 // Outputs[1] { @034A stack[0] = msg.value } // Block ends with conditional jump to 0x0355, if !msg.value label_0351: // Incoming jump from 0x0350, if not !msg.value // Inputs[1] { @0354 memory[0x00:0x00] } 0351 60 PUSH1 0x00 0353 80 DUP1 0354 FD *REVERT // Stack delta = +0 // Outputs[1] { @0354 revert(memory[0x00:0x00]); } // Block terminates label_0355: // Incoming jump from 0x0350, if !msg.value 0355 5B JUMPDEST 0356 50 POP 0357 61 PUSH2 0x025e 035A 61 PUSH2 0x0984 035D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0357 stack[-1] = 0x025e } // Block ends with call to 0x0984, returns to 0x025E label_035E: // Incoming jump from 0x0118, if 0x3771aaa1 == stack[-1] // Inputs[1] { @035F msg.value } 035E 5B JUMPDEST 035F 34 CALLVALUE 0360 80 DUP1 0361 15 ISZERO 0362 61 PUSH2 0x036a 0365 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035F stack[0] = msg.value } // Block ends with conditional jump to 0x036a, if !msg.value label_0366: // Incoming jump from 0x0365, if not !msg.value // Inputs[1] { @0369 memory[0x00:0x00] } 0366 60 PUSH1 0x00 0368 80 DUP1 0369 FD *REVERT // Stack delta = +0 // Outputs[1] { @0369 revert(memory[0x00:0x00]); } // Block terminates label_036A: // Incoming jump from 0x0365, if !msg.value // Inputs[1] { @0372 msg.data.length } 036A 5B JUMPDEST 036B 50 POP 036C 61 PUSH2 0x0227 036F 61 PUSH2 0x0379 0372 36 CALLDATASIZE 0373 60 PUSH1 0x04 0375 61 PUSH2 0x2220 0378 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @036C stack[-1] = 0x0227 // @036F stack[0] = 0x0379 // @0372 stack[1] = msg.data.length // @0373 stack[2] = 0x04 // } // Block ends with call to 0x2220, returns to 0x0379 label_0379: // Incoming return from call to 0x2220 at 0x0378 0379 5B JUMPDEST 037A 61 PUSH2 0x0a12 037D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a12 label_037E: // Incoming jump from 0x0123, if 0x3ccfd60b == stack[-1] // Inputs[1] { @037F msg.value } 037E 5B JUMPDEST 037F 34 CALLVALUE 0380 80 DUP1 0381 15 ISZERO 0382 61 PUSH2 0x038a 0385 57 *JUMPI // Stack delta = +1 // Outputs[1] { @037F stack[0] = msg.value } // Block ends with conditional jump to 0x038a, if !msg.value label_0386: // Incoming jump from 0x0385, if not !msg.value // Inputs[1] { @0389 memory[0x00:0x00] } 0386 60 PUSH1 0x00 0388 80 DUP1 0389 FD *REVERT // Stack delta = +0 // Outputs[1] { @0389 revert(memory[0x00:0x00]); } // Block terminates label_038A: // Incoming jump from 0x0385, if !msg.value 038A 5B JUMPDEST 038B 50 POP 038C 61 PUSH2 0x0227 038F 61 PUSH2 0x0a5c 0392 56 *JUMP // Stack delta = +0 // Outputs[1] { @038C stack[-1] = 0x0227 } // Block ends with call to 0x0a5c, returns to 0x0227 label_0393: // Incoming jump from 0x012E, if 0x41f43434 == stack[-1] // Inputs[1] { @0394 msg.value } 0393 5B JUMPDEST 0394 34 CALLVALUE 0395 80 DUP1 0396 15 ISZERO 0397 61 PUSH2 0x039f 039A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0394 stack[0] = msg.value } // Block ends with conditional jump to 0x039f, if !msg.value label_039B: // Incoming jump from 0x039A, if not !msg.value // Inputs[1] { @039E memory[0x00:0x00] } 039B 60 PUSH1 0x00 039D 80 DUP1 039E FD *REVERT // Stack delta = +0 // Outputs[1] { @039E revert(memory[0x00:0x00]); } // Block terminates label_039F: // Incoming jump from 0x039A, if !msg.value 039F 5B JUMPDEST 03A0 50 POP 03A1 61 PUSH2 0x028b 03A4 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 03B3 81 DUP2 03B4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @03A1 stack[-1] = 0x028b // @03A4 stack[0] = 0xaaeb6d7670e522a718067333cd4e // } // Block ends with unconditional jump to 0x028b label_03B5: // Incoming jump from 0x0139, if 0x42842e0e == stack[-1] // Inputs[1] { @03BC msg.data.length } 03B5 5B JUMPDEST 03B6 61 PUSH2 0x0227 03B9 61 PUSH2 0x03c3 03BC 36 CALLDATASIZE 03BD 60 PUSH1 0x04 03BF 61 PUSH2 0x21c2 03C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B6 stack[0] = 0x0227 // @03B9 stack[1] = 0x03c3 // @03BC stack[2] = msg.data.length // @03BD stack[3] = 0x04 // } // Block ends with call to 0x21c2, returns to 0x03C3 label_03C3: // Incoming return from call to 0x21C2 at 0x03C2 03C3 5B JUMPDEST 03C4 61 PUSH2 0x0ab7 03C7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ab7 label_03C8: // Incoming jump from 0x00DC, if 0x55f804b3 == stack[-1] // Inputs[1] { @03C9 msg.value } 03C8 5B JUMPDEST 03C9 34 CALLVALUE 03CA 80 DUP1 03CB 15 ISZERO 03CC 61 PUSH2 0x03d4 03CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C9 stack[0] = msg.value } // Block ends with conditional jump to 0x03d4, if !msg.value label_03D0: // Incoming jump from 0x03CF, if not !msg.value // Inputs[1] { @03D3 memory[0x00:0x00] } 03D0 60 PUSH1 0x00 03D2 80 DUP1 03D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03D3 revert(memory[0x00:0x00]); } // Block terminates label_03D4: // Incoming jump from 0x03CF, if !msg.value // Inputs[1] { @03DC msg.data.length } 03D4 5B JUMPDEST 03D5 50 POP 03D6 61 PUSH2 0x0227 03D9 61 PUSH2 0x03e3 03DC 36 CALLDATASIZE 03DD 60 PUSH1 0x04 03DF 61 PUSH2 0x22cd 03E2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03D6 stack[-1] = 0x0227 // @03D9 stack[0] = 0x03e3 // @03DC stack[1] = msg.data.length // @03DD stack[2] = 0x04 // } // Block ends with call to 0x22cd, returns to 0x03E3 label_03E3: // Incoming return from call to 0x22CD at 0x03E2 03E3 5B JUMPDEST 03E4 61 PUSH2 0x0ae9 03E7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ae9 label_03E8: // Incoming jump from 0x00E7, if 0x5bbb2177 == stack[-1] // Inputs[1] { @03E9 msg.value } 03E8 5B JUMPDEST 03E9 34 CALLVALUE 03EA 80 DUP1 03EB 15 ISZERO 03EC 61 PUSH2 0x03f4 03EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E9 stack[0] = msg.value } // Block ends with conditional jump to 0x03f4, if !msg.value label_03F0: // Incoming jump from 0x03EF, if not !msg.value // Inputs[1] { @03F3 memory[0x00:0x00] } 03F0 60 PUSH1 0x00 03F2 80 DUP1 03F3 FD *REVERT // Stack delta = +0 // Outputs[1] { @03F3 revert(memory[0x00:0x00]); } // Block terminates label_03F4: // Incoming jump from 0x03EF, if !msg.value // Inputs[1] { @03FC msg.data.length } 03F4 5B JUMPDEST 03F5 50 POP 03F6 61 PUSH2 0x0408 03F9 61 PUSH2 0x0403 03FC 36 CALLDATASIZE 03FD 60 PUSH1 0x04 03FF 61 PUSH2 0x2316 0402 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03F6 stack[-1] = 0x0408 // @03F9 stack[0] = 0x0403 // @03FC stack[1] = msg.data.length // @03FD stack[2] = 0x04 // } // Block ends with call to 0x2316, returns to 0x0403 label_0403: // Incoming return from call to 0x2316 at 0x0402 0403 5B JUMPDEST 0404 61 PUSH2 0x0afd 0407 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0afd label_0408: // Incoming return from call to 0x0403 at 0x0402 // Inputs[2] // { // @040B memory[0x40:0x60] // @040F stack[-1] // } 0408 5B JUMPDEST 0409 60 PUSH1 0x40 040B 51 MLOAD 040C 61 PUSH2 0x01fe 040F 91 SWAP2 0410 90 SWAP1 0411 61 PUSH2 0x238b 0414 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @040F stack[-1] = 0x01fe // @0410 stack[1] = memory[0x40:0x60] // @0410 stack[0] = stack[-1] // } // Block ends with call to 0x238b, returns to 0x01FE label_0415: // Incoming jump from 0x00F2, if 0x6352211e == stack[-1] // Inputs[1] { @0416 msg.value } 0415 5B JUMPDEST 0416 34 CALLVALUE 0417 80 DUP1 0418 15 ISZERO 0419 61 PUSH2 0x0421 041C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0416 stack[0] = msg.value } // Block ends with conditional jump to 0x0421, if !msg.value label_041D: // Incoming jump from 0x041C, if not !msg.value // Inputs[1] { @0420 memory[0x00:0x00] } 041D 60 PUSH1 0x00 041F 80 DUP1 0420 FD *REVERT // Stack delta = +0 // Outputs[1] { @0420 revert(memory[0x00:0x00]); } // Block terminates label_0421: // Incoming jump from 0x041C, if !msg.value // Inputs[1] { @0429 msg.data.length } 0421 5B JUMPDEST 0422 50 POP 0423 61 PUSH2 0x028b 0426 61 PUSH2 0x0430 0429 36 CALLDATASIZE 042A 60 PUSH1 0x04 042C 61 PUSH2 0x217f 042F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0423 stack[-1] = 0x028b // @0426 stack[0] = 0x0430 // @0429 stack[1] = msg.data.length // @042A stack[2] = 0x04 // } // Block ends with call to 0x217f, returns to 0x0430 label_0430: // Incoming return from call to 0x217F at 0x042F 0430 5B JUMPDEST 0431 61 PUSH2 0x0bc9 0434 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bc9 label_0435: // Incoming jump from 0x00AB, if 0x70a08231 == stack[-1] // Inputs[1] { @0436 msg.value } 0435 5B JUMPDEST 0436 34 CALLVALUE 0437 80 DUP1 0438 15 ISZERO 0439 61 PUSH2 0x0441 043C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0436 stack[0] = msg.value } // Block ends with conditional jump to 0x0441, if !msg.value label_043D: // Incoming jump from 0x043C, if not !msg.value // Inputs[1] { @0440 memory[0x00:0x00] } 043D 60 PUSH1 0x00 043F 80 DUP1 0440 FD *REVERT // Stack delta = +0 // Outputs[1] { @0440 revert(memory[0x00:0x00]); } // Block terminates label_0441: // Incoming jump from 0x043C, if !msg.value // Inputs[1] { @0449 msg.data.length } 0441 5B JUMPDEST 0442 50 POP 0443 61 PUSH2 0x02dc 0446 61 PUSH2 0x0450 0449 36 CALLDATASIZE 044A 60 PUSH1 0x04 044C 61 PUSH2 0x2415 044F 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0443 stack[-1] = 0x02dc // @0446 stack[0] = 0x0450 // @0449 stack[1] = msg.data.length // @044A stack[2] = 0x04 // } // Block ends with call to 0x2415, returns to 0x0450 label_0450: // Incoming return from call to 0x2415 at 0x044F 0450 5B JUMPDEST 0451 61 PUSH2 0x0bd4 0454 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bd4 label_0455: // Incoming jump from 0x00B6, if 0x715018a6 == stack[-1] // Inputs[1] { @0456 msg.value } 0455 5B JUMPDEST 0456 34 CALLVALUE 0457 80 DUP1 0458 15 ISZERO 0459 61 PUSH2 0x0461 045C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0456 stack[0] = msg.value } // Block ends with conditional jump to 0x0461, if !msg.value label_045D: // Incoming jump from 0x045C, if not !msg.value // Inputs[1] { @0460 memory[0x00:0x00] } 045D 60 PUSH1 0x00 045F 80 DUP1 0460 FD *REVERT // Stack delta = +0 // Outputs[1] { @0460 revert(memory[0x00:0x00]); } // Block terminates label_0461: // Incoming jump from 0x045C, if !msg.value 0461 5B JUMPDEST 0462 50 POP 0463 61 PUSH2 0x0227 0466 61 PUSH2 0x0c56 0469 56 *JUMP // Stack delta = +0 // Outputs[1] { @0463 stack[-1] = 0x0227 } // Block ends with unconditional jump to 0x0c56 label_046A: // Incoming jump from 0x00C1, if 0x8462151c == stack[-1] // Inputs[1] { @046B msg.value } 046A 5B JUMPDEST 046B 34 CALLVALUE 046C 80 DUP1 046D 15 ISZERO 046E 61 PUSH2 0x0476 0471 57 *JUMPI // Stack delta = +1 // Outputs[1] { @046B stack[0] = msg.value } // Block ends with conditional jump to 0x0476, if !msg.value label_0472: // Incoming jump from 0x0471, if not !msg.value // Inputs[1] { @0475 memory[0x00:0x00] } 0472 60 PUSH1 0x00 0474 80 DUP1 0475 FD *REVERT // Stack delta = +0 // Outputs[1] { @0475 revert(memory[0x00:0x00]); } // Block terminates label_0476: // Incoming jump from 0x0471, if !msg.value // Inputs[1] { @047E msg.data.length } 0476 5B JUMPDEST 0477 50 POP 0478 61 PUSH2 0x048a 047B 61 PUSH2 0x0485 047E 36 CALLDATASIZE 047F 60 PUSH1 0x04 0481 61 PUSH2 0x2415 0484 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0478 stack[-1] = 0x048a // @047B stack[0] = 0x0485 // @047E stack[1] = msg.data.length // @047F stack[2] = 0x04 // } // Block ends with call to 0x2415, returns to 0x0485 label_0485: // Incoming return from call to 0x2415 at 0x0484 0485 5B JUMPDEST 0486 61 PUSH2 0x0c6a 0489 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c6a label_048A: // Incoming return from call to 0x04F2 at 0x04F1 // Incoming return from call to 0x0485 at 0x0484 // Inputs[2] // { // @048D memory[0x40:0x60] // @0491 stack[-1] // } 048A 5B JUMPDEST 048B 60 PUSH1 0x40 048D 51 MLOAD 048E 61 PUSH2 0x01fe 0491 91 SWAP2 0492 90 SWAP1 0493 61 PUSH2 0x2430 0496 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0491 stack[-1] = 0x01fe // @0492 stack[1] = memory[0x40:0x60] // @0492 stack[0] = stack[-1] // } // Block ends with call to 0x2430, returns to 0x01FE label_0497: // Incoming jump from 0x00CC, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0498 msg.value } 0497 5B JUMPDEST 0498 34 CALLVALUE 0499 80 DUP1 049A 15 ISZERO 049B 61 PUSH2 0x04a3 049E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0498 stack[0] = msg.value } // Block ends with conditional jump to 0x04a3, if !msg.value label_049F: // Incoming jump from 0x049E, if not !msg.value // Inputs[1] { @04A2 memory[0x00:0x00] } 049F 60 PUSH1 0x00 04A1 80 DUP1 04A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04A2 revert(memory[0x00:0x00]); } // Block terminates label_04A3: // Incoming jump from 0x049E, if !msg.value // Inputs[1] { @04A7 storage[0x08] } 04A3 5B JUMPDEST 04A4 50 POP 04A5 60 PUSH1 0x08 04A7 54 SLOAD 04A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 04BD 16 AND 04BE 61 PUSH2 0x028b 04C1 56 *JUMP // Stack delta = +0 // Outputs[1] { @04BD stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x08] } // Block ends with unconditional jump to 0x028b label_04C2: // Incoming jump from 0x006F, if 0x95d89b41 == stack[-1] // Inputs[1] { @04C3 msg.value } 04C2 5B JUMPDEST 04C3 34 CALLVALUE 04C4 80 DUP1 04C5 15 ISZERO 04C6 61 PUSH2 0x04ce 04C9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C3 stack[0] = msg.value } // Block ends with conditional jump to 0x04ce, if !msg.value label_04CA: // Incoming jump from 0x04C9, if not !msg.value // Inputs[1] { @04CD memory[0x00:0x00] } 04CA 60 PUSH1 0x00 04CC 80 DUP1 04CD FD *REVERT // Stack delta = +0 // Outputs[1] { @04CD revert(memory[0x00:0x00]); } // Block terminates label_04CE: // Incoming jump from 0x04C9, if !msg.value 04CE 5B JUMPDEST 04CF 50 POP 04D0 61 PUSH2 0x025e 04D3 61 PUSH2 0x0d95 04D6 56 *JUMP // Stack delta = +0 // Outputs[1] { @04D0 stack[-1] = 0x025e } // Block ends with call to 0x0d95, returns to 0x025E label_04D7: // Incoming jump from 0x007A, if 0x99a2557a == stack[-1] // Inputs[1] { @04D8 msg.value } 04D7 5B JUMPDEST 04D8 34 CALLVALUE 04D9 80 DUP1 04DA 15 ISZERO 04DB 61 PUSH2 0x04e3 04DE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D8 stack[0] = msg.value } // Block ends with conditional jump to 0x04e3, if !msg.value label_04DF: // Incoming jump from 0x04DE, if not !msg.value // Inputs[1] { @04E2 memory[0x00:0x00] } 04DF 60 PUSH1 0x00 04E1 80 DUP1 04E2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04E2 revert(memory[0x00:0x00]); } // Block terminates label_04E3: // Incoming jump from 0x04DE, if !msg.value // Inputs[1] { @04EB msg.data.length } 04E3 5B JUMPDEST 04E4 50 POP 04E5 61 PUSH2 0x048a 04E8 61 PUSH2 0x04f2 04EB 36 CALLDATASIZE 04EC 60 PUSH1 0x04 04EE 61 PUSH2 0x2468 04F1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04E5 stack[-1] = 0x048a // @04E8 stack[0] = 0x04f2 // @04EB stack[1] = msg.data.length // @04EC stack[2] = 0x04 // } // Block ends with call to 0x2468, returns to 0x04F2 label_04F2: // Incoming return from call to 0x2468 at 0x04F1 04F2 5B JUMPDEST 04F3 61 PUSH2 0x0da4 04F6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0da4 label_04F7: // Incoming jump from 0x0085, if 0xa22cb465 == stack[-1] // Inputs[1] { @04F8 msg.value } 04F7 5B JUMPDEST 04F8 34 CALLVALUE 04F9 80 DUP1 04FA 15 ISZERO 04FB 61 PUSH2 0x0503 04FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0503, if !msg.value label_04FF: // Incoming jump from 0x04FE, if not !msg.value // Inputs[1] { @0502 memory[0x00:0x00] } 04FF 60 PUSH1 0x00 0501 80 DUP1 0502 FD *REVERT // Stack delta = +0 // Outputs[1] { @0502 revert(memory[0x00:0x00]); } // Block terminates label_0503: // Incoming jump from 0x04FE, if !msg.value // Inputs[1] { @050B msg.data.length } 0503 5B JUMPDEST 0504 50 POP 0505 61 PUSH2 0x0227 0508 61 PUSH2 0x0512 050B 36 CALLDATASIZE 050C 60 PUSH1 0x04 050E 61 PUSH2 0x24a9 0511 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0505 stack[-1] = 0x0227 // @0508 stack[0] = 0x0512 // @050B stack[1] = msg.data.length // @050C stack[2] = 0x04 // } // Block ends with unconditional jump to 0x24a9 0512 5B JUMPDEST 0513 61 PUSH2 0x0f6c 0516 56 *JUMP label_0517: // Incoming jump from 0x0090, if 0xb88d4fde == stack[-1] // Inputs[1] { @051E msg.data.length } 0517 5B JUMPDEST 0518 61 PUSH2 0x0227 051B 61 PUSH2 0x0525 051E 36 CALLDATASIZE 051F 60 PUSH1 0x04 0521 61 PUSH2 0x24d5 0524 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0518 stack[0] = 0x0227 // @051B stack[1] = 0x0525 // @051E stack[2] = msg.data.length // @051F stack[3] = 0x04 // } // Block ends with call to 0x24d5, returns to 0x0525 label_0525: // Incoming return from call to 0x24D5 at 0x0524 0525 5B JUMPDEST 0526 61 PUSH2 0x0f80 0529 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f80 label_052A: // Incoming jump from 0x003E, if 0xc23dc68f == stack[-1] // Inputs[1] { @052B msg.value } 052A 5B JUMPDEST 052B 34 CALLVALUE 052C 80 DUP1 052D 15 ISZERO 052E 61 PUSH2 0x0536 0531 57 *JUMPI // Stack delta = +1 // Outputs[1] { @052B stack[0] = msg.value } // Block ends with conditional jump to 0x0536, if !msg.value label_0532: // Incoming jump from 0x0531, if not !msg.value // Inputs[1] { @0535 memory[0x00:0x00] } 0532 60 PUSH1 0x00 0534 80 DUP1 0535 FD *REVERT // Stack delta = +0 // Outputs[1] { @0535 revert(memory[0x00:0x00]); } // Block terminates label_0536: // Incoming jump from 0x0531, if !msg.value // Inputs[1] { @053E msg.data.length } 0536 5B JUMPDEST 0537 50 POP 0538 61 PUSH2 0x054a 053B 61 PUSH2 0x0545 053E 36 CALLDATASIZE 053F 60 PUSH1 0x04 0541 61 PUSH2 0x217f 0544 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0538 stack[-1] = 0x054a // @053B stack[0] = 0x0545 // @053E stack[1] = msg.data.length // @053F stack[2] = 0x04 // } // Block ends with call to 0x217f, returns to 0x0545 label_0545: // Incoming return from call to 0x217F at 0x0544 0545 5B JUMPDEST 0546 61 PUSH2 0x0fba 0549 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fba label_054A: // Incoming return from call to 0x0545 at 0x0544 // Incoming return from call to 0x0545 at 0x0544 // Inputs[2] // { // @054D memory[0x40:0x60] // @0551 stack[-1] // } 054A 5B JUMPDEST 054B 60 PUSH1 0x40 054D 51 MLOAD 054E 61 PUSH2 0x01fe 0551 91 SWAP2 0552 90 SWAP1 0553 61 PUSH2 0x253d 0556 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0551 stack[-1] = 0x01fe // @0552 stack[1] = memory[0x40:0x60] // @0552 stack[0] = stack[-1] // } // Block ends with call to 0x253d, returns to 0x01FE label_0557: // Incoming jump from 0x0049, if 0xc87b56dd == stack[-1] // Inputs[1] { @0558 msg.value } 0557 5B JUMPDEST 0558 34 CALLVALUE 0559 80 DUP1 055A 15 ISZERO 055B 61 PUSH2 0x0563 055E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0558 stack[0] = msg.value } // Block ends with conditional jump to 0x0563, if !msg.value label_055F: // Incoming jump from 0x055E, if not !msg.value // Inputs[1] { @0562 memory[0x00:0x00] } 055F 60 PUSH1 0x00 0561 80 DUP1 0562 FD *REVERT // Stack delta = +0 // Outputs[1] { @0562 revert(memory[0x00:0x00]); } // Block terminates label_0563: // Incoming jump from 0x055E, if !msg.value // Inputs[1] { @056B msg.data.length } 0563 5B JUMPDEST 0564 50 POP 0565 61 PUSH2 0x025e 0568 61 PUSH2 0x0572 056B 36 CALLDATASIZE 056C 60 PUSH1 0x04 056E 61 PUSH2 0x217f 0571 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0565 stack[-1] = 0x025e // @0568 stack[0] = 0x0572 // @056B stack[1] = msg.data.length // @056C stack[2] = 0x04 // } // Block ends with call to 0x217f, returns to 0x0572 label_0572: // Incoming return from call to 0x217F at 0x0571 0572 5B JUMPDEST 0573 61 PUSH2 0x1042 0576 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1042 label_0577: // Incoming jump from 0x0054, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0578 msg.value } 0577 5B JUMPDEST 0578 34 CALLVALUE 0579 80 DUP1 057A 15 ISZERO 057B 61 PUSH2 0x0583 057E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0578 stack[0] = msg.value } // Block ends with conditional jump to 0x0583, if !msg.value label_057F: // Incoming jump from 0x057E, if not !msg.value // Inputs[1] { @0582 memory[0x00:0x00] } 057F 60 PUSH1 0x00 0581 80 DUP1 0582 FD *REVERT // Stack delta = +0 // Outputs[1] { @0582 revert(memory[0x00:0x00]); } // Block terminates label_0583: // Incoming jump from 0x057E, if !msg.value // Inputs[1] { @058B msg.data.length } 0583 5B JUMPDEST 0584 50 POP 0585 61 PUSH2 0x01f2 0588 61 PUSH2 0x0592 058B 36 CALLDATASIZE 058C 60 PUSH1 0x04 058E 61 PUSH2 0x258f 0591 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0585 stack[-1] = 0x01f2 // @0588 stack[0] = 0x0592 // @058B stack[1] = msg.data.length // @058C stack[2] = 0x04 // } // Block ends with call to 0x258f, returns to 0x0592 label_0592: // Incoming return from call to 0x258F at 0x0591 // Incoming call from 0x15AC, returns to 0x15AD // Incoming call from 0x1712, returns to 0x1713 // Inputs[6] // { // @05A8 stack[-2] // @05BB memory[0x00:0x40] // @05BC stack[-1] // @05C6 memory[0x00:0x40] // @05C7 storage[keccak256(memory[0x00:0x40])] // @05CB stack[-3] // } 0592 5B JUMPDEST 0593 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05A8 91 SWAP2 05A9 82 DUP3 05AA 16 AND 05AB 60 PUSH1 0x00 05AD 90 SWAP1 05AE 81 DUP2 05AF 52 MSTORE 05B0 60 PUSH1 0x07 05B2 60 PUSH1 0x20 05B4 90 SWAP1 05B5 81 DUP2 05B6 52 MSTORE 05B7 60 PUSH1 0x40 05B9 80 DUP1 05BA 83 DUP4 05BB 20 SHA3 05BC 93 SWAP4 05BD 90 SWAP1 05BE 94 SWAP5 05BF 16 AND 05C0 82 DUP3 05C1 52 MSTORE 05C2 91 SWAP2 05C3 90 SWAP1 05C4 91 SWAP2 05C5 52 MSTORE 05C6 20 SHA3 05C7 54 SLOAD 05C8 60 PUSH1 0xff 05CA 16 AND 05CB 90 SWAP1 05CC 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @05AF memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @05B6 memory[0x20:0x40] = 0x07 // @05C1 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @05C5 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @05CB stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_05CD: // Incoming jump from 0x005F, if 0xf2fde38b == stack[-1] // Inputs[1] { @05CE msg.value } 05CD 5B JUMPDEST 05CE 34 CALLVALUE 05CF 80 DUP1 05D0 15 ISZERO 05D1 61 PUSH2 0x05d9 05D4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05CE stack[0] = msg.value } // Block ends with conditional jump to 0x05d9, if !msg.value label_05D5: // Incoming jump from 0x05D4, if not !msg.value // Inputs[1] { @05D8 memory[0x00:0x00] } 05D5 60 PUSH1 0x00 05D7 80 DUP1 05D8 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D8 revert(memory[0x00:0x00]); } // Block terminates label_05D9: // Incoming jump from 0x05D4, if !msg.value // Inputs[1] { @05E1 msg.data.length } 05D9 5B JUMPDEST 05DA 50 POP 05DB 61 PUSH2 0x0227 05DE 61 PUSH2 0x05e8 05E1 36 CALLDATASIZE 05E2 60 PUSH1 0x04 05E4 61 PUSH2 0x2415 05E7 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05DB stack[-1] = 0x0227 // @05DE stack[0] = 0x05e8 // @05E1 stack[1] = msg.data.length // @05E2 stack[2] = 0x04 // } // Block ends with call to 0x2415, returns to 0x05E8 label_05E8: // Incoming return from call to 0x2415 at 0x05E7 05E8 5B JUMPDEST 05E9 61 PUSH2 0x10de 05EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x10de label_05ED: // Incoming jump from 0x01F1 // Inputs[1] { @0611 stack[-1] } 05ED 5B JUMPDEST 05EE 60 PUSH1 0x00 05F0 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 0611 82 DUP3 0612 16 AND 0613 7F PUSH32 0x8446a79e00000000000000000000000000000000000000000000000000000000 0634 14 EQ 0635 80 DUP1 0636 61 PUSH2 0x0643 0639 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @05EE stack[0] = 0x00 // @0634 stack[1] = 0x8446a79e00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x0643, if 0x8446a79e00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_063A: // Incoming jump from 0x0639, if not 0x8446a79e00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @063E stack[-3] } 063A 50 POP 063B 61 PUSH2 0x0643 063E 82 DUP3 063F 61 PUSH2 0x1195 0642 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @063B stack[-1] = 0x0643 // @063E stack[0] = stack[-3] // } // Block ends with call to 0x1195, returns to 0x0643 label_0643: // Incoming jump from 0x11E1, if 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x258E // Incoming jump from 0x0639, if 0x8446a79e00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming jump from 0x122B // Incoming return from call to 0x1D1D at 0x1D1C // Incoming return from call to 0x1A2F at 0x0BD3 // Incoming jump from 0x1BEB // Incoming return from call to 0x1195 at 0x0642 // Incoming jump from 0x1440, if !stack[-1] // Incoming jump from 0x1440, if !(stack[-3] < storage[0x00]) // Inputs[3] // { // @0644 stack[-1] // @0644 stack[-4] // @0645 stack[-3] // } 0643 5B JUMPDEST 0644 92 SWAP3 0645 91 SWAP2 0646 50 POP 0647 50 POP 0648 56 *JUMP // Stack delta = -3 // Outputs[1] { @0644 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0649: // Incoming jump from 0x0226 0649 5B JUMPDEST 064A 61 PUSH2 0x0651 064D 61 PUSH2 0x122c 0650 56 *JUMP // Stack delta = +1 // Outputs[1] { @064A stack[0] = 0x0651 } // Block ends with call to 0x122c, returns to 0x0651 label_0651: // Incoming return from call to 0x122C at 0x0650 // Inputs[3] // { // @0654 stack[-2] // @066B stack[-1] // @066E memory[0x40:0x60] // } 0651 5B JUMPDEST 0652 60 PUSH1 0x00 0654 82 DUP3 0655 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 066A 16 AND 066B 82 DUP3 066C 60 PUSH1 0x40 066E 51 MLOAD 066F 61 PUSH2 0x0678 0672 91 SWAP2 0673 90 SWAP1 0674 61 PUSH2 0x25c2 0677 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0652 stack[0] = 0x00 // @066A stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0672 stack[2] = 0x0678 // @0673 stack[3] = stack[-1] // @0673 stack[4] = memory[0x40:0x60] // } // Block ends with call to 0x25c2, returns to 0x0678 label_0678: // Incoming return from call to 0x25C2 at 0x0677 // Inputs[7] // { // @067D memory[0x40:0x60] // @067F stack[-1] // @0684 stack[-2] // @0685 msg.gas // @0686 address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0686 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @068A returndata.length // } 0678 5B JUMPDEST 0679 60 PUSH1 0x00 067B 60 PUSH1 0x40 067D 51 MLOAD 067E 80 DUP1 067F 83 DUP4 0680 03 SUB 0681 81 DUP2 0682 60 PUSH1 0x00 0684 86 DUP7 0685 5A GAS 0686 F1 CALL 0687 91 SWAP2 0688 50 POP 0689 50 POP 068A 3D RETURNDATASIZE 068B 80 DUP1 068C 60 PUSH1 0x00 068E 81 DUP2 068F 14 EQ 0690 61 PUSH2 0x06b5 0693 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0686 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @0687 stack[-2] = address(stack[-2]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @068A stack[-1] = returndata.length // @068B stack[0] = returndata.length // } // Block ends with conditional jump to 0x06b5, if returndata.length == 0x00 label_0694: // Incoming jump from 0x0693, if not returndata.length == 0x00 // Inputs[6] // { // @0696 memory[0x40:0x60] // @0697 stack[-2] // @069E returndata.length // @06A6 returndata.length // @06A9 returndata.length // @06B0 returndata[0x00:0x00 + returndata.length] // } 0694 60 PUSH1 0x40 0696 51 MLOAD 0697 91 SWAP2 0698 50 POP 0699 60 PUSH1 0x1f 069B 19 NOT 069C 60 PUSH1 0x3f 069E 3D RETURNDATASIZE 069F 01 ADD 06A0 16 AND 06A1 82 DUP3 06A2 01 ADD 06A3 60 PUSH1 0x40 06A5 52 MSTORE 06A6 3D RETURNDATASIZE 06A7 82 DUP3 06A8 52 MSTORE 06A9 3D RETURNDATASIZE 06AA 60 PUSH1 0x00 06AC 60 PUSH1 0x20 06AE 84 DUP5 06AF 01 ADD 06B0 3E RETURNDATACOPY 06B1 61 PUSH2 0x06ba 06B4 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @0697 stack[-2] = memory[0x40:0x60] // @06A5 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @06A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @06B0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x06ba label_06B5: // Incoming jump from 0x0693, if returndata.length == 0x00 // Inputs[3] // { // @06B8 stack[-2] // @06BD stack[-4] // @06BD stack[-3] // } 06B5 5B JUMPDEST 06B6 60 PUSH1 0x60 06B8 91 SWAP2 06B9 50 POP 06BA 5B JUMPDEST 06BB 50 POP 06BC 50 POP 06BD 90 SWAP1 06BE 50 POP 06BF 80 DUP1 06C0 61 PUSH2 0x072a 06C3 57 *JUMPI // Stack delta = -3 // Outputs[1] { @06BD stack[-4] = stack[-3] } // Block ends with conditional jump to 0x072a, if stack[-3] label_06C4: // Incoming jump from 0x06C3, if not stack[-3] // Incoming jump from 0x06C3, if not stack[-3] // Inputs[1] { @06C6 memory[0x40:0x60] } 06C4 60 PUSH1 0x40 06C6 51 MLOAD 06C7 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 06E8 81 DUP2 06E9 52 MSTORE 06EA 60 PUSH1 0x20 06EC 60 PUSH1 0x04 06EE 82 DUP3 06EF 01 ADD 06F0 52 MSTORE 06F1 60 PUSH1 0x13 06F3 60 PUSH1 0x24 06F5 82 DUP3 06F6 01 ADD 06F7 52 MSTORE 06F8 7F PUSH32 0x63616c6c436f6e7472616374206661696c656400000000000000000000000000 0719 60 PUSH1 0x44 071B 82 DUP3 071C 01 ADD 071D 52 MSTORE 071E 60 PUSH1 0x64 0720 01 ADD // Stack delta = +1 // Outputs[5] // { // @06E9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @06F0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @06F7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @071D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x63616c6c436f6e7472616374206661696c656400000000000000000000000000 // @0720 stack[0] = 0x64 + memory[0x40:0x60] // } // Block continues label_0721: // Incoming jump from 0x0720 // Incoming jump from 0x12AC // Incoming jump from 0x134C // Incoming jump from 0x1578 // Incoming jump from 0x1188 // Incoming jump from 0x13C9 // Inputs[3] // { // @0724 memory[0x40:0x60] // @0726 stack[-1] // @0729 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0721 5B JUMPDEST 0722 60 PUSH1 0x40 0724 51 MLOAD 0725 80 DUP1 0726 91 SWAP2 0727 03 SUB 0728 90 SWAP1 0729 FD *REVERT // Stack delta = -1 // Outputs[1] { @0729 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_072A: // Incoming return from call to 0x1579 at 0x0854 // Incoming jump from 0x270C, if !(stack[-2] > 0x1f) // Incoming jump from 0x06C3, if stack[-3] // Incoming jump from 0x06C3, if stack[-3] // Incoming return from call to 0x0F80 at 0x1A2E // Inputs[1] { @072E stack[-4] } 072A 5B JUMPDEST 072B 50 POP 072C 50 POP 072D 50 POP 072E 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_072F: // Incoming jump from 0x0248 072F 5B JUMPDEST 0730 61 PUSH2 0x0737 0733 61 PUSH2 0x122c 0736 56 *JUMP // Stack delta = +1 // Outputs[1] { @0730 stack[0] = 0x0737 } // Block ends with call to 0x122c, returns to 0x0737 label_0737: // Incoming return from call to 0x122C at 0x0736 // Inputs[2] // { // @073B stack[-2] // @073C stack[-1] // } 0737 5B JUMPDEST 0738 61 PUSH2 0x0741 073B 82 DUP3 073C 82 DUP3 073D 61 PUSH2 0x12ad 0740 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0738 stack[0] = 0x0741 // @073B stack[1] = stack[-2] // @073C stack[2] = stack[-1] // } // Block ends with call to 0x12ad, returns to 0x0741 label_0741: // Incoming jump from 0x0A26, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0A26, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0AAD, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming return from call to 0x12AD at 0x0740 // Incoming return from call to 0x2749 at 0x0AFC // Inputs[1] { @0744 stack[-3] } 0741 5B JUMPDEST 0742 50 POP 0743 50 POP 0744 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0745: // Incoming call from 0x025D, returns to 0x025E // Inputs[1] { @074B storage[0x02] } 0745 5B JUMPDEST 0746 60 PUSH1 0x60 0748 60 PUSH1 0x02 074A 80 DUP1 074B 54 SLOAD 074C 61 PUSH2 0x0754 074F 90 SWAP1 0750 61 PUSH2 0x25de 0753 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0746 stack[0] = 0x60 // @0748 stack[1] = 0x02 // @074F stack[2] = 0x0754 // @074F stack[3] = storage[0x02] // } // Block ends with call to 0x25de, returns to 0x0754 label_0754: // Incoming return from call to 0x25DE at 0x0DA3 // Incoming return from call to 0x25DE at 0x1D99 // Incoming return from call to 0x25DE at 0x0753 // Inputs[4] // { // @0755 stack[-1] // @0764 memory[0x40:0x60] // @076C stack[-2] // @0777 storage[stack[-2]] // } 0754 5B JUMPDEST 0755 80 DUP1 0756 60 PUSH1 0x1f 0758 01 ADD 0759 60 PUSH1 0x20 075B 80 DUP1 075C 91 SWAP2 075D 04 DIV 075E 02 MUL 075F 60 PUSH1 0x20 0761 01 ADD 0762 60 PUSH1 0x40 0764 51 MLOAD 0765 90 SWAP1 0766 81 DUP2 0767 01 ADD 0768 60 PUSH1 0x40 076A 52 MSTORE 076B 80 DUP1 076C 92 SWAP3 076D 91 SWAP2 076E 90 SWAP1 076F 81 DUP2 0770 81 DUP2 0771 52 MSTORE 0772 60 PUSH1 0x20 0774 01 ADD 0775 82 DUP3 0776 80 DUP1 0777 54 SLOAD 0778 61 PUSH2 0x0780 077B 90 SWAP1 077C 61 PUSH2 0x25de 077F 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @076A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @076C stack[-2] = memory[0x40:0x60] // @076D stack[-1] = stack[-2] // @076E stack[0] = stack[-1] // @0771 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0774 stack[1] = 0x20 + memory[0x40:0x60] // @0775 stack[2] = stack[-2] // @077B stack[4] = storage[stack[-2]] // @077B stack[3] = 0x0780 // } // Block ends with call to 0x25de, returns to 0x0780 label_0780: // Incoming return from call to 0x25DE at 0x077F // Inputs[1] { @0781 stack[-1] } 0780 5B JUMPDEST 0781 80 DUP1 0782 15 ISZERO 0783 61 PUSH2 0x07cd 0786 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07cd, if !stack[-1] label_0787: // Incoming jump from 0x0786, if not !stack[-1] // Inputs[1] { @0787 stack[-1] } 0787 80 DUP1 0788 60 PUSH1 0x1f 078A 10 LT 078B 61 PUSH2 0x07a2 078E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07a2, if 0x1f < stack[-1] label_078F: // Incoming jump from 0x078E, if not 0x1f < stack[-1] // Inputs[4] // { // @0793 stack[-2] // @0794 storage[stack[-2]] // @0797 stack[-3] // @0799 stack[-1] // } 078F 61 PUSH2 0x0100 0792 80 DUP1 0793 83 DUP4 0794 54 SLOAD 0795 04 DIV 0796 02 MUL 0797 83 DUP4 0798 52 MSTORE 0799 91 SWAP2 079A 60 PUSH1 0x20 079C 01 ADD 079D 91 SWAP2 079E 61 PUSH2 0x07cd 07A1 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @0798 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @079D stack[-1] = stack[-1] // @079D stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x07cd label_07A2: // Incoming jump from 0x078E, if 0x1f < stack[-1] // Inputs[5] // { // @07A3 stack[-3] // @07A4 stack[-1] // @07A6 stack[-2] // @07AE memory[0x00:0x20] // @07B2 storage[keccak256(memory[0x00:0x20])] // } 07A2 5B JUMPDEST 07A3 82 DUP3 07A4 01 ADD 07A5 91 SWAP2 07A6 90 SWAP1 07A7 60 PUSH1 0x00 07A9 52 MSTORE 07AA 60 PUSH1 0x20 07AC 60 PUSH1 0x00 07AE 20 SHA3 07AF 90 SWAP1 07B0 5B JUMPDEST 07B1 81 DUP2 07B2 54 SLOAD 07B3 81 DUP2 07B4 52 MSTORE 07B5 90 SWAP1 07B6 60 PUSH1 0x01 07B8 01 ADD 07B9 90 SWAP1 07BA 60 PUSH1 0x20 07BC 01 ADD 07BD 80 DUP1 07BE 83 DUP4 07BF 11 GT 07C0 61 PUSH2 0x07b0 07C3 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @07A5 stack[-3] = stack[-3] + stack[-1] // @07A9 memory[0x00:0x20] = stack[-2] // @07B4 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @07B9 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07BC stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x07b0, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07C4: // Incoming jump from 0x07C3, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x07C3, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @07C4 stack[-3] // @07C5 stack[-1] // } 07C4 82 DUP3 07C5 90 SWAP1 07C6 03 SUB 07C7 60 PUSH1 0x1f 07C9 16 AND 07CA 82 DUP3 07CB 01 ADD 07CC 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @07CC stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @07CC stack[-1] = stack[-3] // } // Block continues label_07CD: // Incoming jump from 0x07A1 // Incoming jump from 0x0786, if !stack[-1] // Incoming jump from 0x07CC // Inputs[3] // { // @07D3 stack[-6] // @07D3 stack[-7] // @07D5 stack[-8] // } 07CD 5B JUMPDEST 07CE 50 POP 07CF 50 POP 07D0 50 POP 07D1 50 POP 07D2 50 POP 07D3 90 SWAP1 07D4 50 POP 07D5 90 SWAP1 07D6 56 *JUMP // Stack delta = -7 // Outputs[1] { @07D5 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_07D7: // Incoming jump from 0x028A // Inputs[1] { @07DD stack[-1] } 07D7 5B JUMPDEST 07D8 60 PUSH1 0x00 07DA 61 PUSH2 0x07e2 07DD 82 DUP3 07DE 61 PUSH2 0x1426 07E1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @07D8 stack[0] = 0x00 // @07DA stack[1] = 0x07e2 // @07DD stack[2] = stack[-1] // } // Block ends with call to 0x1426, returns to 0x07E2 label_07E2: // Incoming return from call to 0x1426 at 0x07E1 // Inputs[1] { @07E6 stack[-1] } 07E2 5B JUMPDEST 07E3 61 PUSH2 0x0818 07E6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0818, if stack[-1] label_07E7: // Incoming jump from 0x07E6, if not stack[-1] // Inputs[3] // { // @07E9 memory[0x40:0x60] // @0812 memory[0x40:0x60] // @0817 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07E7 60 PUSH1 0x40 07E9 51 MLOAD 07EA 7F PUSH32 0xcf4700e400000000000000000000000000000000000000000000000000000000 080B 81 DUP2 080C 52 MSTORE 080D 60 PUSH1 0x04 080F 01 ADD 0810 60 PUSH1 0x40 0812 51 MLOAD 0813 80 DUP1 0814 91 SWAP2 0815 03 SUB 0816 90 SWAP1 0817 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @080C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcf4700e400000000000000000000000000000000000000000000000000000000 // @0817 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0818: // Incoming jump from 0x07E6, if stack[-1] // Inputs[4] // { // @081C stack[-2] // @0827 memory[0x00:0x40] // @0828 storage[keccak256(memory[0x00:0x40])] // @083F stack[-3] // } 0818 5B JUMPDEST 0819 50 POP 081A 60 PUSH1 0x00 081C 90 SWAP1 081D 81 DUP2 081E 52 MSTORE 081F 60 PUSH1 0x06 0821 60 PUSH1 0x20 0823 52 MSTORE 0824 60 PUSH1 0x40 0826 90 SWAP1 0827 20 SHA3 0828 54 SLOAD 0829 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 083E 16 AND 083F 90 SWAP1 0840 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @081E memory[0x00:0x20] = stack[-2] // @0823 memory[0x20:0x40] = 0x06 // @083F stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0841: // Incoming jump from 0x02C2 // Inputs[1] { @0842 stack[-2] } 0841 5B JUMPDEST 0842 81 DUP2 0843 61 PUSH2 0x084b 0846 81 DUP2 0847 61 PUSH2 0x1474 084A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0842 stack[0] = stack[-2] // @0843 stack[1] = 0x084b // @0846 stack[2] = stack[-2] // } // Block ends with call to 0x1474, returns to 0x084B label_084B: // Incoming return from call to 0x1474 at 0x084A // Inputs[2] // { // @084F stack[-3] // @0850 stack[-2] // } 084B 5B JUMPDEST 084C 61 PUSH2 0x072a 084F 83 DUP4 0850 83 DUP4 0851 61 PUSH2 0x1579 0854 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @084C stack[0] = 0x072a // @084F stack[1] = stack[-3] // @0850 stack[2] = stack[-2] // } // Block ends with call to 0x1579, returns to 0x072A label_0855: // Incoming jump from 0x02FC // Incoming call from 0x1C8D, returns to 0x1C8E // Inputs[2] // { // @0856 stack[-3] // @086E msg.sender // } 0855 5B JUMPDEST 0856 82 DUP3 0857 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 086C 81 DUP2 086D 16 AND 086E 33 CALLER 086F 14 EQ 0870 61 PUSH2 0x087c 0873 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0856 stack[0] = stack[-3] } // Block ends with conditional jump to 0x087c, if msg.sender == stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff label_0874: // Incoming jump from 0x0873, if not msg.sender == stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @0877 msg.sender } 0874 61 PUSH2 0x087c 0877 33 CALLER 0878 61 PUSH2 0x1474 087B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0874 stack[0] = 0x087c // @0877 stack[1] = msg.sender // } // Block ends with call to 0x1474, returns to 0x087C label_087C: // Incoming return from call to 0x1474 at 0x087B // Incoming jump from 0x0873, if msg.sender == stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @0880 stack[-4] // @0881 stack[-3] // @0882 stack[-2] // } 087C 5B JUMPDEST 087D 61 PUSH2 0x0887 0880 84 DUP5 0881 84 DUP5 0882 84 DUP5 0883 61 PUSH2 0x1664 0886 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @087D stack[0] = 0x0887 // @0880 stack[1] = stack[-4] // @0881 stack[2] = stack[-3] // @0882 stack[3] = stack[-2] // } // Block ends with call to 0x1664, returns to 0x0887 label_0887: // Incoming return from call to 0x1664 at 0x0886 // Incoming jump from 0x1CAB, if !address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Incoming return from call to 0x1A14 at 0x0AE8 // Inputs[1] { @088C stack[-5] } 0887 5B JUMPDEST 0888 50 POP 0889 50 POP 088A 50 POP 088B 50 POP 088C 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_088D: // Incoming jump from 0x031C // Incoming call from 0x0A70, returns to 0x0A71 // Inputs[4] // { // @0890 stack[-2] // @089E memory[0x00:0x40] // @08A0 memory[0x40:0x60] // @08A7 storage[keccak256(memory[0x00:0x40])] // } 088D 5B JUMPDEST 088E 60 PUSH1 0x00 0890 82 DUP3 0891 81 DUP2 0892 52 MSTORE 0893 60 PUSH1 0x0a 0895 60 PUSH1 0x20 0897 90 SWAP1 0898 81 DUP2 0899 52 MSTORE 089A 60 PUSH1 0x40 089C 80 DUP1 089D 83 DUP4 089E 20 SHA3 089F 81 DUP2 08A0 51 MLOAD 08A1 80 DUP1 08A2 83 DUP4 08A3 01 ADD 08A4 90 SWAP1 08A5 92 SWAP3 08A6 52 MSTORE 08A7 54 SLOAD 08A8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08BD 81 DUP2 08BE 16 AND 08BF 80 DUP1 08C0 83 DUP4 08C1 52 MSTORE 08C2 74 PUSH21 0x010000000000000000000000000000000000000000 08D8 90 SWAP1 08D9 91 SWAP2 08DA 04 DIV 08DB 6B PUSH12 0xffffffffffffffffffffffff 08E8 16 AND 08E9 92 SWAP3 08EA 82 DUP3 08EB 01 ADD 08EC 92 SWAP3 08ED 90 SWAP1 08EE 92 SWAP3 08EF 52 MSTORE 08F0 82 DUP3 08F1 91 SWAP2 08F2 61 PUSH2 0x0948 08F5 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @088E stack[0] = 0x00 // @0892 memory[0x00:0x20] = stack[-2] // @0899 memory[0x20:0x40] = 0x0a // @08A5 stack[2] = memory[0x40:0x60] // @08A6 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @08C1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff // @08EF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x010000000000000000000000000000000000000000 // @08F1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0948, if storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff label_08F6: // Incoming jump from 0x08F5, if not storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[4] // { // @08FA memory[0x40:0x60] // @0903 storage[0x09] // @094D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0967 stack[-4] // } 08F6 50 POP 08F7 60 PUSH1 0x40 08F9 80 DUP1 08FA 51 MLOAD 08FB 80 DUP1 08FC 82 DUP3 08FD 01 ADD 08FE 90 SWAP1 08FF 91 SWAP2 0900 52 MSTORE 0901 60 PUSH1 0x09 0903 54 SLOAD 0904 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0919 81 DUP2 091A 16 AND 091B 82 DUP3 091C 52 MSTORE 091D 74 PUSH21 0x010000000000000000000000000000000000000000 0933 90 SWAP1 0934 04 DIV 0935 6B PUSH12 0xffffffffffffffffffffffff 0942 16 AND 0943 60 PUSH1 0x20 0945 82 DUP3 0946 01 ADD 0947 52 MSTORE 0948 5B JUMPDEST 0949 60 PUSH1 0x20 094B 81 DUP2 094C 01 ADD 094D 51 MLOAD 094E 60 PUSH1 0x00 0950 90 SWAP1 0951 61 PUSH2 0x2710 0954 90 SWAP1 0955 61 PUSH2 0x096c 0958 90 SWAP1 0959 6B PUSH12 0xffffffffffffffffffffffff 0966 16 AND 0967 87 DUP8 0968 61 PUSH2 0x2660 096B 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @08FF stack[-1] = memory[0x40:0x60] // @0900 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @091C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] & 0xffffffffffffffffffffffffffffffffffffffff // @0947 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffff & storage[0x09] / 0x010000000000000000000000000000000000000000 // @0950 stack[0] = 0x00 // @0954 stack[1] = 0x2710 // @0958 stack[2] = 0x096c // @0966 stack[3] = 0xffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0967 stack[4] = stack[-4] // } // Block ends with call to 0x2660, returns to 0x096C label_096C: // Incoming return from call to 0x2660 at 0x096B // Incoming return from call to 0x2660 at 0x096B // Inputs[2] // { // @0970 stack[-2] // @0971 stack[-1] // } 096C 5B JUMPDEST 096D 61 PUSH2 0x0976 0970 91 SWAP2 0971 90 SWAP1 0972 61 PUSH2 0x267f 0975 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0970 stack[-2] = 0x0976 // @0971 stack[-1] = stack[-2] // @0971 stack[0] = stack[-1] // } // Block ends with call to 0x267f, returns to 0x0976 label_0976: // Incoming return from call to 0x267F at 0x0975 // Inputs[7] // { // @0977 stack[-1] // @0977 stack[-3] // @0978 memory[stack[-3]:stack[-3] + 0x20] // @0979 stack[-8] // @097B stack[-7] // @097D stack[-2] // @097E stack[-6] // } 0976 5B JUMPDEST 0977 91 SWAP2 0978 51 MLOAD 0979 96 SWAP7 097A 91 SWAP2 097B 95 SWAP6 097C 50 POP 097D 90 SWAP1 097E 93 SWAP4 097F 50 POP 0980 50 POP 0981 50 POP 0982 50 POP 0983 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @0979 stack[-8] = memory[stack[-3]:stack[-3] + 0x20] // @097B stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_0984: // Incoming call from 0x035D, returns to 0x025E // Inputs[1] { @0988 storage[0x0b] } 0984 5B JUMPDEST 0985 60 PUSH1 0x0b 0987 80 DUP1 0988 54 SLOAD 0989 61 PUSH2 0x0991 098C 90 SWAP1 098D 61 PUSH2 0x25de 0990 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0985 stack[0] = 0x0b // @098C stack[1] = 0x0991 // @098C stack[2] = storage[0x0b] // } // Block ends with call to 0x25de, returns to 0x0991 label_0991: // Incoming return from call to 0x25DE at 0x0990 // Inputs[4] // { // @0992 stack[-1] // @09A1 memory[0x40:0x60] // @09A9 stack[-2] // @09B4 storage[stack[-2]] // } 0991 5B JUMPDEST 0992 80 DUP1 0993 60 PUSH1 0x1f 0995 01 ADD 0996 60 PUSH1 0x20 0998 80 DUP1 0999 91 SWAP2 099A 04 DIV 099B 02 MUL 099C 60 PUSH1 0x20 099E 01 ADD 099F 60 PUSH1 0x40 09A1 51 MLOAD 09A2 90 SWAP1 09A3 81 DUP2 09A4 01 ADD 09A5 60 PUSH1 0x40 09A7 52 MSTORE 09A8 80 DUP1 09A9 92 SWAP3 09AA 91 SWAP2 09AB 90 SWAP1 09AC 81 DUP2 09AD 81 DUP2 09AE 52 MSTORE 09AF 60 PUSH1 0x20 09B1 01 ADD 09B2 82 DUP3 09B3 80 DUP1 09B4 54 SLOAD 09B5 61 PUSH2 0x09bd 09B8 90 SWAP1 09B9 61 PUSH2 0x25de 09BC 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @09A7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @09A9 stack[-2] = memory[0x40:0x60] // @09AA stack[-1] = stack[-2] // @09AB stack[0] = stack[-1] // @09AE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @09B1 stack[1] = 0x20 + memory[0x40:0x60] // @09B2 stack[2] = stack[-2] // @09B8 stack[4] = storage[stack[-2]] // @09B8 stack[3] = 0x09bd // } // Block ends with call to 0x25de, returns to 0x09BD label_09BD: // Incoming return from call to 0x25DE at 0x09BC // Inputs[1] { @09BE stack[-1] } 09BD 5B JUMPDEST 09BE 80 DUP1 09BF 15 ISZERO 09C0 61 PUSH2 0x0a0a 09C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a0a, if !stack[-1] label_09C4: // Incoming jump from 0x09C3, if not !stack[-1] // Inputs[1] { @09C4 stack[-1] } 09C4 80 DUP1 09C5 60 PUSH1 0x1f 09C7 10 LT 09C8 61 PUSH2 0x09df 09CB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09df, if 0x1f < stack[-1] label_09CC: // Incoming jump from 0x09CB, if not 0x1f < stack[-1] // Inputs[4] // { // @09D0 stack[-2] // @09D1 storage[stack[-2]] // @09D4 stack[-3] // @09D6 stack[-1] // } 09CC 61 PUSH2 0x0100 09CF 80 DUP1 09D0 83 DUP4 09D1 54 SLOAD 09D2 04 DIV 09D3 02 MUL 09D4 83 DUP4 09D5 52 MSTORE 09D6 91 SWAP2 09D7 60 PUSH1 0x20 09D9 01 ADD 09DA 91 SWAP2 09DB 61 PUSH2 0x0a0a 09DE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @09D5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @09DA stack[-1] = stack[-1] // @09DA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0a0a label_09DF: // Incoming jump from 0x09CB, if 0x1f < stack[-1] // Inputs[5] // { // @09E0 stack[-3] // @09E1 stack[-1] // @09E3 stack[-2] // @09EB memory[0x00:0x20] // @09EF storage[keccak256(memory[0x00:0x20])] // } 09DF 5B JUMPDEST 09E0 82 DUP3 09E1 01 ADD 09E2 91 SWAP2 09E3 90 SWAP1 09E4 60 PUSH1 0x00 09E6 52 MSTORE 09E7 60 PUSH1 0x20 09E9 60 PUSH1 0x00 09EB 20 SHA3 09EC 90 SWAP1 09ED 5B JUMPDEST 09EE 81 DUP2 09EF 54 SLOAD 09F0 81 DUP2 09F1 52 MSTORE 09F2 90 SWAP1 09F3 60 PUSH1 0x01 09F5 01 ADD 09F6 90 SWAP1 09F7 60 PUSH1 0x20 09F9 01 ADD 09FA 80 DUP1 09FB 83 DUP4 09FC 11 GT 09FD 61 PUSH2 0x09ed 0A00 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @09E2 stack[-3] = stack[-3] + stack[-1] // @09E6 memory[0x00:0x20] = stack[-2] // @09F1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @09F6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @09F9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x09ed, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_0A01: // Incoming jump from 0x0A00, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x0A00, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @0A01 stack[-3] // @0A02 stack[-1] // } 0A01 82 DUP3 0A02 90 SWAP1 0A03 03 SUB 0A04 60 PUSH1 0x1f 0A06 16 AND 0A07 82 DUP3 0A08 01 ADD 0A09 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0A09 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0A09 stack[-1] = stack[-3] // } // Block continues label_0A0A: // Incoming jump from 0x09DE // Incoming jump from 0x0A09 // Incoming jump from 0x09C3, if !stack[-1] // Inputs[1] { @0A10 stack[-7] } 0A0A 5B JUMPDEST 0A0B 50 POP 0A0C 50 POP 0A0D 50 POP 0A0E 50 POP 0A0F 50 POP 0A10 81 DUP2 0A11 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_0A12: // Incoming jump from 0x037D 0A12 5B JUMPDEST 0A13 61 PUSH2 0x0a1a 0A16 61 PUSH2 0x122c 0A19 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A13 stack[0] = 0x0a1a } // Block ends with call to 0x122c, returns to 0x0A1A label_0A1A: // Incoming return from call to 0x122C at 0x0A19 // Inputs[2] // { // @0A1E stack[-1] // @0A1F memory[stack[-1]:stack[-1] + 0x20] // } 0A1A 5B JUMPDEST 0A1B 60 PUSH1 0x00 0A1D 5B JUMPDEST 0A1E 81 DUP2 0A1F 51 MLOAD 0A20 81 DUP2 0A21 10 LT 0A22 15 ISZERO 0A23 61 PUSH2 0x0741 0A26 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A1B stack[0] = 0x00 } // Block ends with conditional jump to 0x0741, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0A27: // Incoming jump from 0x0A26, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0A26, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0A2A stack[-2] // @0A2B stack[-1] // @0A2D memory[stack[-2]:stack[-2] + 0x20] // } 0A27 61 PUSH2 0x0a4a 0A2A 82 DUP3 0A2B 82 DUP3 0A2C 81 DUP2 0A2D 51 MLOAD 0A2E 81 DUP2 0A2F 10 LT 0A30 61 PUSH2 0x0a3b 0A33 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0A27 stack[0] = 0x0a4a // @0A2A stack[1] = stack[-2] // @0A2B stack[2] = stack[-1] // } // Block ends with conditional call to 0x0a3b, returns to 0x0A4A, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_0A34: // Incoming jump from 0x0A33, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 0A34 61 PUSH2 0x0a3b 0A37 61 PUSH2 0x26ba 0A3A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A34 stack[0] = 0x0a3b } // Block ends with unconditional jump to 0x26ba label_0A3B: // Incoming call from 0x0A33, returns to 0x0A4A, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @0A3E stack[-1] // @0A42 stack[-2] // @0A43 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 0A3B 5B JUMPDEST 0A3C 60 PUSH1 0x20 0A3E 02 MUL 0A3F 60 PUSH1 0x20 0A41 01 ADD 0A42 01 ADD 0A43 51 MLOAD 0A44 60 PUSH1 0x01 0A46 61 PUSH2 0x18d6 0A49 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0A43 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0A44 stack[-1] = 0x01 // } // Block ends with unconditional jump to 0x18d6 label_0A4A: // Incoming return from call to 0x0A3B at 0x0A33 // Inputs[1] { @0A4B stack[-1] } 0A4A 5B JUMPDEST 0A4B 80 DUP1 0A4C 61 PUSH2 0x0a54 0A4F 81 DUP2 0A50 61 PUSH2 0x26e9 0A53 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0A4B stack[0] = stack[-1] // @0A4C stack[1] = 0x0a54 // @0A4F stack[2] = stack[-1] // } // Block ends with call to 0x26e9, returns to 0x0A54 label_0A54: // Incoming return from call to 0x26E9 at 0x0A53 // Inputs[2] // { // @0A55 stack[-3] // @0A55 stack[-1] // } 0A54 5B JUMPDEST 0A55 91 SWAP2 0A56 50 POP 0A57 50 POP 0A58 61 PUSH2 0x0a1d 0A5B 56 *JUMP // Stack delta = -2 // Outputs[1] { @0A55 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x0a1d label_0A5C: // Incoming call from 0x0392, returns to 0x0227 0A5C 5B JUMPDEST 0A5D 61 PUSH2 0x0a64 0A60 61 PUSH2 0x122c 0A63 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A5D stack[0] = 0x0a64 } // Block ends with call to 0x122c, returns to 0x0A64 label_0A64: // Incoming return from call to 0x122C at 0x0A63 0A64 5B JUMPDEST 0A65 60 PUSH1 0x00 0A67 61 PUSH2 0x0a71 0A6A 60 PUSH1 0x00 0A6C 80 DUP1 0A6D 61 PUSH2 0x088d 0A70 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0A65 stack[0] = 0x00 // @0A67 stack[1] = 0x0a71 // @0A6A stack[2] = 0x00 // @0A6C stack[3] = 0x00 // } // Block ends with call to 0x088d, returns to 0x0A71 label_0A71: // Incoming return from call to 0x088D at 0x0A70 // Inputs[7] // { // @0A75 memory[0x40:0x60] // @0A76 stack[-2] // @0A77 stack[-3] // @0A91 address(this).balance // @0A91 address(this) // @0AA1 address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0AA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 0A71 5B JUMPDEST 0A72 50 POP 0A73 60 PUSH1 0x40 0A75 51 MLOAD 0A76 90 SWAP1 0A77 91 SWAP2 0A78 50 POP 0A79 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A8E 82 DUP3 0A8F 16 AND 0A90 90 SWAP1 0A91 47 SELFBALANCE 0A92 80 DUP1 0A93 15 ISZERO 0A94 61 PUSH2 0x08fc 0A97 02 MUL 0A98 91 SWAP2 0A99 60 PUSH1 0x00 0A9B 81 DUP2 0A9C 81 DUP2 0A9D 81 DUP2 0A9E 85 DUP6 0A9F 88 DUP9 0AA0 88 DUP9 0AA1 F1 CALL 0AA2 93 SWAP4 0AA3 50 POP 0AA4 50 POP 0AA5 50 POP 0AA6 50 POP 0AA7 15 ISZERO 0AA8 80 DUP1 0AA9 15 ISZERO 0AAA 61 PUSH2 0x0741 0AAD 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @0A77 stack[-3] = stack[-2] // @0AA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0AA7 stack[-2] = !address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0741, if !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0AAE: // Incoming jump from 0x0AAD, if not !!address(stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0AAE returndata.length // @0AB2 returndata[0x00:0x00 + returndata.length] // @0AB3 returndata.length // @0AB6 memory[0x00:0x00 + returndata.length] // } 0AAE 3D RETURNDATASIZE 0AAF 60 PUSH1 0x00 0AB1 80 DUP1 0AB2 3E RETURNDATACOPY 0AB3 3D RETURNDATASIZE 0AB4 60 PUSH1 0x00 0AB6 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AB2 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0AB6 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0AB7: // Incoming jump from 0x03C7 // Inputs[2] // { // @0AB8 stack[-3] // @0AD0 msg.sender // } 0AB7 5B JUMPDEST 0AB8 82 DUP3 0AB9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0ACE 81 DUP2 0ACF 16 AND 0AD0 33 CALLER 0AD1 14 EQ 0AD2 61 PUSH2 0x0ade 0AD5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0AB8 stack[0] = stack[-3] } // Block ends with conditional jump to 0x0ade, if msg.sender == stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff label_0AD6: // Incoming jump from 0x0AD5, if not msg.sender == stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @0AD9 msg.sender } 0AD6 61 PUSH2 0x0ade 0AD9 33 CALLER 0ADA 61 PUSH2 0x1474 0ADD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0AD6 stack[0] = 0x0ade // @0AD9 stack[1] = msg.sender // } // Block ends with call to 0x1474, returns to 0x0ADE label_0ADE: // Incoming jump from 0x0AD5, if msg.sender == stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // Incoming return from call to 0x1474 at 0x0ADD // Inputs[3] // { // @0AE2 stack[-4] // @0AE3 stack[-3] // @0AE4 stack[-2] // } 0ADE 5B JUMPDEST 0ADF 61 PUSH2 0x0887 0AE2 84 DUP5 0AE3 84 DUP5 0AE4 84 DUP5 0AE5 61 PUSH2 0x1a14 0AE8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0ADF stack[0] = 0x0887 // @0AE2 stack[1] = stack[-4] // @0AE3 stack[2] = stack[-3] // @0AE4 stack[3] = stack[-2] // } // Block ends with call to 0x1a14, returns to 0x0887 label_0AE9: // Incoming jump from 0x03E7 0AE9 5B JUMPDEST 0AEA 61 PUSH2 0x0af1 0AED 61 PUSH2 0x122c 0AF0 56 *JUMP // Stack delta = +1 // Outputs[1] { @0AEA stack[0] = 0x0af1 } // Block ends with call to 0x122c, returns to 0x0AF1 label_0AF1: // Incoming return from call to 0x122C at 0x0AF0 // Inputs[1] { @0AF7 stack[-1] } 0AF1 5B JUMPDEST 0AF2 60 PUSH1 0x0b 0AF4 61 PUSH2 0x0741 0AF7 82 DUP3 0AF8 82 DUP3 0AF9 61 PUSH2 0x2749 0AFC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AF2 stack[0] = 0x0b // @0AF4 stack[1] = 0x0741 // @0AF7 stack[2] = stack[-1] // @0AF8 stack[3] = 0x0b // } // Block ends with call to 0x2749, returns to 0x0741 label_0AFD: // Incoming jump from 0x0407 // Inputs[1] { @0B00 stack[-1] } 0AFD 5B JUMPDEST 0AFE 60 PUSH1 0x60 0B00 81 DUP2 0B01 60 PUSH1 0x00 0B03 81 DUP2 0B04 67 PUSH8 0xffffffffffffffff 0B0D 81 DUP2 0B0E 11 GT 0B0F 15 ISZERO 0B10 61 PUSH2 0x0b1b 0B13 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0AFE stack[0] = 0x60 // @0B00 stack[1] = stack[-1] // @0B01 stack[2] = 0x00 // @0B03 stack[3] = stack[-1] // } // Block ends with conditional jump to 0x0b1b, if !(stack[-1] > 0xffffffffffffffff) label_0B14: // Incoming jump from 0x0B13, if not !(stack[-1] > 0xffffffffffffffff) 0B14 61 PUSH2 0x0b1b 0B17 61 PUSH2 0x1fae 0B1A 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B14 stack[0] = 0x0b1b } // Block ends with unconditional jump to 0x1fae label_0B1B: // Incoming jump from 0x0B13, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0B1E memory[0x40:0x60] // @0B1F stack[-1] // } 0B1B 5B JUMPDEST 0B1C 60 PUSH1 0x40 0B1E 51 MLOAD 0B1F 90 SWAP1 0B20 80 DUP1 0B21 82 DUP3 0B22 52 MSTORE 0B23 80 DUP1 0B24 60 PUSH1 0x20 0B26 02 MUL 0B27 60 PUSH1 0x20 0B29 01 ADD 0B2A 82 DUP3 0B2B 01 ADD 0B2C 60 PUSH1 0x40 0B2E 52 MSTORE 0B2F 80 DUP1 0B30 15 ISZERO 0B31 61 PUSH2 0x0b6d 0B34 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0B1F stack[-1] = memory[0x40:0x60] // @0B1F stack[0] = stack[-1] // @0B22 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0B2E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0b6d, if !stack[-1] label_0B35: // Incoming jump from 0x0B34, if not !stack[-1] // Inputs[3] // { // @0B35 stack[-2] // @0B3D memory[0x40:0x60] // @0B62 stack[-1] // } 0B35 81 DUP2 0B36 60 PUSH1 0x20 0B38 01 ADD 0B39 5B JUMPDEST 0B3A 60 PUSH1 0x40 0B3C 80 DUP1 0B3D 51 MLOAD 0B3E 60 PUSH1 0x80 0B40 81 DUP2 0B41 01 ADD 0B42 82 DUP3 0B43 52 MSTORE 0B44 60 PUSH1 0x00 0B46 80 DUP1 0B47 82 DUP3 0B48 52 MSTORE 0B49 60 PUSH1 0x20 0B4B 80 DUP1 0B4C 83 DUP4 0B4D 01 ADD 0B4E 82 DUP3 0B4F 90 SWAP1 0B50 52 MSTORE 0B51 92 SWAP3 0B52 82 DUP3 0B53 01 ADD 0B54 81 DUP2 0B55 90 SWAP1 0B56 52 MSTORE 0B57 60 PUSH1 0x60 0B59 82 DUP3 0B5A 01 ADD 0B5B 52 MSTORE 0B5C 82 DUP3 0B5D 52 MSTORE 0B5E 60 PUSH1 0x00 0B60 19 NOT 0B61 90 SWAP1 0B62 92 SWAP3 0B63 01 ADD 0B64 91 SWAP2 0B65 01 ADD 0B66 81 DUP2 0B67 61 PUSH2 0x0b39 0B6A 57 *JUMPI // Stack delta = +1 // Outputs[8] // { // @0B43 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @0B48 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0B50 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0B56 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @0B5B memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @0B5D memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = memory[0x40:0x60] // @0B64 stack[-1] = stack[-1] + ~0x00 // @0B65 stack[0] = 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0b39, if stack[-1] + ~0x00 label_0B6B: // Incoming jump from 0x0B6A, if not stack[-2] + ~0x00 // Incoming jump from 0x0B6A, if not stack[-1] + ~0x00 // Inputs[2] // { // @0B6B stack[-2] // @0B6B stack[-1] // } 0B6B 90 SWAP1 0B6C 50 POP // Stack delta = -1 // Outputs[1] { @0B6B stack[-2] = stack[-1] } // Block continues label_0B6D: // Incoming jump from 0x0B34, if !stack[-1] // Incoming jump from 0x0B6C // Inputs[3] // { // @0B6F stack[-3] // @0B6F stack[-2] // @0B74 stack[-4] // } 0B6D 5B JUMPDEST 0B6E 50 POP 0B6F 90 SWAP1 0B70 50 POP 0B71 60 PUSH1 0x00 0B73 5B JUMPDEST 0B74 82 DUP3 0B75 81 DUP2 0B76 14 EQ 0B77 61 PUSH2 0x0bc0 0B7A 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @0B6F stack[-3] = stack[-2] // @0B71 stack[-2] = 0x00 // } // Block ends with conditional jump to 0x0bc0, if 0x00 == stack[-4] label_0B7B: // Incoming jump from 0x0B7A, if not 0x00 == stack[-4] // Incoming jump from 0x0B7A, if not stack[-1] == stack[-3] // Inputs[3] // { // @0B7E stack[-6] // @0B7F stack[-5] // @0B80 stack[-1] // } 0B7B 61 PUSH2 0x0b9b 0B7E 86 DUP7 0B7F 86 DUP7 0B80 83 DUP4 0B81 81 DUP2 0B82 81 DUP2 0B83 10 LT 0B84 61 PUSH2 0x0b8f 0B87 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0B7B stack[0] = 0x0b9b // @0B7E stack[1] = stack[-6] // @0B7F stack[2] = stack[-5] // @0B80 stack[3] = stack[-1] // } // Block ends with conditional call to 0x0b8f, returns to 0x0B9B, if stack[-1] < stack[-5] label_0B88: // Incoming jump from 0x0B87, if not stack[-1] < stack[-5] 0B88 61 PUSH2 0x0b8f 0B8B 61 PUSH2 0x26ba 0B8E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B88 stack[0] = 0x0b8f } // Block ends with unconditional jump to 0x26ba label_0B8F: // Incoming call from 0x0B87, returns to 0x0B9B, if stack[-1] < stack[-5] // Inputs[4] // { // @0B90 stack[-2] // @0B90 stack[-1] // @0B95 stack[-3] // @0B96 msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] // } 0B8F 5B JUMPDEST 0B90 90 SWAP1 0B91 50 POP 0B92 60 PUSH1 0x20 0B94 02 MUL 0B95 01 ADD 0B96 35 CALLDATALOAD 0B97 61 PUSH2 0x0fba 0B9A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0B96 stack[-3] = msg.data[0x20 * stack[-1] + stack[-3]:0x20 * stack[-1] + stack[-3] + 0x20] } // Block ends with unconditional jump to 0x0fba label_0B9B: // Incoming return from call to 0x0B8F at 0x0B87 // Incoming return from call to 0x0B8F at 0x0B87 // Inputs[3] // { // @0B9C stack[-3] // @0B9D stack[-2] // @0B9F memory[stack[-3]:stack[-3] + 0x20] // } 0B9B 5B JUMPDEST 0B9C 82 DUP3 0B9D 82 DUP3 0B9E 81 DUP2 0B9F 51 MLOAD 0BA0 81 DUP2 0BA1 10 LT 0BA2 61 PUSH2 0x0bad 0BA5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0B9C stack[0] = stack[-3] // @0B9D stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0bad, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] label_0BA6: // Incoming jump from 0x0BA5, if not stack[-2] < memory[stack[-3]:stack[-3] + 0x20] 0BA6 61 PUSH2 0x0bad 0BA9 61 PUSH2 0x26ba 0BAC 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BA6 stack[0] = 0x0bad } // Block ends with unconditional jump to 0x26ba label_0BAD: // Incoming jump from 0x0BA5, if stack[-2] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[4] // { // @0BB0 stack[-1] // @0BB3 stack[-2] // @0BB8 stack[-3] // @0BBB stack[-4] // } 0BAD 5B JUMPDEST 0BAE 60 PUSH1 0x20 0BB0 90 SWAP1 0BB1 81 DUP2 0BB2 02 MUL 0BB3 91 SWAP2 0BB4 90 SWAP1 0BB5 91 SWAP2 0BB6 01 ADD 0BB7 01 ADD 0BB8 52 MSTORE 0BB9 60 PUSH1 0x01 0BBB 01 ADD 0BBC 61 PUSH2 0x0b73 0BBF 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0BB8 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @0BBB stack[-4] = 0x01 + stack[-4] // } // Block ends with unconditional jump to 0x0b73 label_0BC0: // Incoming jump from 0x0B7A, if 0x00 == stack[-4] // Incoming jump from 0x0B7A, if stack[-1] == stack[-3] // Inputs[3] // { // @0BC2 stack[-7] // @0BC2 stack[-2] // @0BC3 stack[-6] // } 0BC0 5B JUMPDEST 0BC1 50 POP 0BC2 94 SWAP5 0BC3 93 SWAP4 0BC4 50 POP 0BC5 50 POP 0BC6 50 POP 0BC7 50 POP 0BC8 56 *JUMP // Stack delta = -6 // Outputs[1] { @0BC2 stack[-7] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_0BC9: // Incoming call from 0x1583, returns to 0x1584 // Incoming jump from 0x0434 // Inputs[1] { @0BCF stack[-1] } 0BC9 5B JUMPDEST 0BCA 60 PUSH1 0x00 0BCC 61 PUSH2 0x0643 0BCF 82 DUP3 0BD0 61 PUSH2 0x1a2f 0BD3 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0BCA stack[0] = 0x00 // @0BCC stack[1] = 0x0643 // @0BCF stack[2] = stack[-1] // } // Block ends with call to 0x1a2f, returns to 0x0643 label_0BD4: // Incoming jump from 0x0454 // Incoming call from 0x0C79, returns to 0x0C7A // Incoming call from 0x0E11, returns to 0x0E12 // Incoming call from 0x0E11, returns to 0x0E12 // Inputs[1] { @0BEC stack[-1] } 0BD4 5B JUMPDEST 0BD5 60 PUSH1 0x00 0BD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0BEC 82 DUP3 0BED 16 AND 0BEE 61 PUSH2 0x0c23 0BF1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BD5 stack[0] = 0x00 } // Block ends with conditional jump to 0x0c23, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_0BF2: // Incoming jump from 0x0BF1, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @0BF4 memory[0x40:0x60] // @0C1D memory[0x40:0x60] // @0C22 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0BF2 60 PUSH1 0x40 0BF4 51 MLOAD 0BF5 7F PUSH32 0x8f4eb60400000000000000000000000000000000000000000000000000000000 0C16 81 DUP2 0C17 52 MSTORE 0C18 60 PUSH1 0x04 0C1A 01 ADD 0C1B 60 PUSH1 0x40 0C1D 51 MLOAD 0C1E 80 DUP1 0C1F 91 SWAP2 0C20 03 SUB 0C21 90 SWAP1 0C22 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C17 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8f4eb60400000000000000000000000000000000000000000000000000000000 // @0C22 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C23: // Incoming jump from 0x0BF1, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[4] // { // @0C3A stack[-2] // @0C48 memory[0x00:0x40] // @0C49 storage[keccak256(memory[0x00:0x40])] // @0C54 stack[-3] // } 0C23 5B JUMPDEST 0C24 50 POP 0C25 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C3A 16 AND 0C3B 60 PUSH1 0x00 0C3D 90 SWAP1 0C3E 81 DUP2 0C3F 52 MSTORE 0C40 60 PUSH1 0x05 0C42 60 PUSH1 0x20 0C44 52 MSTORE 0C45 60 PUSH1 0x40 0C47 90 SWAP1 0C48 20 SHA3 0C49 54 SLOAD 0C4A 67 PUSH8 0xffffffffffffffff 0C53 16 AND 0C54 90 SWAP1 0C55 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0C3F memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @0C44 memory[0x20:0x40] = 0x05 // @0C54 stack[-3] = 0xffffffffffffffff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0C56: // Incoming jump from 0x0469 0C56 5B JUMPDEST 0C57 61 PUSH2 0x0c5e 0C5A 61 PUSH2 0x122c 0C5D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C57 stack[0] = 0x0c5e } // Block ends with call to 0x122c, returns to 0x0C5E label_0C5E: // Incoming return from call to 0x122C at 0x0C5D 0C5E 5B JUMPDEST 0C5F 61 PUSH2 0x0c68 0C62 60 PUSH1 0x00 0C64 61 PUSH2 0x1ad0 0C67 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0C5F stack[0] = 0x0c68 // @0C62 stack[1] = 0x00 // } // Block ends with call to 0x1ad0, returns to 0x0C68 label_0C68: // Incoming jump from 0x124B, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x08] // Incoming return from call to 0x1AD0 at 0x0C67 // Inputs[1] { @0C69 stack[-1] } 0C68 5B JUMPDEST 0C69 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0C6A: // Incoming jump from 0x0489 // Inputs[1] { @0C75 stack[-1] } 0C6A 5B JUMPDEST 0C6B 60 PUSH1 0x60 0C6D 60 PUSH1 0x00 0C6F 80 DUP1 0C70 60 PUSH1 0x00 0C72 61 PUSH2 0x0c7a 0C75 85 DUP6 0C76 61 PUSH2 0x0bd4 0C79 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @0C6B stack[0] = 0x60 // @0C6D stack[1] = 0x00 // @0C6F stack[2] = 0x00 // @0C70 stack[3] = 0x00 // @0C72 stack[4] = 0x0c7a // @0C75 stack[5] = stack[-1] // } // Block ends with call to 0x0bd4, returns to 0x0C7A label_0C7A: // Incoming return from call to 0x0BD4 at 0x0C79 // Inputs[2] // { // @0C7B stack[-2] // @0C7B stack[-1] // } 0C7A 5B JUMPDEST 0C7B 90 SWAP1 0C7C 50 POP 0C7D 60 PUSH1 0x00 0C7F 81 DUP2 0C80 67 PUSH8 0xffffffffffffffff 0C89 81 DUP2 0C8A 11 GT 0C8B 15 ISZERO 0C8C 61 PUSH2 0x0c97 0C8F 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0C7B stack[-2] = stack[-1] // @0C7D stack[-1] = 0x00 // @0C7F stack[0] = stack[-1] // } // Block ends with conditional jump to 0x0c97, if !(stack[-1] > 0xffffffffffffffff) label_0C90: // Incoming jump from 0x0C8F, if not !(stack[-1] > 0xffffffffffffffff) 0C90 61 PUSH2 0x0c97 0C93 61 PUSH2 0x1fae 0C96 56 *JUMP // Stack delta = +1 // Outputs[1] { @0C90 stack[0] = 0x0c97 } // Block ends with unconditional jump to 0x1fae label_0C97: // Incoming jump from 0x0C8F, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0C9A memory[0x40:0x60] // @0C9B stack[-1] // } 0C97 5B JUMPDEST 0C98 60 PUSH1 0x40 0C9A 51 MLOAD 0C9B 90 SWAP1 0C9C 80 DUP1 0C9D 82 DUP3 0C9E 52 MSTORE 0C9F 80 DUP1 0CA0 60 PUSH1 0x20 0CA2 02 MUL 0CA3 60 PUSH1 0x20 0CA5 01 ADD 0CA6 82 DUP3 0CA7 01 ADD 0CA8 60 PUSH1 0x40 0CAA 52 MSTORE 0CAB 80 DUP1 0CAC 15 ISZERO 0CAD 61 PUSH2 0x0cc0 0CB0 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0C9B stack[-1] = memory[0x40:0x60] // @0C9B stack[0] = stack[-1] // @0C9E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0CAA memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0cc0, if !stack[-1] label_0CB1: // Incoming jump from 0x0CB0, if not !stack[-1] // Inputs[8] // { // @0CB1 stack[-2] // @0CB7 stack[-1] // @0CBA msg.data.length // @0CBC msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0CC5 memory[0x40:0x60] // @0CE7 stack[-3] // @0CEC stack[-4] // @0CED stack[-6] // } 0CB1 81 DUP2 0CB2 60 PUSH1 0x20 0CB4 01 ADD 0CB5 60 PUSH1 0x20 0CB7 82 DUP3 0CB8 02 MUL 0CB9 80 DUP1 0CBA 36 CALLDATASIZE 0CBB 83 DUP4 0CBC 37 CALLDATACOPY 0CBD 01 ADD 0CBE 90 SWAP1 0CBF 50 POP 0CC0 5B JUMPDEST 0CC1 50 POP 0CC2 60 PUSH1 0x40 0CC4 80 DUP1 0CC5 51 MLOAD 0CC6 60 PUSH1 0x80 0CC8 81 DUP2 0CC9 01 ADD 0CCA 82 DUP3 0CCB 52 MSTORE 0CCC 60 PUSH1 0x00 0CCE 80 DUP1 0CCF 82 DUP3 0CD0 52 MSTORE 0CD1 60 PUSH1 0x20 0CD3 82 DUP3 0CD4 01 ADD 0CD5 81 DUP2 0CD6 90 SWAP1 0CD7 52 MSTORE 0CD8 91 SWAP2 0CD9 81 DUP2 0CDA 01 ADD 0CDB 82 DUP3 0CDC 90 SWAP1 0CDD 52 MSTORE 0CDE 60 PUSH1 0x60 0CE0 81 DUP2 0CE1 01 ADD 0CE2 91 SWAP2 0CE3 90 SWAP1 0CE4 91 SWAP2 0CE5 52 MSTORE 0CE6 90 SWAP1 0CE7 91 SWAP2 0CE8 50 POP 0CE9 60 PUSH1 0x01 0CEB 5B JUMPDEST 0CEC 83 DUP4 0CED 86 DUP7 0CEE 14 EQ 0CEF 61 PUSH2 0x0d89 0CF2 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @0CBC memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0CCB memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @0CD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0CD7 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0CDD memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @0CE5 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @0CE6 stack[-2] = memory[0x40:0x60] // @0CE7 stack[-3] = stack[-2] // @0CE9 stack[-1] = 0x01 // } // Block ends with conditional jump to 0x0d89, if stack[-6] == stack[-4] label_0CF3: // Incoming jump from 0x0CF2, if not stack[-6] == stack[-4] // Incoming jump from 0x0CF2, if not stack[-6] == stack[-4] // Incoming jump from 0x0CF2, if not stack[-6] == stack[-4] // Inputs[1] { @0CF6 stack[-1] } 0CF3 61 PUSH2 0x0cfb 0CF6 81 DUP2 0CF7 61 PUSH2 0x1b47 0CFA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CF3 stack[0] = 0x0cfb // @0CF6 stack[1] = stack[-1] // } // Block ends with call to 0x1b47, returns to 0x0CFB label_0CFB: // Incoming return from call to 0x1B47 at 0x0CFA // Inputs[3] // { // @0CFC stack[-3] // @0CFC stack[-1] // @0D02 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 0CFB 5B JUMPDEST 0CFC 91 SWAP2 0CFD 50 POP 0CFE 81 DUP2 0CFF 60 PUSH1 0x40 0D01 01 ADD 0D02 51 MLOAD 0D03 61 PUSH2 0x0d81 0D06 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0CFC stack[-3] = stack[-1] } // Block ends with conditional jump to 0x0d81, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_0D07: // Incoming jump from 0x0D06, if not memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[2] // { // @0D07 stack[-2] // @0D08 memory[stack[-2]:stack[-2] + 0x20] // } 0D07 81 DUP2 0D08 51 MLOAD 0D09 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D1E 16 AND 0D1F 15 ISZERO 0D20 61 PUSH2 0x0d28 0D23 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d28, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20]) label_0D24: // Incoming jump from 0x0D23, if not !(0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @0D24 stack[-2] // @0D25 memory[stack[-2]:stack[-2] + 0x20] // @0D26 stack[-5] // @0D29 stack[-8] // } 0D24 81 DUP2 0D25 51 MLOAD 0D26 94 SWAP5 0D27 50 POP 0D28 5B JUMPDEST 0D29 87 DUP8 0D2A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D3F 16 AND 0D40 85 DUP6 0D41 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D56 16 AND 0D57 03 SUB 0D58 61 PUSH2 0x0d81 0D5B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0D26 stack[-5] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0d81, if (0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-8]) label_0D5C: // Incoming jump from 0x0D5B, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-5]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-8]) // Incoming jump from 0x0D5B, if not (0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-8]) // Inputs[4] // { // @0D5C stack[-1] // @0D5D stack[-3] // @0D5E stack[-6] // @0D66 memory[stack[-3]:stack[-3] + 0x20] // } 0D5C 80 DUP1 0D5D 83 DUP4 0D5E 87 DUP8 0D5F 80 DUP1 0D60 60 PUSH1 0x01 0D62 01 ADD 0D63 98 SWAP9 0D64 50 POP 0D65 81 DUP2 0D66 51 MLOAD 0D67 81 DUP2 0D68 10 LT 0D69 61 PUSH2 0x0d74 0D6C 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @0D5C stack[0] = stack[-1] // @0D5D stack[1] = stack[-3] // @0D5E stack[2] = stack[-6] // @0D63 stack[-6] = 0x01 + stack[-6] // } // Block ends with conditional jump to 0x0d74, if stack[-6] < memory[stack[-3]:stack[-3] + 0x20] label_0D6D: // Incoming jump from 0x0D6C, if not stack[-6] < memory[stack[-3]:stack[-3] + 0x20] 0D6D 61 PUSH2 0x0d74 0D70 61 PUSH2 0x26ba 0D73 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D6D stack[0] = 0x0d74 } // Block ends with unconditional jump to 0x26ba label_0D74: // Incoming jump from 0x0D6C, if stack[-6] < memory[stack[-3]:stack[-3] + 0x20] // Inputs[3] // { // @0D77 stack[-1] // @0D7B stack[-2] // @0D7C stack[-3] // } 0D74 5B JUMPDEST 0D75 60 PUSH1 0x20 0D77 02 MUL 0D78 60 PUSH1 0x20 0D7A 01 ADD 0D7B 01 ADD 0D7C 81 DUP2 0D7D 81 DUP2 0D7E 52 MSTORE 0D7F 50 POP 0D80 50 POP // Stack delta = -3 // Outputs[1] { @0D7E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] } // Block continues label_0D81: // Incoming jump from 0x0D06, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Incoming jump from 0x0D5B, if (0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-8]) // Incoming jump from 0x0D80 // Incoming jump from 0x0D5B, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-5]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-8]) // Inputs[1] { @0D84 stack[-1] } 0D81 5B JUMPDEST 0D82 60 PUSH1 0x01 0D84 01 ADD 0D85 61 PUSH2 0x0ceb 0D88 56 *JUMP // Stack delta = +0 // Outputs[1] { @0D84 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x0ceb label_0D89: // Incoming jump from 0x23AF, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0CF2, if stack[-6] == stack[-4] // Incoming jump from 0x0CF2, if stack[-6] == stack[-4] // Incoming jump from 0x2454, if !(stack[-1] < stack[-2]) // Incoming jump from 0x0CF2, if stack[-6] == stack[-4] // Incoming jump from 0x2454, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x23AF, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @0D8B stack[-2] // @0D8B stack[-3] // @0D8C stack[-9] // @0D8D stack[-8] // } 0D89 5B JUMPDEST 0D8A 50 POP 0D8B 90 SWAP1 0D8C 96 SWAP7 0D8D 95 SWAP6 0D8E 50 POP 0D8F 50 POP 0D90 50 POP 0D91 50 POP 0D92 50 POP 0D93 50 POP 0D94 56 *JUMP // Stack delta = -8 // Outputs[1] { @0D8C stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] label_0D95: // Incoming call from 0x04D6, returns to 0x025E // Inputs[1] { @0D9B storage[0x03] } 0D95 5B JUMPDEST 0D96 60 PUSH1 0x60 0D98 60 PUSH1 0x03 0D9A 80 DUP1 0D9B 54 SLOAD 0D9C 61 PUSH2 0x0754 0D9F 90 SWAP1 0DA0 61 PUSH2 0x25de 0DA3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D96 stack[0] = 0x60 // @0D98 stack[1] = 0x03 // @0D9F stack[2] = 0x0754 // @0D9F stack[3] = storage[0x03] // } // Block ends with call to 0x25de, returns to 0x0754 label_0DA4: // Incoming jump from 0x04F6 // Inputs[2] // { // @0DA7 stack[-1] // @0DA8 stack[-2] // } 0DA4 5B JUMPDEST 0DA5 60 PUSH1 0x60 0DA7 81 DUP2 0DA8 83 DUP4 0DA9 10 LT 0DAA 61 PUSH2 0x0ddf 0DAD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DA5 stack[0] = 0x60 } // Block ends with conditional jump to 0x0ddf, if stack[-2] < stack[-1] label_0DAE: // Incoming jump from 0x0DAD, if not stack[-2] < stack[-1] // Inputs[3] // { // @0DB0 memory[0x40:0x60] // @0DD9 memory[0x40:0x60] // @0DDE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DAE 60 PUSH1 0x40 0DB0 51 MLOAD 0DB1 7F PUSH32 0x32c1995a00000000000000000000000000000000000000000000000000000000 0DD2 81 DUP2 0DD3 52 MSTORE 0DD4 60 PUSH1 0x04 0DD6 01 ADD 0DD7 60 PUSH1 0x40 0DD9 51 MLOAD 0DDA 80 DUP1 0DDB 91 SWAP2 0DDC 03 SUB 0DDD 90 SWAP1 0DDE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DD3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x32c1995a00000000000000000000000000000000000000000000000000000000 // @0DDE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0DDF: // Incoming jump from 0x0DAD, if stack[-2] < stack[-1] // Inputs[1] { @0DE8 storage[0x00] } 0DDF 5B JUMPDEST 0DE0 60 PUSH1 0x00 0DE2 80 DUP1 0DE3 61 PUSH2 0x0deb 0DE6 60 PUSH1 0x00 0DE8 54 SLOAD 0DE9 90 SWAP1 0DEA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0DE0 stack[0] = 0x00 // @0DE2 stack[1] = 0x00 // @0DE9 stack[2] = storage[0x00] // } // Block ends with unconditional jump to 0x0deb label_0DEB: // Incoming jump from 0x0DEA // Inputs[3] // { // @0DEC stack[-2] // @0DEC stack[-1] // @0DF0 stack[-6] // } 0DEB 5B JUMPDEST 0DEC 90 SWAP1 0DED 50 POP 0DEE 60 PUSH1 0x01 0DF0 85 DUP6 0DF1 10 LT 0DF2 15 ISZERO 0DF3 61 PUSH2 0x0dfb 0DF6 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0DEC stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0dfb, if !(stack[-6] < 0x01) label_0DF7: // Incoming jump from 0x0DF6, if not !(stack[-6] < 0x01) // Inputs[3] // { // @0DF9 stack[-5] // @0DFC stack[-1] // @0DFD stack[-4] // } 0DF7 60 PUSH1 0x01 0DF9 94 SWAP5 0DFA 50 POP 0DFB 5B JUMPDEST 0DFC 80 DUP1 0DFD 84 DUP5 0DFE 11 GT 0DFF 15 ISZERO 0E00 61 PUSH2 0x0e07 0E03 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0DF9 stack[-5] = 0x01 } // Block ends with conditional jump to 0x0e07, if !(stack[-4] > stack[-1]) label_0E04: // Incoming jump from 0x0E03, if not !(stack[-4] > stack[-1]) // Incoming jump from 0x0E03, if not !(stack[-4] > stack[-1]) // Inputs[3] // { // @0E04 stack[-1] // @0E05 stack[-4] // @0E0D stack[-6] // } 0E04 80 DUP1 0E05 93 SWAP4 0E06 50 POP 0E07 5B JUMPDEST 0E08 60 PUSH1 0x00 0E0A 61 PUSH2 0x0e12 0E0D 87 DUP8 0E0E 61 PUSH2 0x0bd4 0E11 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0E05 stack[-4] = stack[-1] // @0E08 stack[0] = 0x00 // @0E0A stack[1] = 0x0e12 // @0E0D stack[2] = stack[-6] // } // Block ends with call to 0x0bd4, returns to 0x0E12 label_0E12: // Incoming return from call to 0x0BD4 at 0x0E11 // Incoming return from call to 0x0BD4 at 0x0E11 // Inputs[4] // { // @0E13 stack[-1] // @0E13 stack[-2] // @0E15 stack[-6] // @0E16 stack[-7] // } 0E12 5B JUMPDEST 0E13 90 SWAP1 0E14 50 POP 0E15 84 DUP5 0E16 86 DUP7 0E17 10 LT 0E18 15 ISZERO 0E19 61 PUSH2 0x0e31 0E1C 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0E13 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x0e31, if !(stack[-7] < stack[-6]) label_0E1D: // Incoming jump from 0x0E1C, if not !(stack[-7] < stack[-6]) // Inputs[3] // { // @0E1D stack[-6] // @0E1E stack[-5] // @0E20 stack[-1] // } 0E1D 85 DUP6 0E1E 85 DUP6 0E1F 03 SUB 0E20 81 DUP2 0E21 81 DUP2 0E22 10 LT 0E23 15 ISZERO 0E24 61 PUSH2 0x0e2b 0E27 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E1F stack[0] = stack[-5] - stack[-6] } // Block ends with conditional jump to 0x0e2b, if !(stack[-5] - stack[-6] < stack[-1]) label_0E28: // Incoming jump from 0x0E27, if not !(stack[-5] - stack[-6] < stack[-1]) // Inputs[2] // { // @0E28 stack[-1] // @0E29 stack[-2] // } 0E28 80 DUP1 0E29 91 SWAP2 0E2A 50 POP 0E2B 5B JUMPDEST 0E2C 50 POP 0E2D 61 PUSH2 0x0e35 0E30 56 *JUMP // Stack delta = -1 // Outputs[1] { @0E29 stack[-2] = stack[-1] } // Block ends with unconditional jump to 0x0e35 label_0E31: // Incoming jump from 0x0E1C, if !(stack[-7] < stack[-6]) 0E31 5B JUMPDEST 0E32 50 POP 0E33 60 PUSH1 0x00 0E35 5B JUMPDEST 0E36 60 PUSH1 0x00 0E38 81 DUP2 0E39 67 PUSH8 0xffffffffffffffff 0E42 81 DUP2 0E43 11 GT 0E44 15 ISZERO 0E45 61 PUSH2 0x0e50 0E48 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0E33 stack[-1] = 0x00 // @0E36 stack[0] = 0x00 // @0E38 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0e50, if !(0x00 > 0xffffffffffffffff) label_0E49: // Incoming jump from 0x0E48, if not !(0x00 > 0xffffffffffffffff) // Incoming jump from 0x0E48, if not !(stack[-1] > 0xffffffffffffffff) 0E49 61 PUSH2 0x0e50 0E4C 61 PUSH2 0x1fae 0E4F 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E49 stack[0] = 0x0e50 } // Block ends with unconditional jump to 0x1fae label_0E50: // Incoming jump from 0x0E48, if !(0x00 > 0xffffffffffffffff) // Incoming jump from 0x0E48, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @0E53 memory[0x40:0x60] // @0E54 stack[-1] // } 0E50 5B JUMPDEST 0E51 60 PUSH1 0x40 0E53 51 MLOAD 0E54 90 SWAP1 0E55 80 DUP1 0E56 82 DUP3 0E57 52 MSTORE 0E58 80 DUP1 0E59 60 PUSH1 0x20 0E5B 02 MUL 0E5C 60 PUSH1 0x20 0E5E 01 ADD 0E5F 82 DUP3 0E60 01 ADD 0E61 60 PUSH1 0x40 0E63 52 MSTORE 0E64 80 DUP1 0E65 15 ISZERO 0E66 61 PUSH2 0x0e79 0E69 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @0E54 stack[-1] = memory[0x40:0x60] // @0E54 stack[0] = stack[-1] // @0E57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0E63 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // } // Block ends with conditional jump to 0x0e79, if !stack[-1] label_0E6A: // Incoming jump from 0x0E69, if not !stack[-1] // Inputs[6] // { // @0E6A stack[-2] // @0E70 stack[-1] // @0E73 msg.data.length // @0E75 msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0E7B stack[-3] // @0E7D stack[-4] // } 0E6A 81 DUP2 0E6B 60 PUSH1 0x20 0E6D 01 ADD 0E6E 60 PUSH1 0x20 0E70 82 DUP3 0E71 02 MUL 0E72 80 DUP1 0E73 36 CALLDATASIZE 0E74 83 DUP4 0E75 37 CALLDATACOPY 0E76 01 ADD 0E77 90 SWAP1 0E78 50 POP 0E79 5B JUMPDEST 0E7A 50 POP 0E7B 90 SWAP1 0E7C 50 POP 0E7D 81 DUP2 0E7E 60 PUSH1 0x00 0E80 03 SUB 0E81 61 PUSH2 0x0e8f 0E84 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0E75 memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x20] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x20] // @0E7B stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x0e8f, if 0x00 - stack[-4] label_0E85: // Incoming jump from 0x0E84, if not 0x00 - stack[-4] // Incoming jump from 0x0E84, if not 0x00 - stack[-4] // Inputs[3] // { // @0E85 stack[-1] // @0E85 stack[-5] // @0E8A stack[-4] // } 0E85 93 SWAP4 0E86 50 POP 0E87 61 PUSH2 0x0f65 0E8A 92 SWAP3 0E8B 50 POP 0E8C 50 POP 0E8D 50 POP 0E8E 56 *JUMP // Stack delta = -4 // Outputs[1] { @0E85 stack[-5] = stack[-1] } // Block ends with unconditional jump to 0x0f65 label_0E8F: // Incoming jump from 0x0E84, if 0x00 - stack[-4] // Incoming jump from 0x0E84, if 0x00 - stack[-4] // Inputs[1] { @0E95 stack[-7] } 0E8F 5B JUMPDEST 0E90 60 PUSH1 0x00 0E92 61 PUSH2 0x0e9a 0E95 88 DUP9 0E96 61 PUSH2 0x0fba 0E99 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0E90 stack[0] = 0x00 // @0E92 stack[1] = 0x0e9a // @0E95 stack[2] = stack[-7] // } // Block ends with call to 0x0fba, returns to 0x0E9A label_0E9A: // Incoming return from call to 0x0FBA at 0x0E99 // Inputs[3] // { // @0E9B stack[-1] // @0E9B stack[-2] // @0EA3 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 0E9A 5B JUMPDEST 0E9B 90 SWAP1 0E9C 50 POP 0E9D 60 PUSH1 0x00 0E9F 81 DUP2 0EA0 60 PUSH1 0x40 0EA2 01 ADD 0EA3 51 MLOAD 0EA4 61 PUSH2 0x0eab 0EA7 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E9B stack[-2] = stack[-1] // @0E9D stack[-1] = 0x00 // } // Block ends with conditional jump to 0x0eab, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_0EA8: // Incoming jump from 0x0EA7, if not memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[4] // { // @0EA9 stack[-2] // @0EAA memory[stack[-2]:stack[-2] + 0x20] // @0EAC stack[-9] // @0EAE stack[-8] // } 0EA8 50 POP 0EA9 80 DUP1 0EAA 51 MLOAD 0EAB 5B JUMPDEST 0EAC 88 DUP9 0EAD 5B JUMPDEST 0EAE 88 DUP9 0EAF 81 DUP2 0EB0 14 EQ 0EB1 15 ISZERO 0EB2 80 DUP1 0EB3 15 ISZERO 0EB4 61 PUSH2 0x0ebd 0EB7 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0EAA stack[-1] = memory[stack[-2]:stack[-2] + 0x20] // @0EAC stack[0] = stack[-9] // @0EB1 stack[1] = !(stack[-9] == stack[-8]) // } // Block ends with conditional jump to 0x0ebd, if !!(stack[-9] == stack[-8]) label_0EB8: // Incoming jump from 0x0EB7, if not !!(stack[-9] == stack[-8]) // Incoming jump from 0x0EB7, if not !!(stack[-1] == stack[-9]) // Incoming jump from 0x0EB7, if not !!(stack[-9] == stack[-8]) // Inputs[2] // { // @0EB9 stack[-6] // @0EBA stack[-8] // } 0EB8 50 POP 0EB9 84 DUP5 0EBA 87 DUP8 0EBB 14 EQ 0EBC 15 ISZERO 0EBD 5B JUMPDEST 0EBE 15 ISZERO 0EBF 61 PUSH2 0x0f59 0EC2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f59, if !!(stack[-8] == stack[-6]) label_0EC3: // Incoming jump from 0x0EC2, if not !!(stack[-8] == stack[-6]) // Incoming jump from 0x0EC2, if not !stack[-1] // Inputs[1] { @0EC6 stack[-1] } 0EC3 61 PUSH2 0x0ecb 0EC6 81 DUP2 0EC7 61 PUSH2 0x1b47 0ECA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0EC3 stack[0] = 0x0ecb // @0EC6 stack[1] = stack[-1] // } // Block ends with call to 0x1b47, returns to 0x0ECB label_0ECB: // Incoming return from call to 0x1B47 at 0x0ECA // Inputs[3] // { // @0ECC stack[-4] // @0ECC stack[-1] // @0ED2 memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 0ECB 5B JUMPDEST 0ECC 92 SWAP3 0ECD 50 POP 0ECE 82 DUP3 0ECF 60 PUSH1 0x40 0ED1 01 ADD 0ED2 51 MLOAD 0ED3 61 PUSH2 0x0f51 0ED6 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0ECC stack[-4] = stack[-1] } // Block ends with conditional jump to 0x0f51, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_0ED7: // Incoming jump from 0x0ED6, if not memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[2] // { // @0ED7 stack[-3] // @0ED8 memory[stack[-3]:stack[-3] + 0x20] // } 0ED7 82 DUP3 0ED8 51 MLOAD 0ED9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EEE 16 AND 0EEF 15 ISZERO 0EF0 61 PUSH2 0x0ef8 0EF3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ef8, if !(0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-3]:stack[-3] + 0x20]) label_0EF4: // Incoming jump from 0x0EF3, if not !(0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-3]:stack[-3] + 0x20]) // Inputs[4] // { // @0EF4 stack[-3] // @0EF5 memory[stack[-3]:stack[-3] + 0x20] // @0EF6 stack[-2] // @0EF9 stack[-11] // } 0EF4 82 DUP3 0EF5 51 MLOAD 0EF6 91 SWAP2 0EF7 50 POP 0EF8 5B JUMPDEST 0EF9 8A DUP11 0EFA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F0F 16 AND 0F10 82 DUP3 0F11 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F26 16 AND 0F27 03 SUB 0F28 61 PUSH2 0x0f51 0F2B 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0EF6 stack[-2] = memory[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x0f51, if (0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-3]:stack[-3] + 0x20]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-11]) label_0F2C: // Incoming jump from 0x0F2B, if not (0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-3]:stack[-3] + 0x20]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-11]) // Incoming jump from 0x0F2B, if not (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-11]) // Inputs[4] // { // @0F2C stack[-1] // @0F2D stack[-4] // @0F2E stack[-7] // @0F36 memory[stack[-4]:stack[-4] + 0x20] // } 0F2C 80 DUP1 0F2D 84 DUP5 0F2E 88 DUP9 0F2F 80 DUP1 0F30 60 PUSH1 0x01 0F32 01 ADD 0F33 99 SWAP10 0F34 50 POP 0F35 81 DUP2 0F36 51 MLOAD 0F37 81 DUP2 0F38 10 LT 0F39 61 PUSH2 0x0f44 0F3C 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @0F2C stack[0] = stack[-1] // @0F2D stack[1] = stack[-4] // @0F2E stack[2] = stack[-7] // @0F33 stack[-7] = 0x01 + stack[-7] // } // Block ends with conditional jump to 0x0f44, if stack[-7] < memory[stack[-4]:stack[-4] + 0x20] label_0F3D: // Incoming jump from 0x0F3C, if not stack[-7] < memory[stack[-4]:stack[-4] + 0x20] 0F3D 61 PUSH2 0x0f44 0F40 61 PUSH2 0x26ba 0F43 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F3D stack[0] = 0x0f44 } // Block ends with unconditional jump to 0x26ba label_0F44: // Incoming jump from 0x0F3C, if stack[-7] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[3] // { // @0F47 stack[-1] // @0F4B stack[-2] // @0F4C stack[-3] // } 0F44 5B JUMPDEST 0F45 60 PUSH1 0x20 0F47 02 MUL 0F48 60 PUSH1 0x20 0F4A 01 ADD 0F4B 01 ADD 0F4C 81 DUP2 0F4D 81 DUP2 0F4E 52 MSTORE 0F4F 50 POP 0F50 50 POP // Stack delta = -3 // Outputs[1] { @0F4E memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] = stack[-3] } // Block continues label_0F51: // Incoming jump from 0x0F50 // Incoming jump from 0x0F2B, if (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-11]) // Incoming jump from 0x0ED6, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Incoming jump from 0x0F2B, if (0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-3]:stack[-3] + 0x20]) - (0xffffffffffffffffffffffffffffffffffffffff & stack[-11]) // Inputs[1] { @0F54 stack[-1] } 0F51 5B JUMPDEST 0F52 60 PUSH1 0x01 0F54 01 ADD 0F55 61 PUSH2 0x0ead 0F58 56 *JUMP // Stack delta = +0 // Outputs[1] { @0F54 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x0ead label_0F59: // Incoming jump from 0x0EC2, if !!(stack[-8] == stack[-6]) // Incoming jump from 0x0EC2, if !stack[-1] // Inputs[4] // { // @0F5D stack[-4] // @0F5D stack[-7] // @0F61 stack[-6] // @0F62 stack[-8] // } 0F59 5B JUMPDEST 0F5A 50 POP 0F5B 50 POP 0F5C 50 POP 0F5D 92 SWAP3 0F5E 83 DUP4 0F5F 52 MSTORE 0F60 50 POP 0F61 90 SWAP1 0F62 91 SWAP2 0F63 50 POP 0F64 50 POP // Stack delta = -7 // Outputs[2] // { // @0F5F memory[stack[-4]:stack[-4] + 0x20] = stack[-7] // @0F62 stack[-8] = stack[-4] // } // Block continues label_0F65: // Incoming return from call to 0x2140 at 0x217E // Incoming return from call to 0x200E at 0x2085 // Incoming return from call to 0x1F3A at 0x28BA // Incoming jump from 0x0E8E // Incoming return from call to 0x1F3A at 0x1F84 // Incoming jump from 0x1A83, if 0x00 - stack[-1] // Incoming return from call to 0x1F85 at 0x242F // Incoming return from call to 0x249B at 0x2854 // Incoming jump from 0x0F64 // Inputs[3] // { // @0F66 stack[-5] // @0F66 stack[-1] // @0F67 stack[-4] // } 0F65 5B JUMPDEST 0F66 93 SWAP4 0F67 92 SWAP3 0F68 50 POP 0F69 50 POP 0F6A 50 POP 0F6B 56 *JUMP // Stack delta = -4 // Outputs[1] { @0F66 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] 0F6C 5B JUMPDEST 0F6D 81 DUP2 0F6E 61 PUSH2 0x0f76 0F71 81 DUP2 0F72 61 PUSH2 0x1474 0F75 56 *JUMP 0F76 5B JUMPDEST 0F77 61 PUSH2 0x072a 0F7A 83 DUP4 0F7B 83 DUP4 0F7C 61 PUSH2 0x1bec 0F7F 56 *JUMP label_0F80: // Incoming call from 0x1A2E, returns to 0x072A // Incoming jump from 0x0529 // Inputs[2] // { // @0F81 stack[-4] // @0F99 msg.sender // } 0F80 5B JUMPDEST 0F81 83 DUP4 0F82 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F97 81 DUP2 0F98 16 AND 0F99 33 CALLER 0F9A 14 EQ 0F9B 61 PUSH2 0x0fa7 0F9E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F81 stack[0] = stack[-4] } // Block ends with conditional jump to 0x0fa7, if msg.sender == stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff label_0F9F: // Incoming jump from 0x0F9E, if not msg.sender == stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @0FA2 msg.sender } 0F9F 61 PUSH2 0x0fa7 0FA2 33 CALLER 0FA3 61 PUSH2 0x1474 0FA6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F9F stack[0] = 0x0fa7 // @0FA2 stack[1] = msg.sender // } // Block ends with call to 0x1474, returns to 0x0FA7 label_0FA7: // Incoming jump from 0x0F9E, if msg.sender == stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // Incoming return from call to 0x1474 at 0x0FA6 // Inputs[4] // { // @0FAB stack[-5] // @0FAC stack[-4] // @0FAD stack[-3] // @0FAE stack[-2] // } 0FA7 5B JUMPDEST 0FA8 61 PUSH2 0x0fb3 0FAB 85 DUP6 0FAC 85 DUP6 0FAD 85 DUP6 0FAE 85 DUP6 0FAF 61 PUSH2 0x1c83 0FB2 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0FA8 stack[0] = 0x0fb3 // @0FAB stack[1] = stack[-5] // @0FAC stack[2] = stack[-4] // @0FAD stack[3] = stack[-3] // @0FAE stack[4] = stack[-2] // } // Block ends with call to 0x1c83, returns to 0x0FB3 label_0FB3: // Incoming return from call to 0x1C83 at 0x0FB2 // Inputs[1] { @0FB9 stack[-6] } 0FB3 5B JUMPDEST 0FB4 50 POP 0FB5 50 POP 0FB6 50 POP 0FB7 50 POP 0FB8 50 POP 0FB9 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0FBA: // Incoming call from 0x0E99, returns to 0x0E9A // Incoming jump from 0x0B9A // Incoming jump from 0x0549 // Inputs[3] // { // @0FBE memory[0x40:0x60] // @0FE2 memory[0x40:0x60] // @1005 stack[-1] // } 0FBA 5B JUMPDEST 0FBB 60 PUSH1 0x40 0FBD 80 DUP1 0FBE 51 MLOAD 0FBF 60 PUSH1 0x80 0FC1 81 DUP2 0FC2 01 ADD 0FC3 82 DUP3 0FC4 52 MSTORE 0FC5 60 PUSH1 0x00 0FC7 80 DUP1 0FC8 82 DUP3 0FC9 52 MSTORE 0FCA 60 PUSH1 0x20 0FCC 82 DUP3 0FCD 01 ADD 0FCE 81 DUP2 0FCF 90 SWAP1 0FD0 52 MSTORE 0FD1 91 SWAP2 0FD2 81 DUP2 0FD3 01 ADD 0FD4 82 DUP3 0FD5 90 SWAP1 0FD6 52 MSTORE 0FD7 60 PUSH1 0x60 0FD9 81 DUP2 0FDA 01 ADD 0FDB 91 SWAP2 0FDC 90 SWAP1 0FDD 91 SWAP2 0FDE 52 MSTORE 0FDF 60 PUSH1 0x40 0FE1 80 DUP1 0FE2 51 MLOAD 0FE3 60 PUSH1 0x80 0FE5 81 DUP2 0FE6 01 ADD 0FE7 82 DUP3 0FE8 52 MSTORE 0FE9 60 PUSH1 0x00 0FEB 80 DUP1 0FEC 82 DUP3 0FED 52 MSTORE 0FEE 60 PUSH1 0x20 0FF0 82 DUP3 0FF1 01 ADD 0FF2 81 DUP2 0FF3 90 SWAP1 0FF4 52 MSTORE 0FF5 91 SWAP2 0FF6 81 DUP2 0FF7 01 ADD 0FF8 82 DUP3 0FF9 90 SWAP1 0FFA 52 MSTORE 0FFB 60 PUSH1 0x60 0FFD 81 DUP2 0FFE 01 ADD 0FFF 91 SWAP2 1000 90 SWAP1 1001 91 SWAP2 1002 52 MSTORE 1003 60 PUSH1 0x01 1005 83 DUP4 1006 10 LT 1007 80 DUP1 1008 61 PUSH2 0x1013 100B 57 *JUMPI // Stack delta = +3 // Outputs[13] // { // @0FC4 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @0FC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0FD0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0FD6 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @0FDD stack[0] = memory[0x40:0x60] // @0FDE memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @0FE8 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @0FED memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0FF4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0FFA memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1001 stack[1] = memory[0x40:0x60] // @1002 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @1006 stack[2] = stack[-1] < 0x01 // } // Block ends with conditional jump to 0x1013, if stack[-1] < 0x01 label_100C: // Incoming jump from 0x100B, if not stack[-1] < 0x01 // Inputs[2] // { // @100F storage[0x00] // @1010 stack[-4] // } 100C 50 POP 100D 60 PUSH1 0x00 100F 54 SLOAD 1010 83 DUP4 1011 10 LT 1012 15 ISZERO 1013 5B JUMPDEST 1014 15 ISZERO 1015 61 PUSH2 0x101e 1018 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x101e, if !!(stack[-4] < storage[0x00]) label_1019: // Incoming jump from 0x1018, if not !stack[-1] // Incoming jump from 0x1018, if not !!(stack[-4] < storage[0x00]) // Inputs[3] // { // @1019 stack[-1] // @1019 stack[-4] // @101A stack[-3] // } 1019 92 SWAP3 101A 91 SWAP2 101B 50 POP 101C 50 POP 101D 56 *JUMP // Stack delta = -3 // Outputs[1] { @1019 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_101E: // Incoming jump from 0x1018, if !stack[-1] // Incoming jump from 0x1018, if !!(stack[-4] < storage[0x00]) // Inputs[1] { @1022 stack[-3] } 101E 5B JUMPDEST 101F 61 PUSH2 0x1027 1022 83 DUP4 1023 61 PUSH2 0x1b47 1026 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @101F stack[0] = 0x1027 // @1022 stack[1] = stack[-3] // } // Block ends with call to 0x1b47, returns to 0x1027 label_1027: // Incoming return from call to 0x1B47 at 0x1026 // Inputs[3] // { // @1028 stack[-1] // @1028 stack[-2] // @102E memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 1027 5B JUMPDEST 1028 90 SWAP1 1029 50 POP 102A 80 DUP1 102B 60 PUSH1 0x40 102D 01 ADD 102E 51 MLOAD 102F 15 ISZERO 1030 61 PUSH2 0x1039 1033 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1028 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1039, if !memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_1034: // Incoming jump from 0x1033, if not !memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[3] // { // @1034 stack[-1] // @1034 stack[-4] // @1035 stack[-3] // } 1034 92 SWAP3 1035 91 SWAP2 1036 50 POP 1037 50 POP 1038 56 *JUMP // Stack delta = -3 // Outputs[1] { @1034 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1039: // Incoming jump from 0x1033, if !memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[1] { @103D stack[-3] } 1039 5B JUMPDEST 103A 61 PUSH2 0x0f65 103D 83 DUP4 103E 61 PUSH2 0x1ced 1041 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @103A stack[0] = 0x0f65 // @103D stack[1] = stack[-3] // } // Block ends with unconditional jump to 0x1ced label_1042: // Incoming jump from 0x0576 // Inputs[1] { @1048 stack[-1] } 1042 5B JUMPDEST 1043 60 PUSH1 0x60 1045 61 PUSH2 0x104d 1048 82 DUP3 1049 61 PUSH2 0x1426 104C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1043 stack[0] = 0x60 // @1045 stack[1] = 0x104d // @1048 stack[2] = stack[-1] // } // Block ends with call to 0x1426, returns to 0x104D label_104D: // Incoming return from call to 0x1426 at 0x104C // Inputs[1] { @1051 stack[-1] } 104D 5B JUMPDEST 104E 61 PUSH2 0x1083 1051 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1083, if stack[-1] label_1052: // Incoming jump from 0x1051, if not stack[-1] // Inputs[3] // { // @1054 memory[0x40:0x60] // @107D memory[0x40:0x60] // @1082 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1052 60 PUSH1 0x40 1054 51 MLOAD 1055 7F PUSH32 0xa14c4b5000000000000000000000000000000000000000000000000000000000 1076 81 DUP2 1077 52 MSTORE 1078 60 PUSH1 0x04 107A 01 ADD 107B 60 PUSH1 0x40 107D 51 MLOAD 107E 80 DUP1 107F 91 SWAP2 1080 03 SUB 1081 90 SWAP1 1082 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1077 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa14c4b5000000000000000000000000000000000000000000000000000000000 // @1082 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1083: // Incoming jump from 0x1051, if stack[-1] 1083 5B JUMPDEST 1084 60 PUSH1 0x00 1086 61 PUSH2 0x108d 1089 61 PUSH2 0x1d8b 108C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1084 stack[0] = 0x00 // @1086 stack[1] = 0x108d // } // Block ends with unconditional jump to 0x1d8b 108D 5B JUMPDEST 108E 90 SWAP1 108F 50 POP 1090 80 DUP1 1091 51 MLOAD 1092 60 PUSH1 0x00 1094 03 SUB 1095 61 PUSH2 0x10ad 1098 57 *JUMPI 1099 60 PUSH1 0x40 109B 51 MLOAD 109C 80 DUP1 109D 60 PUSH1 0x20 109F 01 ADD 10A0 60 PUSH1 0x40 10A2 52 MSTORE 10A3 80 DUP1 10A4 60 PUSH1 0x00 10A6 81 DUP2 10A7 52 MSTORE 10A8 50 POP 10A9 61 PUSH2 0x0f65 10AC 56 *JUMP 10AD 5B JUMPDEST 10AE 80 DUP1 10AF 61 PUSH2 0x10b7 10B2 84 DUP5 10B3 61 PUSH2 0x1d9a 10B6 56 *JUMP 10B7 5B JUMPDEST 10B8 60 PUSH1 0x40 10BA 51 MLOAD 10BB 60 PUSH1 0x20 10BD 01 ADD 10BE 61 PUSH2 0x10c8 10C1 92 SWAP3 10C2 91 SWAP2 10C3 90 SWAP1 10C4 61 PUSH2 0x2809 10C7 56 *JUMP 10C8 5B JUMPDEST 10C9 60 PUSH1 0x40 10CB 51 MLOAD 10CC 60 PUSH1 0x20 10CE 81 DUP2 10CF 83 DUP4 10D0 03 SUB 10D1 03 SUB 10D2 81 DUP2 10D3 52 MSTORE 10D4 90 SWAP1 10D5 60 PUSH1 0x40 10D7 52 MSTORE 10D8 93 SWAP4 10D9 92 SWAP3 10DA 50 POP 10DB 50 POP 10DC 50 POP 10DD 56 *JUMP label_10DE: // Incoming jump from 0x05EC 10DE 5B JUMPDEST 10DF 61 PUSH2 0x10e6 10E2 61 PUSH2 0x122c 10E5 56 *JUMP // Stack delta = +1 // Outputs[1] { @10DF stack[0] = 0x10e6 } // Block ends with call to 0x122c, returns to 0x10E6 label_10E6: // Incoming return from call to 0x122C at 0x10E5 // Inputs[1] { @10FC stack[-1] } 10E6 5B JUMPDEST 10E7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 10FC 81 DUP2 10FD 16 AND 10FE 61 PUSH2 0x1189 1101 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1189, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_1102: // Incoming jump from 0x1101, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @1104 memory[0x40:0x60] } 1102 60 PUSH1 0x40 1104 51 MLOAD 1105 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1126 81 DUP2 1127 52 MSTORE 1128 60 PUSH1 0x20 112A 60 PUSH1 0x04 112C 82 DUP3 112D 01 ADD 112E 52 MSTORE 112F 60 PUSH1 0x26 1131 60 PUSH1 0x24 1133 82 DUP3 1134 01 ADD 1135 52 MSTORE 1136 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1157 60 PUSH1 0x44 1159 82 DUP3 115A 01 ADD 115B 52 MSTORE 115C 7F PUSH32 0x6464726573730000000000000000000000000000000000000000000000000000 117D 60 PUSH1 0x64 117F 82 DUP3 1180 01 ADD 1181 52 MSTORE 1182 60 PUSH1 0x84 1184 01 ADD 1185 61 PUSH2 0x0721 1188 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @1127 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @112E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1135 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @115B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1181 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6464726573730000000000000000000000000000000000000000000000000000 // @1184 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0721 label_1189: // Incoming jump from 0x1101, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @118D stack[-1] } 1189 5B JUMPDEST 118A 61 PUSH2 0x1192 118D 81 DUP2 118E 61 PUSH2 0x1ad0 1191 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @118A stack[0] = 0x1192 // @118D stack[1] = stack[-1] // } // Block ends with call to 0x1ad0, returns to 0x1192 label_1192: // Incoming jump from 0x1489, if !address(0xaaeb6d7670e522a718067333cd4e).code.length // Incoming jump from 0x152F, if stack[-1] // Incoming jump from 0x1F63, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Incoming return from call to 0x1AD0 at 0x1191 // Incoming jump from 0x24A4, if stack[-1] == !!stack[-1] // Inputs[1] { @1194 stack[-2] } 1192 5B JUMPDEST 1193 50 POP 1194 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_1195: // Incoming call from 0x0642, returns to 0x0643 // Inputs[1] { @11B9 stack[-1] } 1195 5B JUMPDEST 1196 60 PUSH1 0x00 1198 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 11B9 82 DUP3 11BA 16 AND 11BB 7F PUSH32 0x2a55205a00000000000000000000000000000000000000000000000000000000 11DC 14 EQ 11DD 80 DUP1 11DE 61 PUSH2 0x0643 11E1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1196 stack[0] = 0x00 // @11DC stack[1] = 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // } // Block ends with conditional jump to 0x0643, if 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_11E2: // Incoming jump from 0x11E1, if not 0x2a55205a00000000000000000000000000000000000000000000000000000000 == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1225 stack[-3] } 11E2 50 POP 11E3 7F PUSH32 0x01ffc9a700000000000000000000000000000000000000000000000000000000 1204 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1225 83 DUP4 1226 16 AND 1227 14 EQ 1228 61 PUSH2 0x0643 122B 56 *JUMP // Stack delta = +0 // Outputs[1] { @1227 stack[-1] = stack[-3] & 0xffffffff00000000000000000000000000000000000000000000000000000000 == 0x01ffc9a700000000000000000000000000000000000000000000000000000000 } // Block ends with unconditional jump to 0x0643 label_122C: // Incoming call from 0x0650, returns to 0x0651 // Incoming call from 0x10E5, returns to 0x10E6 // Incoming call from 0x0AF0, returns to 0x0AF1 // Incoming call from 0x0C5D, returns to 0x0C5E // Incoming call from 0x0736, returns to 0x0737 // Incoming call from 0x0A19, returns to 0x0A1A // Incoming call from 0x0A63, returns to 0x0A64 // Inputs[2] // { // @122F storage[0x08] // @1246 msg.sender // } 122C 5B JUMPDEST 122D 60 PUSH1 0x08 122F 54 SLOAD 1230 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1245 16 AND 1246 33 CALLER 1247 14 EQ 1248 61 PUSH2 0x0c68 124B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c68, if msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x08] label_124C: // Incoming jump from 0x124B, if not msg.sender == 0xffffffffffffffffffffffffffffffffffffffff & storage[0x08] // Inputs[1] { @124E memory[0x40:0x60] } 124C 60 PUSH1 0x40 124E 51 MLOAD 124F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1270 81 DUP2 1271 52 MSTORE 1272 60 PUSH1 0x20 1274 60 PUSH1 0x04 1276 82 DUP3 1277 01 ADD 1278 81 DUP2 1279 90 SWAP1 127A 52 MSTORE 127B 60 PUSH1 0x24 127D 82 DUP3 127E 01 ADD 127F 52 MSTORE 1280 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 12A1 60 PUSH1 0x44 12A3 82 DUP3 12A4 01 ADD 12A5 52 MSTORE 12A6 60 PUSH1 0x64 12A8 01 ADD 12A9 61 PUSH2 0x0721 12AC 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @1271 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @127A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @127F memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @12A5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @12A8 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0721 label_12AD: // Incoming call from 0x0740, returns to 0x0741 // Inputs[1] { @12BE stack[-1] } 12AD 5B JUMPDEST 12AE 61 PUSH2 0x2710 12B1 6B PUSH12 0xffffffffffffffffffffffff 12BE 82 DUP3 12BF 16 AND 12C0 11 GT 12C1 15 ISZERO 12C2 61 PUSH2 0x134d 12C5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x134d, if !(stack[-1] & 0xffffffffffffffffffffffff > 0x2710) label_12C6: // Incoming jump from 0x12C5, if not !(stack[-1] & 0xffffffffffffffffffffffff > 0x2710) // Inputs[1] { @12C8 memory[0x40:0x60] } 12C6 60 PUSH1 0x40 12C8 51 MLOAD 12C9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 12EA 81 DUP2 12EB 52 MSTORE 12EC 60 PUSH1 0x20 12EE 60 PUSH1 0x04 12F0 82 DUP3 12F1 01 ADD 12F2 52 MSTORE 12F3 60 PUSH1 0x2a 12F5 60 PUSH1 0x24 12F7 82 DUP3 12F8 01 ADD 12F9 52 MSTORE 12FA 7F PUSH32 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 131B 60 PUSH1 0x44 131D 82 DUP3 131E 01 ADD 131F 52 MSTORE 1320 7F PUSH32 0x2073616c65507269636500000000000000000000000000000000000000000000 1341 60 PUSH1 0x64 1343 82 DUP3 1344 01 ADD 1345 52 MSTORE 1346 60 PUSH1 0x84 1348 01 ADD 1349 61 PUSH2 0x0721 134C 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @12EB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @12F2 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12F9 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @131F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 // @1345 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2073616c65507269636500000000000000000000000000000000000000000000 // @1348 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0721 label_134D: // Incoming jump from 0x12C5, if !(stack[-1] & 0xffffffffffffffffffffffff > 0x2710) // Inputs[1] { @1363 stack[-2] } 134D 5B JUMPDEST 134E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1363 82 DUP3 1364 16 AND 1365 61 PUSH2 0x13ca 1368 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x13ca, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff label_1369: // Incoming jump from 0x1368, if not stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @136B memory[0x40:0x60] } 1369 60 PUSH1 0x40 136B 51 MLOAD 136C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 138D 81 DUP2 138E 52 MSTORE 138F 60 PUSH1 0x20 1391 60 PUSH1 0x04 1393 82 DUP3 1394 01 ADD 1395 52 MSTORE 1396 60 PUSH1 0x19 1398 60 PUSH1 0x24 139A 82 DUP3 139B 01 ADD 139C 52 MSTORE 139D 7F PUSH32 0x455243323938313a20696e76616c696420726563656976657200000000000000 13BE 60 PUSH1 0x44 13C0 82 DUP3 13C1 01 ADD 13C2 52 MSTORE 13C3 60 PUSH1 0x64 13C5 01 ADD 13C6 61 PUSH2 0x0721 13C9 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @138E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1395 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @139C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @13C2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20696e76616c696420726563656976657200000000000000 // @13C5 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0721 label_13CA: // Incoming jump from 0x1368, if stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[4] // { // @13CE memory[0x40:0x60] // @13EB stack[-2] // @13FE stack[-1] // @1425 stack[-3] // } 13CA 5B JUMPDEST 13CB 60 PUSH1 0x40 13CD 80 DUP1 13CE 51 MLOAD 13CF 80 DUP1 13D0 82 DUP3 13D1 01 ADD 13D2 90 SWAP1 13D3 91 SWAP2 13D4 52 MSTORE 13D5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13EA 90 SWAP1 13EB 92 SWAP3 13EC 16 AND 13ED 80 DUP1 13EE 83 DUP4 13EF 52 MSTORE 13F0 6B PUSH12 0xffffffffffffffffffffffff 13FD 90 SWAP1 13FE 91 SWAP2 13FF 16 AND 1400 60 PUSH1 0x20 1402 90 SWAP1 1403 92 SWAP3 1404 01 ADD 1405 82 DUP3 1406 90 SWAP1 1407 52 MSTORE 1408 74 PUSH21 0x010000000000000000000000000000000000000000 141E 90 SWAP1 141F 91 SWAP2 1420 02 MUL 1421 17 OR 1422 60 PUSH1 0x09 1424 55 SSTORE 1425 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @13D4 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @13EF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @1407 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & 0xffffffffffffffffffffffff // @1424 storage[0x09] = (stack[-1] & 0xffffffffffffffffffffffff) * 0x010000000000000000000000000000000000000000 | (stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff) // } // Block ends with unconditional jump to stack[-3] label_1426: // Incoming call from 0x07E1, returns to 0x07E2 // Incoming call from 0x104C, returns to 0x104D // Inputs[1] { @1429 stack[-1] } 1426 5B JUMPDEST 1427 60 PUSH1 0x00 1429 81 DUP2 142A 60 PUSH1 0x01 142C 11 GT 142D 15 ISZERO 142E 80 DUP1 142F 15 ISZERO 1430 61 PUSH2 0x143a 1433 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1427 stack[0] = 0x00 // @142D stack[1] = !(0x01 > stack[-1]) // } // Block ends with conditional jump to 0x143a, if !!(0x01 > stack[-1]) label_1434: // Incoming jump from 0x1433, if not !!(0x01 > stack[-1]) // Inputs[2] // { // @1437 storage[0x00] // @1438 stack[-3] // } 1434 50 POP 1435 60 PUSH1 0x00 1437 54 SLOAD 1438 82 DUP3 1439 10 LT 143A 5B JUMPDEST 143B 80 DUP1 143C 15 ISZERO 143D 61 PUSH2 0x0643 1440 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1439 stack[-1] = stack[-3] < storage[0x00] } // Block ends with conditional jump to 0x0643, if !(stack[-3] < storage[0x00]) label_1441: // Incoming jump from 0x1440, if not !stack[-1] // Incoming jump from 0x1440, if not !(stack[-3] < storage[0x00]) // Inputs[4] // { // @1445 stack[-3] // @1450 memory[0x00:0x40] // @1451 storage[keccak256(memory[0x00:0x40])] // @1472 stack[-4] // } 1441 50 POP 1442 50 POP 1443 60 PUSH1 0x00 1445 90 SWAP1 1446 81 DUP2 1447 52 MSTORE 1448 60 PUSH1 0x04 144A 60 PUSH1 0x20 144C 52 MSTORE 144D 60 PUSH1 0x40 144F 90 SWAP1 1450 20 SHA3 1451 54 SLOAD 1452 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 1470 16 AND 1471 15 ISZERO 1472 90 SWAP1 1473 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1447 memory[0x00:0x20] = stack[-3] // @144C memory[0x20:0x40] = 0x04 // @1472 stack[-4] = !(0x0100000000000000000000000000000000000000000000000000000000 & storage[keccak256(memory[0x00:0x40])]) // } // Block ends with unconditional jump to stack[-4] label_1474: // Incoming call from 0x087B, returns to 0x087C // Incoming call from 0x0FA6, returns to 0x0FA7 // Incoming call from 0x0ADD, returns to 0x0ADE // Incoming call from 0x084A, returns to 0x084B // Inputs[1] { @1484 address(0xaaeb6d7670e522a718067333cd4e).code.length } 1474 5B JUMPDEST 1475 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 1484 3B EXTCODESIZE 1485 15 ISZERO 1486 61 PUSH2 0x1192 1489 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1192, if !address(0xaaeb6d7670e522a718067333cd4e).code.length label_148A: // Incoming jump from 0x1489, if not !address(0xaaeb6d7670e522a718067333cd4e).code.length // Inputs[7] // { // @148C memory[0x40:0x60] // @14B0 address(this) // @14CB stack[-1] // @14EF memory[0x40:0x60] // @14F5 msg.gas // @14F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]] // @14F6 address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 148A 60 PUSH1 0x40 148C 51 MLOAD 148D 7F PUSH32 0xc617113400000000000000000000000000000000000000000000000000000000 14AE 81 DUP2 14AF 52 MSTORE 14B0 30 ADDRESS 14B1 60 PUSH1 0x04 14B3 82 DUP3 14B4 01 ADD 14B5 52 MSTORE 14B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14CB 82 DUP3 14CC 16 AND 14CD 60 PUSH1 0x24 14CF 82 DUP3 14D0 01 ADD 14D1 52 MSTORE 14D2 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 14E1 90 SWAP1 14E2 63 PUSH4 0xc6171134 14E7 90 SWAP1 14E8 60 PUSH1 0x44 14EA 01 ADD 14EB 60 PUSH1 0x20 14ED 60 PUSH1 0x40 14EF 51 MLOAD 14F0 80 DUP1 14F1 83 DUP4 14F2 03 SUB 14F3 81 DUP2 14F4 86 DUP7 14F5 5A GAS 14F6 FA STATICCALL 14F7 15 ISZERO 14F8 80 DUP1 14F9 15 ISZERO 14FA 61 PUSH2 0x1507 14FD 57 *JUMPI // Stack delta = +4 // Outputs[8] // { // @14AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc617113400000000000000000000000000000000000000000000000000000000 // @14B5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @14D1 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @14E1 stack[0] = 0xaaeb6d7670e522a718067333cd4e // @14E7 stack[1] = 0xc6171134 // @14EA stack[2] = 0x44 + memory[0x40:0x60] // @14F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // @14F7 stack[3] = !address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1507, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_14FE: // Incoming jump from 0x14FD, if not !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @14FE returndata.length // @1502 returndata[0x00:0x00 + returndata.length] // @1503 returndata.length // @1506 memory[0x00:0x00 + returndata.length] // } 14FE 3D RETURNDATASIZE 14FF 60 PUSH1 0x00 1501 80 DUP1 1502 3E RETURNDATACOPY 1503 3D RETURNDATASIZE 1504 60 PUSH1 0x00 1506 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1502 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1506 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1507: // Incoming jump from 0x14FD, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @150E memory[0x40:0x60] // @150F returndata.length // } 1507 5B JUMPDEST 1508 50 POP 1509 50 POP 150A 50 POP 150B 50 POP 150C 60 PUSH1 0x40 150E 51 MLOAD 150F 3D RETURNDATASIZE 1510 60 PUSH1 0x1f 1512 19 NOT 1513 60 PUSH1 0x1f 1515 82 DUP3 1516 01 ADD 1517 16 AND 1518 82 DUP3 1519 01 ADD 151A 80 DUP1 151B 60 PUSH1 0x40 151D 52 MSTORE 151E 50 POP 151F 81 DUP2 1520 01 ADD 1521 90 SWAP1 1522 61 PUSH2 0x152b 1525 91 SWAP2 1526 90 SWAP1 1527 61 PUSH2 0x2838 152A 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @151D memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1525 stack[-4] = 0x152b // @1526 stack[-2] = memory[0x40:0x60] // @1526 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x2838, returns to 0x152B label_152B: // Incoming return from call to 0x2838 at 0x152A // Inputs[1] { @152F stack[-1] } 152B 5B JUMPDEST 152C 61 PUSH2 0x1192 152F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1192, if stack[-1] label_1530: // Incoming jump from 0x152F, if not stack[-1] // Inputs[2] // { // @1532 memory[0x40:0x60] // @156B stack[-1] // } 1530 60 PUSH1 0x40 1532 51 MLOAD 1533 7F PUSH32 0xede71dcc00000000000000000000000000000000000000000000000000000000 1554 81 DUP2 1555 52 MSTORE 1556 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 156B 82 DUP3 156C 16 AND 156D 60 PUSH1 0x04 156F 82 DUP3 1570 01 ADD 1571 52 MSTORE 1572 60 PUSH1 0x24 1574 01 ADD 1575 61 PUSH2 0x0721 1578 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1555 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xede71dcc00000000000000000000000000000000000000000000000000000000 // @1571 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @1574 stack[0] = 0x24 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0721 label_1579: // Incoming call from 0x0854, returns to 0x072A // Inputs[1] { @157F stack[-1] } 1579 5B JUMPDEST 157A 60 PUSH1 0x00 157C 61 PUSH2 0x1584 157F 82 DUP3 1580 61 PUSH2 0x0bc9 1583 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @157A stack[0] = 0x00 // @157C stack[1] = 0x1584 // @157F stack[2] = stack[-1] // } // Block ends with call to 0x0bc9, returns to 0x1584 label_1584: // Incoming return from call to 0x0BC9 at 0x1583 // Inputs[3] // { // @1585 stack[-1] // @1585 stack[-2] // @1587 msg.sender // } 1584 5B JUMPDEST 1585 90 SWAP1 1586 50 POP 1587 33 CALLER 1588 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 159D 82 DUP3 159E 16 AND 159F 14 EQ 15A0 61 PUSH2 0x15e3 15A3 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1585 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x15e3, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender label_15A4: // Incoming jump from 0x15A3, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender // Inputs[2] // { // @15A7 stack[-1] // @15A8 msg.sender // } 15A4 61 PUSH2 0x15ad 15A7 81 DUP2 15A8 33 CALLER 15A9 61 PUSH2 0x0592 15AC 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15A4 stack[0] = 0x15ad // @15A7 stack[1] = stack[-1] // @15A8 stack[2] = msg.sender // } // Block ends with call to 0x0592, returns to 0x15AD label_15AD: // Incoming return from call to 0x0592 at 0x15AC // Inputs[1] { @15B1 stack[-1] } 15AD 5B JUMPDEST 15AE 61 PUSH2 0x15e3 15B1 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x15e3, if stack[-1] label_15B2: // Incoming jump from 0x15B1, if not stack[-1] // Inputs[3] // { // @15B4 memory[0x40:0x60] // @15DD memory[0x40:0x60] // @15E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 15B2 60 PUSH1 0x40 15B4 51 MLOAD 15B5 7F PUSH32 0xcfb3b94200000000000000000000000000000000000000000000000000000000 15D6 81 DUP2 15D7 52 MSTORE 15D8 60 PUSH1 0x04 15DA 01 ADD 15DB 60 PUSH1 0x40 15DD 51 MLOAD 15DE 80 DUP1 15DF 91 SWAP2 15E0 03 SUB 15E1 90 SWAP1 15E2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @15D7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xcfb3b94200000000000000000000000000000000000000000000000000000000 // @15E2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_15E3: // Incoming jump from 0x15A3, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender // Incoming jump from 0x15B1, if stack[-1] // Inputs[8] // { // @15E6 stack[-2] // @15F2 memory[0x00:0x40] // @15F4 storage[keccak256(memory[0x00:0x40])] // @162C stack[-3] // @1636 memory[0x40:0x60] // @163A stack[-1] // @165F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1663 stack[-4] // } 15E3 5B JUMPDEST 15E4 60 PUSH1 0x00 15E6 82 DUP3 15E7 81 DUP2 15E8 52 MSTORE 15E9 60 PUSH1 0x06 15EB 60 PUSH1 0x20 15ED 52 MSTORE 15EE 60 PUSH1 0x40 15F0 80 DUP1 15F1 82 DUP3 15F2 20 SHA3 15F3 80 DUP1 15F4 54 SLOAD 15F5 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 1616 16 AND 1617 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 162C 87 DUP8 162D 81 DUP2 162E 16 AND 162F 91 SWAP2 1630 82 DUP3 1631 17 OR 1632 90 SWAP1 1633 92 SWAP3 1634 55 SSTORE 1635 91 SWAP2 1636 51 MLOAD 1637 85 DUP6 1638 93 SWAP4 1639 91 SWAP2 163A 85 DUP6 163B 16 AND 163C 91 SWAP2 163D 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 165E 91 SWAP2 165F A4 LOG4 1660 50 POP 1661 50 POP 1662 50 POP 1663 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @15E8 memory[0x00:0x20] = stack[-2] // @15ED memory[0x20:0x40] = 0x06 // @1634 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & storage[keccak256(memory[0x00:0x40])]) // @165F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-4] label_1664: // Incoming call from 0x0886, returns to 0x0887 // Inputs[1] { @166A stack[-1] } 1664 5B JUMPDEST 1665 60 PUSH1 0x00 1667 61 PUSH2 0x166f 166A 82 DUP3 166B 61 PUSH2 0x1a2f 166E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1665 stack[0] = 0x00 // @1667 stack[1] = 0x166f // @166A stack[2] = stack[-1] // } // Block ends with call to 0x1a2f, returns to 0x166F label_166F: // Incoming return from call to 0x1A2F at 0x166E // Inputs[3] // { // @1670 stack[-2] // @1670 stack[-1] // @1672 stack[-5] // } 166F 5B JUMPDEST 1670 90 SWAP1 1671 50 POP 1672 83 DUP4 1673 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1688 16 AND 1689 81 DUP2 168A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 169F 16 AND 16A0 14 EQ 16A1 61 PUSH2 0x16d6 16A4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1670 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x16d6, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] label_16A5: // Incoming jump from 0x16A4, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // Inputs[3] // { // @16A7 memory[0x40:0x60] // @16D0 memory[0x40:0x60] // @16D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16A5 60 PUSH1 0x40 16A7 51 MLOAD 16A8 7F PUSH32 0xa114810000000000000000000000000000000000000000000000000000000000 16C9 81 DUP2 16CA 52 MSTORE 16CB 60 PUSH1 0x04 16CD 01 ADD 16CE 60 PUSH1 0x40 16D0 51 MLOAD 16D1 80 DUP1 16D2 91 SWAP2 16D3 03 SUB 16D4 90 SWAP1 16D5 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16CA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xa114810000000000000000000000000000000000000000000000000000000000 // @16D5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_16D6: // Incoming jump from 0x16A4, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // Inputs[5] // { // @16D9 stack[-2] // @16E4 memory[0x00:0x40] // @16E6 storage[keccak256(memory[0x00:0x40])] // @16E7 msg.sender // @1700 stack[-4] // } 16D6 5B JUMPDEST 16D7 60 PUSH1 0x00 16D9 82 DUP3 16DA 81 DUP2 16DB 52 MSTORE 16DC 60 PUSH1 0x06 16DE 60 PUSH1 0x20 16E0 52 MSTORE 16E1 60 PUSH1 0x40 16E3 90 SWAP1 16E4 20 SHA3 16E5 80 DUP1 16E6 54 SLOAD 16E7 33 CALLER 16E8 80 DUP1 16E9 82 DUP3 16EA 14 EQ 16EB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1700 88 DUP9 1701 16 AND 1702 90 SWAP1 1703 91 SWAP2 1704 14 EQ 1705 17 OR 1706 61 PUSH2 0x1749 1709 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @16DB memory[0x00:0x20] = stack[-2] // @16E0 memory[0x20:0x40] = 0x06 // @16E4 stack[0] = keccak256(memory[0x00:0x40]) // @16E6 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1749, if (msg.sender == stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_170A: // Incoming jump from 0x1709, if not (msg.sender == stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[2] // { // @170D stack[-6] // @170E msg.sender // } 170A 61 PUSH2 0x1713 170D 86 DUP7 170E 33 CALLER 170F 61 PUSH2 0x0592 1712 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @170A stack[0] = 0x1713 // @170D stack[1] = stack[-6] // @170E stack[2] = msg.sender // } // Block ends with call to 0x0592, returns to 0x1713 label_1713: // Incoming return from call to 0x0592 at 0x1712 // Inputs[1] { @1717 stack[-1] } 1713 5B JUMPDEST 1714 61 PUSH2 0x1749 1717 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1749, if stack[-1] label_1718: // Incoming jump from 0x1717, if not stack[-1] // Inputs[3] // { // @171A memory[0x40:0x60] // @1743 memory[0x40:0x60] // @1748 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1718 60 PUSH1 0x40 171A 51 MLOAD 171B 7F PUSH32 0x59c896be00000000000000000000000000000000000000000000000000000000 173C 81 DUP2 173D 52 MSTORE 173E 60 PUSH1 0x04 1740 01 ADD 1741 60 PUSH1 0x40 1743 51 MLOAD 1744 80 DUP1 1745 91 SWAP2 1746 03 SUB 1747 90 SWAP1 1748 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @173D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x59c896be00000000000000000000000000000000000000000000000000000000 // @1748 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1749: // Incoming jump from 0x1709, if (msg.sender == stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Incoming jump from 0x1717, if stack[-1] // Inputs[1] { @175F stack[-5] } 1749 5B JUMPDEST 174A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 175F 85 DUP6 1760 16 AND 1761 61 PUSH2 0x1796 1764 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1796, if stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff label_1765: // Incoming jump from 0x1764, if not stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @1767 memory[0x40:0x60] // @1790 memory[0x40:0x60] // @1795 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1765 60 PUSH1 0x40 1767 51 MLOAD 1768 7F PUSH32 0xea553b3400000000000000000000000000000000000000000000000000000000 1789 81 DUP2 178A 52 MSTORE 178B 60 PUSH1 0x04 178D 01 ADD 178E 60 PUSH1 0x40 1790 51 MLOAD 1791 80 DUP1 1792 91 SWAP2 1793 03 SUB 1794 90 SWAP1 1795 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @178A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xea553b3400000000000000000000000000000000000000000000000000000000 // @1795 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1796: // Incoming jump from 0x1764, if stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @1797 stack[-1] } 1796 5B JUMPDEST 1797 80 DUP1 1798 15 ISZERO 1799 61 PUSH2 0x17a1 179C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17a1, if !stack[-1] label_179D: // Incoming jump from 0x179C, if not !stack[-1] // Inputs[11] // { // @179F stack[-2] // @17B7 stack[-6] // @17C8 memory[0x00:0x40] // @17CA storage[keccak256(memory[0x00:0x40])] // @17D2 stack[-5] // @17D9 memory[0x00:0x40] // @17DB storage[keccak256(memory[0x00:0x40])] // @17E1 block.timestamp // @1807 stack[-4] // @1812 memory[0x00:0x40] // @1835 stack[-3] // } 179D 60 PUSH1 0x00 179F 82 DUP3 17A0 55 SSTORE 17A1 5B JUMPDEST 17A2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17B7 86 DUP7 17B8 81 DUP2 17B9 16 AND 17BA 60 PUSH1 0x00 17BC 90 SWAP1 17BD 81 DUP2 17BE 52 MSTORE 17BF 60 PUSH1 0x05 17C1 60 PUSH1 0x20 17C3 52 MSTORE 17C4 60 PUSH1 0x40 17C6 80 DUP1 17C7 82 DUP3 17C8 20 SHA3 17C9 80 DUP1 17CA 54 SLOAD 17CB 60 PUSH1 0x00 17CD 19 NOT 17CE 01 ADD 17CF 90 SWAP1 17D0 55 SSTORE 17D1 91 SWAP2 17D2 87 DUP8 17D3 16 AND 17D4 80 DUP1 17D5 82 DUP3 17D6 52 MSTORE 17D7 91 SWAP2 17D8 90 SWAP1 17D9 20 SHA3 17DA 80 DUP1 17DB 54 SLOAD 17DC 60 PUSH1 0x01 17DE 01 ADD 17DF 90 SWAP1 17E0 55 SSTORE 17E1 42 TIMESTAMP 17E2 60 PUSH1 0xa0 17E4 1B SHL 17E5 17 OR 17E6 7C PUSH29 0x0200000000000000000000000000000000000000000000000000000000 1804 17 OR 1805 60 PUSH1 0x00 1807 85 DUP6 1808 81 DUP2 1809 52 MSTORE 180A 60 PUSH1 0x04 180C 60 PUSH1 0x20 180E 52 MSTORE 180F 60 PUSH1 0x40 1811 81 DUP2 1812 20 SHA3 1813 91 SWAP2 1814 90 SWAP1 1815 91 SWAP2 1816 55 SSTORE 1817 7C PUSH29 0x0200000000000000000000000000000000000000000000000000000000 1835 84 DUP5 1836 16 AND 1837 90 SWAP1 1838 03 SUB 1839 61 PUSH2 0x1872 183C 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @17A0 storage[stack[-2]] = 0x00 // @17BE memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @17C3 memory[0x20:0x40] = 0x05 // @17D0 storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @17D6 memory[0x00:0x20] = stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // @17E0 storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @1809 memory[0x00:0x20] = stack[-4] // @180E memory[0x20:0x40] = 0x04 // @1816 storage[keccak256(memory[0x00:0x40])] = 0x0200000000000000000000000000000000000000000000000000000000 | (block.timestamp << 0xa0) | (stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff) // } // Block ends with conditional jump to 0x1872, if 0x00 - (stack[-3] & 0x0200000000000000000000000000000000000000000000000000000000) label_183D: // Incoming jump from 0x183C, if not 0x00 - (stack[-3] & 0x0200000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x183C, if not 0x00 - (stack[-3] & 0x0200000000000000000000000000000000000000000000000000000000) // Inputs[3] // { // @183F stack[-4] // @184E memory[0x00:0x40] // @184F storage[keccak256(memory[0x00:0x40])] // } 183D 60 PUSH1 0x01 183F 84 DUP5 1840 01 ADD 1841 60 PUSH1 0x00 1843 81 DUP2 1844 81 DUP2 1845 52 MSTORE 1846 60 PUSH1 0x04 1848 60 PUSH1 0x20 184A 52 MSTORE 184B 60 PUSH1 0x40 184D 81 DUP2 184E 20 SHA3 184F 54 SLOAD 1850 90 SWAP1 1851 03 SUB 1852 61 PUSH2 0x1870 1855 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1840 stack[0] = stack[-4] + 0x01 // @1845 memory[0x00:0x20] = stack[-4] + 0x01 // @184A memory[0x20:0x40] = 0x04 // } // Block ends with conditional jump to 0x1870, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_1856: // Incoming jump from 0x1855, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @1858 storage[0x00] // @1859 stack[-1] // } 1856 60 PUSH1 0x00 1858 54 SLOAD 1859 81 DUP2 185A 14 EQ 185B 61 PUSH2 0x1870 185E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1870, if stack[-1] == storage[0x00] label_185F: // Incoming jump from 0x185E, if not stack[-1] == storage[0x00] // Inputs[3] // { // @1861 stack[-1] // @186C memory[0x00:0x40] // @186D stack[-4] // } 185F 60 PUSH1 0x00 1861 81 DUP2 1862 81 DUP2 1863 52 MSTORE 1864 60 PUSH1 0x04 1866 60 PUSH1 0x20 1868 52 MSTORE 1869 60 PUSH1 0x40 186B 90 SWAP1 186C 20 SHA3 186D 84 DUP5 186E 90 SWAP1 186F 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @1863 memory[0x00:0x20] = stack[-1] // @1868 memory[0x20:0x40] = 0x04 // @186F storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_1870: // Incoming jump from 0x185E, if stack[-1] == storage[0x00] // Incoming jump from 0x1855, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x186F 1870 5B JUMPDEST 1871 50 POP // Stack delta = -1 // Block continues label_1872: // Incoming jump from 0x1871 // Incoming jump from 0x183C, if 0x00 - (stack[-3] & 0x0200000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x183C, if 0x00 - (stack[-3] & 0x0200000000000000000000000000000000000000000000000000000000) // Inputs[7] // { // @1873 stack[-4] // @1874 stack[-5] // @188B stack[-6] // @18C5 memory[0x40:0x60] // @18C8 memory[0x40:0x60] // @18CD memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @18D5 stack[-7] // } 1872 5B JUMPDEST 1873 83 DUP4 1874 85 DUP6 1875 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 188A 16 AND 188B 87 DUP8 188C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18A1 16 AND 18A2 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 18C3 60 PUSH1 0x40 18C5 51 MLOAD 18C6 60 PUSH1 0x40 18C8 51 MLOAD 18C9 80 DUP1 18CA 91 SWAP2 18CB 03 SUB 18CC 90 SWAP1 18CD A4 LOG4 18CE 5B JUMPDEST 18CF 50 POP 18D0 50 POP 18D1 50 POP 18D2 50 POP 18D3 50 POP 18D4 50 POP 18D5 56 *JUMP // Stack delta = -7 // Outputs[1] { @18CD log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_18D6: // Incoming jump from 0x0A49 // Inputs[2] // { // @18DA storage[0x00] // @18DC stack[-1] // } 18D6 5B JUMPDEST 18D7 60 PUSH1 0x00 18D9 80 DUP1 18DA 54 SLOAD 18DB 90 SWAP1 18DC 82 DUP3 18DD 90 SWAP1 18DE 03 SUB 18DF 61 PUSH2 0x1914 18E2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18DB stack[0] = storage[0x00] } // Block ends with conditional jump to 0x1914, if 0x00 - stack[-1] label_18E3: // Incoming jump from 0x18E2, if not 0x00 - stack[-1] // Inputs[3] // { // @18E5 memory[0x40:0x60] // @190E memory[0x40:0x60] // @1913 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 18E3 60 PUSH1 0x40 18E5 51 MLOAD 18E6 7F PUSH32 0xb562e8dd00000000000000000000000000000000000000000000000000000000 1907 81 DUP2 1908 52 MSTORE 1909 60 PUSH1 0x04 190B 01 ADD 190C 60 PUSH1 0x40 190E 51 MLOAD 190F 80 DUP1 1910 91 SWAP2 1911 03 SUB 1912 90 SWAP1 1913 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1908 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xb562e8dd00000000000000000000000000000000000000000000000000000000 // @1913 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1914: // Incoming jump from 0x18E2, if 0x00 - stack[-1] // Inputs[8] // { // @192A stack[-3] // @193C memory[0x00:0x40] // @193E storage[keccak256(memory[0x00:0x40])] // @1949 stack[-2] // @194E stack[-1] // @1957 memory[0x00:0x40] // @195F block.timestamp // @1993 memory[0x00:0x00] // } 1914 5B JUMPDEST 1915 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 192A 83 DUP4 192B 16 AND 192C 60 PUSH1 0x00 192E 81 DUP2 192F 81 DUP2 1930 52 MSTORE 1931 60 PUSH1 0x05 1933 60 PUSH1 0x20 1935 90 SWAP1 1936 81 DUP2 1937 52 MSTORE 1938 60 PUSH1 0x40 193A 80 DUP1 193B 83 DUP4 193C 20 SHA3 193D 80 DUP1 193E 54 SLOAD 193F 68 PUSH9 0x010000000000000001 1949 88 DUP9 194A 02 MUL 194B 01 ADD 194C 90 SWAP1 194D 55 SSTORE 194E 84 DUP5 194F 83 DUP4 1950 52 MSTORE 1951 60 PUSH1 0x04 1953 90 SWAP1 1954 91 SWAP2 1955 52 MSTORE 1956 81 DUP2 1957 20 SHA3 1958 60 PUSH1 0x01 195A 85 DUP6 195B 14 EQ 195C 60 PUSH1 0xe1 195E 1B SHL 195F 42 TIMESTAMP 1960 60 PUSH1 0xa0 1962 1B SHL 1963 17 OR 1964 83 DUP4 1965 17 OR 1966 90 SWAP1 1967 55 SSTORE 1968 82 DUP3 1969 84 DUP5 196A 01 ADD 196B 90 SWAP1 196C 83 DUP4 196D 90 SWAP1 196E 83 DUP4 196F 90 SWAP1 1970 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1991 81 DUP2 1992 80 DUP1 1993 A4 LOG4 1994 60 PUSH1 0x01 1996 83 DUP4 1997 01 ADD 1998 5B JUMPDEST 1999 81 DUP2 199A 81 DUP2 199B 14 EQ 199C 61 PUSH2 0x19d0 199F 57 *JUMPI // Stack delta = +3 // Outputs[10] // { // @192B stack[0] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @1930 memory[0x00:0x20] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @1937 memory[0x20:0x40] = 0x05 // @194D storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @1950 memory[0x00:0x20] = stack[-1] // @1955 memory[0x20:0x40] = 0x04 // @1967 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff) | (block.timestamp << 0xa0) | ((stack[-2] == 0x01) << 0xe1) // @196B stack[1] = stack[-2] + stack[-1] // @1993 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1]]); // @1997 stack[2] = stack[-1] + 0x01 // } // Block ends with conditional jump to 0x19d0, if stack[-1] + 0x01 == stack[-2] + stack[-1] label_19A0: // Incoming jump from 0x199F, if not stack[-1] == stack[-2] // Incoming jump from 0x199F, if not stack[-1] + 0x01 == stack[-2] + stack[-1] // Inputs[3] // { // @19A0 stack[-1] // @19A1 stack[-3] // @19C8 memory[0x00:0x00] // } 19A0 80 DUP1 19A1 83 DUP4 19A2 60 PUSH1 0x00 19A4 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 19C5 60 PUSH1 0x00 19C7 80 DUP1 19C8 A4 LOG4 19C9 60 PUSH1 0x01 19CB 01 ADD 19CC 61 PUSH2 0x1998 19CF 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @19C8 log(memory[0x00:0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x00, stack[-3], stack[-1]]); // @19CB stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x1998 label_19D0: // Incoming jump from 0x199F, if stack[-1] == stack[-2] // Incoming jump from 0x199F, if stack[-1] + 0x01 == stack[-2] + stack[-1] // Inputs[1] { @19D2 stack[-3] } 19D0 5B JUMPDEST 19D1 50 POP 19D2 81 DUP2 19D3 60 PUSH1 0x00 19D5 03 SUB 19D6 61 PUSH2 0x1a0b 19D9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1a0b, if 0x00 - stack[-3] label_19DA: // Incoming jump from 0x19D9, if not 0x00 - stack[-3] // Inputs[3] // { // @19DC memory[0x40:0x60] // @1A05 memory[0x40:0x60] // @1A0A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19DA 60 PUSH1 0x40 19DC 51 MLOAD 19DD 7F PUSH32 0x2e07630000000000000000000000000000000000000000000000000000000000 19FE 81 DUP2 19FF 52 MSTORE 1A00 60 PUSH1 0x04 1A02 01 ADD 1A03 60 PUSH1 0x40 1A05 51 MLOAD 1A06 80 DUP1 1A07 91 SWAP2 1A08 03 SUB 1A09 90 SWAP1 1A0A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @19FF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x2e07630000000000000000000000000000000000000000000000000000000000 // @1A0A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A0B: // Incoming jump from 0x19D9, if 0x00 - stack[-3] // Inputs[2] // { // @1A0E stack[-1] // @1A13 stack[-6] // } 1A0B 5B JUMPDEST 1A0C 60 PUSH1 0x00 1A0E 55 SSTORE 1A0F 50 POP 1A10 50 POP 1A11 50 POP 1A12 50 POP 1A13 56 *JUMP // Stack delta = -6 // Outputs[1] { @1A0E storage[0x00] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1A14: // Incoming call from 0x0AE8, returns to 0x0887 // Inputs[4] // { // @1A18 stack[-3] // @1A19 stack[-2] // @1A1A stack[-1] // @1A1D memory[0x40:0x60] // } 1A14 5B JUMPDEST 1A15 61 PUSH2 0x072a 1A18 83 DUP4 1A19 83 DUP4 1A1A 83 DUP4 1A1B 60 PUSH1 0x40 1A1D 51 MLOAD 1A1E 80 DUP1 1A1F 60 PUSH1 0x20 1A21 01 ADD 1A22 60 PUSH1 0x40 1A24 52 MSTORE 1A25 80 DUP1 1A26 60 PUSH1 0x00 1A28 81 DUP2 1A29 52 MSTORE 1A2A 50 POP 1A2B 61 PUSH2 0x0f80 1A2E 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1A15 stack[0] = 0x072a // @1A18 stack[1] = stack[-3] // @1A19 stack[2] = stack[-2] // @1A1A stack[3] = stack[-1] // @1A1D stack[4] = memory[0x40:0x60] // @1A24 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1A29 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x0f80, returns to 0x072A label_1A2F: // Incoming call from 0x166E, returns to 0x166F // Incoming call from 0x1D1C, returns to 0x1D1D // Incoming call from 0x0BD3, returns to 0x0643 // Inputs[1] { @1A32 stack[-1] } 1A2F 5B JUMPDEST 1A30 60 PUSH1 0x00 1A32 81 DUP2 1A33 80 DUP1 1A34 60 PUSH1 0x01 1A36 11 GT 1A37 61 PUSH2 0x1a9e 1A3A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1A30 stack[0] = 0x00 // @1A32 stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1a9e, if 0x01 > stack[-1] label_1A3B: // Incoming jump from 0x1A3A, if not 0x01 > stack[-1] // Inputs[2] // { // @1A3D storage[0x00] // @1A3E stack[-1] // } 1A3B 60 PUSH1 0x00 1A3D 54 SLOAD 1A3E 81 DUP2 1A3F 10 LT 1A40 15 ISZERO 1A41 61 PUSH2 0x1a9e 1A44 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1a9e, if !(stack[-1] < storage[0x00]) label_1A45: // Incoming jump from 0x1A44, if not !(stack[-1] < storage[0x00]) // Inputs[3] // { // @1A47 stack[-1] // @1A52 memory[0x00:0x40] // @1A53 storage[keccak256(memory[0x00:0x40])] // } 1A45 60 PUSH1 0x00 1A47 81 DUP2 1A48 81 DUP2 1A49 52 MSTORE 1A4A 60 PUSH1 0x04 1A4C 60 PUSH1 0x20 1A4E 52 MSTORE 1A4F 60 PUSH1 0x40 1A51 81 DUP2 1A52 20 SHA3 1A53 54 SLOAD 1A54 90 SWAP1 1A55 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 1A73 82 DUP3 1A74 16 AND 1A75 90 SWAP1 1A76 03 SUB 1A77 61 PUSH2 0x1a9c 1A7A 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1A49 memory[0x00:0x20] = stack[-1] // @1A4E memory[0x20:0x40] = 0x04 // @1A54 stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1a9c, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & 0x0100000000000000000000000000000000000000000000000000000000) label_1A7B: // Incoming jump from 0x1A7A, if not 0x00 - (storage[keccak256(memory[0x00:0x40])] & 0x0100000000000000000000000000000000000000000000000000000000) // Incoming jump from 0x1A9B // Inputs[1] { @1A7C stack[-1] } 1A7B 5B JUMPDEST 1A7C 80 DUP1 1A7D 60 PUSH1 0x00 1A7F 03 SUB 1A80 61 PUSH2 0x0f65 1A83 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f65, if 0x00 - stack[-1] label_1A84: // Incoming jump from 0x1A83, if not 0x00 - stack[-1] // Inputs[3] // { // @1A88 stack[-2] // @1A96 memory[0x00:0x40] // @1A97 storage[keccak256(memory[0x00:0x40])] // } 1A84 50 POP 1A85 60 PUSH1 0x00 1A87 19 NOT 1A88 01 ADD 1A89 60 PUSH1 0x00 1A8B 81 DUP2 1A8C 81 DUP2 1A8D 52 MSTORE 1A8E 60 PUSH1 0x04 1A90 60 PUSH1 0x20 1A92 52 MSTORE 1A93 60 PUSH1 0x40 1A95 90 SWAP1 1A96 20 SHA3 1A97 54 SLOAD 1A98 61 PUSH2 0x1a7b 1A9B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1A88 stack[-2] = ~0x00 + stack[-2] // @1A8D memory[0x00:0x20] = ~0x00 + stack[-2] // @1A92 memory[0x20:0x40] = 0x04 // @1A97 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to 0x1a7b label_1A9C: // Incoming jump from 0x1A7A, if 0x00 - (storage[keccak256(memory[0x00:0x40])] & 0x0100000000000000000000000000000000000000000000000000000000) 1A9C 5B JUMPDEST 1A9D 50 POP // Stack delta = -1 // Block continues label_1A9E: // Incoming jump from 0x1A3A, if 0x01 > stack[-1] // Incoming jump from 0x1A9D // Incoming jump from 0x1A44, if !(stack[-1] < storage[0x00]) // Inputs[3] // { // @1AA1 memory[0x40:0x60] // @1ACA memory[0x40:0x60] // @1ACF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A9E 5B JUMPDEST 1A9F 60 PUSH1 0x40 1AA1 51 MLOAD 1AA2 7F PUSH32 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 1AC3 81 DUP2 1AC4 52 MSTORE 1AC5 60 PUSH1 0x04 1AC7 01 ADD 1AC8 60 PUSH1 0x40 1ACA 51 MLOAD 1ACB 80 DUP1 1ACC 91 SWAP2 1ACD 03 SUB 1ACE 90 SWAP1 1ACF FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AC4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xdf2d9b4200000000000000000000000000000000000000000000000000000000 // @1ACF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AD0: // Incoming call from 0x1191, returns to 0x1192 // Incoming call from 0x0C67, returns to 0x0C68 // Inputs[5] // { // @1AD4 storage[0x08] // @1AEA stack[-1] // @1B17 memory[0x40:0x60] // @1B43 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1B46 stack[-2] // } 1AD0 5B JUMPDEST 1AD1 60 PUSH1 0x08 1AD3 80 DUP1 1AD4 54 SLOAD 1AD5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AEA 83 DUP4 1AEB 81 DUP2 1AEC 16 AND 1AED 7F PUSH32 0xffffffffffffffffffffffff0000000000000000000000000000000000000000 1B0E 83 DUP4 1B0F 16 AND 1B10 81 DUP2 1B11 17 OR 1B12 90 SWAP1 1B13 93 SWAP4 1B14 55 SSTORE 1B15 60 PUSH1 0x40 1B17 51 MLOAD 1B18 91 SWAP2 1B19 16 AND 1B1A 91 SWAP2 1B1B 90 SWAP1 1B1C 82 DUP3 1B1D 90 SWAP1 1B1E 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1B3F 90 SWAP1 1B40 60 PUSH1 0x00 1B42 90 SWAP1 1B43 A3 LOG3 1B44 50 POP 1B45 50 POP 1B46 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1B14 storage[0x08] = (stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff) | (storage[0x08] & 0xffffffffffffffffffffffff0000000000000000000000000000000000000000) // @1B43 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x08] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // } // Block ends with unconditional jump to stack[-2] label_1B47: // Incoming call from 0x1026, returns to 0x1027 // Incoming call from 0x0CFA, returns to 0x0CFB // Incoming call from 0x0ECA, returns to 0x0ECB // Inputs[5] // { // @1B4B memory[0x40:0x60] // @1B6E stack[-1] // @1B79 memory[0x00:0x40] // @1B7A storage[keccak256(memory[0x00:0x40])] // @1B82 memory[0x40:0x60] // } 1B47 5B JUMPDEST 1B48 60 PUSH1 0x40 1B4A 80 DUP1 1B4B 51 MLOAD 1B4C 60 PUSH1 0x80 1B4E 81 DUP2 1B4F 01 ADD 1B50 82 DUP3 1B51 52 MSTORE 1B52 60 PUSH1 0x00 1B54 80 DUP1 1B55 82 DUP3 1B56 52 MSTORE 1B57 60 PUSH1 0x20 1B59 82 DUP3 1B5A 01 ADD 1B5B 81 DUP2 1B5C 90 SWAP1 1B5D 52 MSTORE 1B5E 91 SWAP2 1B5F 81 DUP2 1B60 01 ADD 1B61 82 DUP3 1B62 90 SWAP1 1B63 52 MSTORE 1B64 60 PUSH1 0x60 1B66 81 DUP2 1B67 01 ADD 1B68 91 SWAP2 1B69 90 SWAP1 1B6A 91 SWAP2 1B6B 52 MSTORE 1B6C 60 PUSH1 0x00 1B6E 82 DUP3 1B6F 81 DUP2 1B70 52 MSTORE 1B71 60 PUSH1 0x04 1B73 60 PUSH1 0x20 1B75 52 MSTORE 1B76 60 PUSH1 0x40 1B78 90 SWAP1 1B79 20 SHA3 1B7A 54 SLOAD 1B7B 61 PUSH2 0x0643 1B7E 90 SWAP1 1B7F 60 PUSH1 0x40 1B81 80 DUP1 1B82 51 MLOAD 1B83 60 PUSH1 0x80 1B85 81 DUP2 1B86 01 ADD 1B87 82 DUP3 1B88 52 MSTORE 1B89 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B9E 83 DUP4 1B9F 16 AND 1BA0 81 DUP2 1BA1 52 MSTORE 1BA2 60 PUSH1 0xa0 1BA4 83 DUP4 1BA5 90 SWAP1 1BA6 1C SHR 1BA7 67 PUSH8 0xffffffffffffffff 1BB0 16 AND 1BB1 60 PUSH1 0x20 1BB3 82 DUP3 1BB4 01 ADD 1BB5 52 MSTORE 1BB6 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 1BD4 83 DUP4 1BD5 16 AND 1BD6 15 ISZERO 1BD7 15 ISZERO 1BD8 91 SWAP2 1BD9 81 DUP2 1BDA 01 ADD 1BDB 91 SWAP2 1BDC 90 SWAP1 1BDD 91 SWAP2 1BDE 52 MSTORE 1BDF 60 PUSH1 0xe8 1BE1 91 SWAP2 1BE2 90 SWAP1 1BE3 91 SWAP2 1BE4 1C SHR 1BE5 60 PUSH1 0x60 1BE7 82 DUP3 1BE8 01 ADD 1BE9 52 MSTORE 1BEA 90 SWAP1 1BEB 56 *JUMP // Stack delta = +2 // Outputs[14] // { // @1B51 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @1B56 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1B5D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1B63 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1B6A stack[0] = memory[0x40:0x60] // @1B6B memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @1B70 memory[0x00:0x20] = stack[-1] // @1B75 memory[0x20:0x40] = 0x04 // @1B88 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @1BA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & 0xffffffffffffffffffffffffffffffffffffffff // @1BB5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & (storage[keccak256(memory[0x00:0x40])] >> 0xa0) // @1BDE memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(storage[keccak256(memory[0x00:0x40])] & 0x0100000000000000000000000000000000000000000000000000000000) // @1BE9 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = storage[keccak256(memory[0x00:0x40])] >> 0xe8 // @1BEA stack[1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0643 1BEC 5B JUMPDEST 1BED 33 CALLER 1BEE 60 PUSH1 0x00 1BF0 81 DUP2 1BF1 81 DUP2 1BF2 52 MSTORE 1BF3 60 PUSH1 0x07 1BF5 60 PUSH1 0x20 1BF7 90 SWAP1 1BF8 81 DUP2 1BF9 52 MSTORE 1BFA 60 PUSH1 0x40 1BFC 80 DUP1 1BFD 83 DUP4 1BFE 20 SHA3 1BFF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C14 87 DUP8 1C15 16 AND 1C16 80 DUP1 1C17 85 DUP6 1C18 52 MSTORE 1C19 90 SWAP1 1C1A 83 DUP4 1C1B 52 MSTORE 1C1C 92 SWAP3 1C1D 81 DUP2 1C1E 90 SWAP1 1C1F 20 SHA3 1C20 80 DUP1 1C21 54 SLOAD 1C22 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 1C43 16 AND 1C44 86 DUP7 1C45 15 ISZERO 1C46 15 ISZERO 1C47 90 SWAP1 1C48 81 DUP2 1C49 17 OR 1C4A 90 SWAP1 1C4B 91 SWAP2 1C4C 55 SSTORE 1C4D 90 SWAP1 1C4E 51 MLOAD 1C4F 90 SWAP1 1C50 81 DUP2 1C51 52 MSTORE 1C52 91 SWAP2 1C53 92 SWAP3 1C54 91 SWAP2 1C55 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1C76 91 SWAP2 1C77 01 ADD 1C78 60 PUSH1 0x40 1C7A 51 MLOAD 1C7B 80 DUP1 1C7C 91 SWAP2 1C7D 03 SUB 1C7E 90 SWAP1 1C7F A3 LOG3 1C80 50 POP 1C81 50 POP 1C82 56 *JUMP label_1C83: // Incoming call from 0x0FB2, returns to 0x0FB3 // Inputs[3] // { // @1C87 stack[-4] // @1C88 stack[-3] // @1C89 stack[-2] // } 1C83 5B JUMPDEST 1C84 61 PUSH2 0x1c8e 1C87 84 DUP5 1C88 84 DUP5 1C89 84 DUP5 1C8A 61 PUSH2 0x0855 1C8D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1C84 stack[0] = 0x1c8e // @1C87 stack[1] = stack[-4] // @1C88 stack[2] = stack[-3] // @1C89 stack[3] = stack[-2] // } // Block ends with call to 0x0855, returns to 0x1C8E label_1C8E: // Incoming return from call to 0x0855 at 0x1C8D // Inputs[2] // { // @1CA4 stack[-3] // @1CA6 address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1C8E 5B JUMPDEST 1C8F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CA4 83 DUP4 1CA5 16 AND 1CA6 3B EXTCODESIZE 1CA7 15 ISZERO 1CA8 61 PUSH2 0x0887 1CAB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0887, if !address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1CAC: // Incoming jump from 0x1CAB, if not !address(stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[4] // { // @1CAF stack[-4] // @1CB0 stack[-3] // @1CB1 stack[-2] // @1CB2 stack[-1] // } 1CAC 61 PUSH2 0x1cb7 1CAF 84 DUP5 1CB0 84 DUP5 1CB1 84 DUP5 1CB2 84 DUP5 1CB3 61 PUSH2 0x1dde 1CB6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1CAC stack[0] = 0x1cb7 // @1CAF stack[1] = stack[-4] // @1CB0 stack[2] = stack[-3] // @1CB1 stack[3] = stack[-2] // @1CB2 stack[4] = stack[-1] // } // Block ends with unconditional jump to 0x1dde 1CB7 5B JUMPDEST 1CB8 61 PUSH2 0x0887 1CBB 57 *JUMPI 1CBC 60 PUSH1 0x40 1CBE 51 MLOAD 1CBF 7F PUSH32 0xd1a57ed600000000000000000000000000000000000000000000000000000000 1CE0 81 DUP2 1CE1 52 MSTORE 1CE2 60 PUSH1 0x04 1CE4 01 ADD 1CE5 60 PUSH1 0x40 1CE7 51 MLOAD 1CE8 80 DUP1 1CE9 91 SWAP2 1CEA 03 SUB 1CEB 90 SWAP1 1CEC FD *REVERT label_1CED: // Incoming jump from 0x1041 // Inputs[2] // { // @1CF1 memory[0x40:0x60] // @1D18 stack[-1] // } 1CED 5B JUMPDEST 1CEE 60 PUSH1 0x40 1CF0 80 DUP1 1CF1 51 MLOAD 1CF2 60 PUSH1 0x80 1CF4 81 DUP2 1CF5 01 ADD 1CF6 82 DUP3 1CF7 52 MSTORE 1CF8 60 PUSH1 0x00 1CFA 80 DUP1 1CFB 82 DUP3 1CFC 52 MSTORE 1CFD 60 PUSH1 0x20 1CFF 82 DUP3 1D00 01 ADD 1D01 81 DUP2 1D02 90 SWAP1 1D03 52 MSTORE 1D04 91 SWAP2 1D05 81 DUP2 1D06 01 ADD 1D07 82 DUP3 1D08 90 SWAP1 1D09 52 MSTORE 1D0A 60 PUSH1 0x60 1D0C 81 DUP2 1D0D 01 ADD 1D0E 91 SWAP2 1D0F 90 SWAP1 1D10 91 SWAP2 1D11 52 MSTORE 1D12 61 PUSH2 0x0643 1D15 61 PUSH2 0x1d1d 1D18 83 DUP4 1D19 61 PUSH2 0x1a2f 1D1C 56 *JUMP // Stack delta = +4 // Outputs[9] // { // @1CF7 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @1CFC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1D03 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @1D09 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1D10 stack[0] = memory[0x40:0x60] // @1D11 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @1D12 stack[1] = 0x0643 // @1D15 stack[2] = 0x1d1d // @1D18 stack[3] = stack[-1] // } // Block ends with call to 0x1a2f, returns to 0x1D1D label_1D1D: // Incoming return from call to 0x1A2F at 0x1D1C // Inputs[3] // { // @1D21 memory[0x40:0x60] // @1D3D stack[-1] // @1D89 stack[-2] // } 1D1D 5B JUMPDEST 1D1E 60 PUSH1 0x40 1D20 80 DUP1 1D21 51 MLOAD 1D22 60 PUSH1 0x80 1D24 81 DUP2 1D25 01 ADD 1D26 82 DUP3 1D27 52 MSTORE 1D28 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D3D 83 DUP4 1D3E 16 AND 1D3F 81 DUP2 1D40 52 MSTORE 1D41 60 PUSH1 0xa0 1D43 83 DUP4 1D44 90 SWAP1 1D45 1C SHR 1D46 67 PUSH8 0xffffffffffffffff 1D4F 16 AND 1D50 60 PUSH1 0x20 1D52 82 DUP3 1D53 01 ADD 1D54 52 MSTORE 1D55 7C PUSH29 0x0100000000000000000000000000000000000000000000000000000000 1D73 83 DUP4 1D74 16 AND 1D75 15 ISZERO 1D76 15 ISZERO 1D77 91 SWAP2 1D78 81 DUP2 1D79 01 ADD 1D7A 91 SWAP2 1D7B 90 SWAP1 1D7C 91 SWAP2 1D7D 52 MSTORE 1D7E 60 PUSH1 0xe8 1D80 91 SWAP2 1D81 90 SWAP1 1D82 91 SWAP2 1D83 1C SHR 1D84 60 PUSH1 0x60 1D86 82 DUP3 1D87 01 ADD 1D88 52 MSTORE 1D89 90 SWAP1 1D8A 56 *JUMP // Stack delta = -1 // Outputs[6] // { // @1D27 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @1D40 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @1D54 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffff & (stack[-1] >> 0xa0) // @1D7D memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(stack[-1] & 0x0100000000000000000000000000000000000000000000000000000000) // @1D88 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = stack[-1] >> 0xe8 // @1D89 stack[-2] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-2] label_1D8B: // Incoming jump from 0x108C // Inputs[1] { @1D91 storage[0x0b] } 1D8B 5B JUMPDEST 1D8C 60 PUSH1 0x60 1D8E 60 PUSH1 0x0b 1D90 80 DUP1 1D91 54 SLOAD 1D92 61 PUSH2 0x0754 1D95 90 SWAP1 1D96 61 PUSH2 0x25de 1D99 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D8C stack[0] = 0x60 // @1D8E stack[1] = 0x0b // @1D95 stack[2] = 0x0754 // @1D95 stack[3] = storage[0x0b] // } // Block ends with call to 0x25de, returns to 0x0754 1D9A 5B JUMPDEST 1D9B 60 PUSH1 0x60 1D9D 60 PUSH1 0xa0 1D9F 60 PUSH1 0x40 1DA1 51 MLOAD 1DA2 01 ADD 1DA3 80 DUP1 1DA4 60 PUSH1 0x40 1DA6 52 MSTORE 1DA7 60 PUSH1 0x20 1DA9 81 DUP2 1DAA 03 SUB 1DAB 91 SWAP2 1DAC 50 POP 1DAD 50 POP 1DAE 60 PUSH1 0x00 1DB0 81 DUP2 1DB1 52 MSTORE 1DB2 80 DUP1 1DB3 82 DUP3 1DB4 5B JUMPDEST 1DB5 60 PUSH1 0x01 1DB7 83 DUP4 1DB8 03 SUB 1DB9 92 SWAP3 1DBA 50 POP 1DBB 60 PUSH1 0x0a 1DBD 81 DUP2 1DBE 06 MOD 1DBF 60 PUSH1 0x30 1DC1 01 ADD 1DC2 83 DUP4 1DC3 53 MSTORE8 1DC4 60 PUSH1 0x0a 1DC6 90 SWAP1 1DC7 04 DIV 1DC8 80 DUP1 1DC9 61 PUSH2 0x1db4 1DCC 57 *JUMPI 1DCD 50 POP 1DCE 81 DUP2 1DCF 90 SWAP1 1DD0 03 SUB 1DD1 60 PUSH1 0x1f 1DD3 19 NOT 1DD4 90 SWAP1 1DD5 91 SWAP2 1DD6 01 ADD 1DD7 90 SWAP1 1DD8 81 DUP2 1DD9 52 MSTORE 1DDA 91 SWAP2 1DDB 90 SWAP1 1DDC 50 POP 1DDD 56 *JUMP label_1DDE: // Incoming jump from 0x1CB6 // Inputs[6] // { // @1DE1 memory[0x40:0x60] // @1E1D stack[-3] // @1E2A msg.sender // @1E2C stack[-4] // @1E2E stack[-2] // @1E30 stack[-1] // } 1DDE 5B JUMPDEST 1DDF 60 PUSH1 0x40 1DE1 51 MLOAD 1DE2 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 1E03 81 DUP2 1E04 52 MSTORE 1E05 60 PUSH1 0x00 1E07 90 SWAP1 1E08 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E1D 85 DUP6 1E1E 16 AND 1E1F 90 SWAP1 1E20 63 PUSH4 0x150b7a02 1E25 90 SWAP1 1E26 61 PUSH2 0x1e39 1E29 90 SWAP1 1E2A 33 CALLER 1E2B 90 SWAP1 1E2C 89 DUP10 1E2D 90 SWAP1 1E2E 88 DUP9 1E2F 90 SWAP1 1E30 88 DUP9 1E31 90 SWAP1 1E32 60 PUSH1 0x04 1E34 01 ADD 1E35 61 PUSH2 0x2855 1E38 56 *JUMP // Stack delta = +9 // Outputs[10] // { // @1E04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x150b7a0200000000000000000000000000000000000000000000000000000000 // @1E07 stack[0] = 0x00 // @1E1F stack[1] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @1E25 stack[2] = 0x150b7a02 // @1E29 stack[3] = 0x1e39 // @1E2B stack[4] = msg.sender // @1E2D stack[5] = stack[-4] // @1E2F stack[6] = stack[-2] // @1E31 stack[7] = stack[-1] // @1E34 stack[8] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2855, returns to 0x1E39 label_1E39: // Incoming return from call to 0x2855 at 0x1E38 // Inputs[6] // { // @1E3E memory[0x40:0x60] // @1E40 stack[-1] // @1E45 stack[-3] // @1E46 msg.gas // @1E47 address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1E47 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 1E39 5B JUMPDEST 1E3A 60 PUSH1 0x20 1E3C 60 PUSH1 0x40 1E3E 51 MLOAD 1E3F 80 DUP1 1E40 83 DUP4 1E41 03 SUB 1E42 81 DUP2 1E43 60 PUSH1 0x00 1E45 87 DUP8 1E46 5A GAS 1E47 F1 CALL 1E48 92 SWAP3 1E49 50 POP 1E4A 50 POP 1E4B 50 POP 1E4C 80 DUP1 1E4D 15 ISZERO 1E4E 61 PUSH2 0x1e74 1E51 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1E47 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1E48 stack[-3] = address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x1e74, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) label_1E52: // Incoming jump from 0x1E51, if not !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[2] // { // @1E56 memory[0x40:0x60] // @1E59 returndata.length // } 1E52 50 POP 1E53 60 PUSH1 0x40 1E55 80 DUP1 1E56 51 MLOAD 1E57 60 PUSH1 0x1f 1E59 3D RETURNDATASIZE 1E5A 90 SWAP1 1E5B 81 DUP2 1E5C 01 ADD 1E5D 60 PUSH1 0x1f 1E5F 19 NOT 1E60 16 AND 1E61 82 DUP3 1E62 01 ADD 1E63 90 SWAP1 1E64 92 SWAP3 1E65 52 MSTORE 1E66 61 PUSH2 0x1e71 1E69 91 SWAP2 1E6A 81 DUP2 1E6B 01 ADD 1E6C 90 SWAP1 1E6D 61 PUSH2 0x289e 1E70 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1E65 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1E69 stack[-1] = 0x1e71 // @1E6C stack[1] = memory[0x40:0x60] // @1E6C stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x289e 1E71 5B JUMPDEST 1E72 60 PUSH1 0x01 label_1E74: // Incoming jump from 0x1E51, if !address(stack[-3]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // Inputs[1] { @1E78 stack[-1] } 1E74 5B JUMPDEST 1E75 61 PUSH2 0x1eeb 1E78 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1eeb, if stack[-1] label_1E79: // Incoming jump from 0x1E78, if not stack[-1] // Inputs[1] { @1E79 returndata.length } 1E79 3D RETURNDATASIZE 1E7A 80 DUP1 1E7B 80 DUP1 1E7C 15 ISZERO 1E7D 61 PUSH2 0x1ea2 1E80 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E79 stack[0] = returndata.length // @1E7A stack[1] = returndata.length // } // Block ends with conditional jump to 0x1ea2, if !returndata.length label_1E81: // Incoming jump from 0x1E80, if not !returndata.length // Inputs[6] // { // @1E83 memory[0x40:0x60] // @1E84 stack[-2] // @1E8B returndata.length // @1E93 returndata.length // @1E96 returndata.length // @1E9D returndata[0x00:0x00 + returndata.length] // } 1E81 60 PUSH1 0x40 1E83 51 MLOAD 1E84 91 SWAP2 1E85 50 POP 1E86 60 PUSH1 0x1f 1E88 19 NOT 1E89 60 PUSH1 0x3f 1E8B 3D RETURNDATASIZE 1E8C 01 ADD 1E8D 16 AND 1E8E 82 DUP3 1E8F 01 ADD 1E90 60 PUSH1 0x40 1E92 52 MSTORE 1E93 3D RETURNDATASIZE 1E94 82 DUP3 1E95 52 MSTORE 1E96 3D RETURNDATASIZE 1E97 60 PUSH1 0x00 1E99 60 PUSH1 0x20 1E9B 84 DUP5 1E9C 01 ADD 1E9D 3E RETURNDATACOPY 1E9E 61 PUSH2 0x1ea7 1EA1 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1E84 stack[-2] = memory[0x40:0x60] // @1E92 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1E95 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1E9D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1ea7 label_1EA2: // Incoming jump from 0x1E80, if !returndata.length // Inputs[2] // { // @1EA5 stack[-2] // @1EAA memory[0x60:0x80] // } 1EA2 5B JUMPDEST 1EA3 60 PUSH1 0x60 1EA5 91 SWAP2 1EA6 50 POP 1EA7 5B JUMPDEST 1EA8 50 POP 1EA9 80 DUP1 1EAA 51 MLOAD 1EAB 60 PUSH1 0x00 1EAD 03 SUB 1EAE 61 PUSH2 0x1ee3 1EB1 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1EA5 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1ee3, if 0x00 - memory[0x60:0x80] label_1EB2: // Incoming jump from 0x1EB1, if not 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1EB1, if not 0x00 - memory[0x60:0x80] // Inputs[3] // { // @1EB4 memory[0x40:0x60] // @1EDD memory[0x40:0x60] // @1EE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1EB2 60 PUSH1 0x40 1EB4 51 MLOAD 1EB5 7F PUSH32 0xd1a57ed600000000000000000000000000000000000000000000000000000000 1ED6 81 DUP2 1ED7 52 MSTORE 1ED8 60 PUSH1 0x04 1EDA 01 ADD 1EDB 60 PUSH1 0x40 1EDD 51 MLOAD 1EDE 80 DUP1 1EDF 91 SWAP2 1EE0 03 SUB 1EE1 90 SWAP1 1EE2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1ED7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xd1a57ed600000000000000000000000000000000000000000000000000000000 // @1EE2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1EE3: // Incoming jump from 0x1EB1, if 0x00 - memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1EB1, if 0x00 - memory[0x60:0x80] // Inputs[3] // { // @1EE4 stack[-1] // @1EE5 memory[stack[-1]:stack[-1] + 0x20] // @1EEA memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1EE3 5B JUMPDEST 1EE4 80 DUP1 1EE5 51 MLOAD 1EE6 81 DUP2 1EE7 60 PUSH1 0x20 1EE9 01 ADD 1EEA FD *REVERT // Stack delta = +0 // Outputs[1] { @1EEA revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1EEB: // Incoming jump from 0x1E78, if stack[-1] // Inputs[2] // { // @1F0D stack[-1] // @1F30 stack[-2] // } 1EEB 5B JUMPDEST 1EEC 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1F0D 16 AND 1F0E 7F PUSH32 0x150b7a0200000000000000000000000000000000000000000000000000000000 1F2F 14 EQ 1F30 90 SWAP1 1F31 50 POP // Stack delta = -1 // Outputs[1] { @1F30 stack[-2] = 0x150b7a0200000000000000000000000000000000000000000000000000000000 == 0xffffffff00000000000000000000000000000000000000000000000000000000 & stack[-1] } // Block continues label_1F32: // Incoming return from call to 0x200E at 0x2315 // Incoming jump from 0x1F31 // Inputs[3] // { // @1F33 stack[-1] // @1F33 stack[-6] // @1F34 stack[-5] // } 1F32 5B JUMPDEST 1F33 94 SWAP5 1F34 93 SWAP4 1F35 50 POP 1F36 50 POP 1F37 50 POP 1F38 50 POP 1F39 56 *JUMP // Stack delta = -5 // Outputs[1] { @1F33 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_1F3A: // Incoming call from 0x1F84, returns to 0x0F65 // Incoming call from 0x28BA, returns to 0x0F65 // Inputs[1] { @1F5C stack[-1] } 1F3A 5B JUMPDEST 1F3B 7F PUSH32 0xffffffff00000000000000000000000000000000000000000000000000000000 1F5C 81 DUP2 1F5D 16 AND 1F5E 81 DUP2 1F5F 14 EQ 1F60 61 PUSH2 0x1192 1F63 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1192, if stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 label_1F64: // Incoming jump from 0x1F63, if not stack[-1] == stack[-1] & 0xffffffff00000000000000000000000000000000000000000000000000000000 // Inputs[1] { @1F67 memory[0x00:0x00] } 1F64 60 PUSH1 0x00 1F66 80 DUP1 1F67 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F67 revert(memory[0x00:0x00]); } // Block terminates label_1F68: // Incoming call from 0x01EC, returns to 0x01ED // Inputs[2] // { // @1F6D stack[-1] // @1F6E stack[-2] // } 1F68 5B JUMPDEST 1F69 60 PUSH1 0x00 1F6B 60 PUSH1 0x20 1F6D 82 DUP3 1F6E 84 DUP5 1F6F 03 SUB 1F70 12 SLT 1F71 15 ISZERO 1F72 61 PUSH2 0x1f7a 1F75 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F69 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f7a, if !(stack[-2] - stack[-1] i< 0x20) label_1F76: // Incoming jump from 0x1F75, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F79 memory[0x00:0x00] } 1F76 60 PUSH1 0x00 1F78 80 DUP1 1F79 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F79 revert(memory[0x00:0x00]); } // Block terminates label_1F7A: // Incoming jump from 0x1F75, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1F7B stack[-2] // @1F7C msg.data[stack[-2]:stack[-2] + 0x20] // } 1F7A 5B JUMPDEST 1F7B 81 DUP2 1F7C 35 CALLDATALOAD 1F7D 61 PUSH2 0x0f65 1F80 81 DUP2 1F81 61 PUSH2 0x1f3a 1F84 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1F7C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1F7D stack[1] = 0x0f65 // @1F80 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1f3a, returns to 0x0F65 label_1F85: // Incoming call from 0x2501, returns to 0x2502 // Incoming call from 0x20EF, returns to 0x20F0 // Incoming call from 0x2485, returns to 0x2486 // Incoming call from 0x21B3, returns to 0x21B4 // Incoming call from 0x25B8, returns to 0x25B9 // Incoming call from 0x21DF, returns to 0x21E0 // Incoming call from 0x22B1, returns to 0x22B2 // Incoming call from 0x25AA, returns to 0x25AB // Incoming call from 0x20A1, returns to 0x20A2 // Incoming call from 0x21ED, returns to 0x21EE // Incoming call from 0x24C4, returns to 0x24C5 // Incoming call from 0x24F3, returns to 0x24F4 // Incoming call from 0x242F, returns to 0x0F65 // Inputs[2] // { // @1F86 stack[-1] // @1F87 msg.data[stack[-1]:stack[-1] + 0x20] // } 1F85 5B JUMPDEST 1F86 80 DUP1 1F87 35 CALLDATALOAD 1F88 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F9D 81 DUP2 1F9E 16 AND 1F9F 81 DUP2 1FA0 14 EQ 1FA1 61 PUSH2 0x1fa9 1FA4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F87 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x1fa9, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff label_1FA5: // Incoming jump from 0x1FA4, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @1FA8 memory[0x00:0x00] } 1FA5 60 PUSH1 0x00 1FA7 80 DUP1 1FA8 FD *REVERT // Stack delta = +0 // Outputs[1] { @1FA8 revert(memory[0x00:0x00]); } // Block terminates label_1FA9: // Incoming jump from 0x1FA4, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[3] // { // @1FAA stack[-3] // @1FAA stack[-1] // @1FAB stack[-2] // } 1FA9 5B JUMPDEST 1FAA 91 SWAP2 1FAB 90 SWAP1 1FAC 50 POP 1FAD 56 *JUMP // Stack delta = -2 // Outputs[1] { @1FAA stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1FAE: // Incoming jump from 0x2762 // Incoming jump from 0x2270 // Incoming jump from 0x2027 // Incoming jump from 0x0B1A // Incoming jump from 0x0E4F // Incoming jump from 0x2005 // Incoming jump from 0x0C96 // Inputs[1] { @1FDC memory[0x00:0x24] } 1FAE 5B JUMPDEST 1FAF 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 1FD0 60 PUSH1 0x00 1FD2 52 MSTORE 1FD3 60 PUSH1 0x41 1FD5 60 PUSH1 0x04 1FD7 52 MSTORE 1FD8 60 PUSH1 0x24 1FDA 60 PUSH1 0x00 1FDC FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1FD2 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @1FD7 memory[0x04:0x24] = 0x41 // @1FDC revert(memory[0x00:0x24]); // } // Block terminates label_1FDD: // Incoming call from 0x2281, returns to 0x2282 // Incoming call from 0x203A, returns to 0x203B // Inputs[2] // { // @1FE0 memory[0x40:0x60] // @1FE3 stack[-1] // } 1FDD 5B JUMPDEST 1FDE 60 PUSH1 0x40 1FE0 51 MLOAD 1FE1 60 PUSH1 0x1f 1FE3 82 DUP3 1FE4 01 ADD 1FE5 60 PUSH1 0x1f 1FE7 19 NOT 1FE8 16 AND 1FE9 81 DUP2 1FEA 01 ADD 1FEB 67 PUSH8 0xffffffffffffffff 1FF4 81 DUP2 1FF5 11 GT 1FF6 82 DUP3 1FF7 82 DUP3 1FF8 10 LT 1FF9 17 OR 1FFA 15 ISZERO 1FFB 61 PUSH2 0x2006 1FFE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FE0 stack[0] = memory[0x40:0x60] // @1FEA stack[1] = memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) // } // Block ends with conditional jump to 0x2006, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) label_1FFF: // Incoming jump from 0x1FFE, if not !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) 1FFF 61 PUSH2 0x2006 2002 61 PUSH2 0x1fae 2005 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FFF stack[0] = 0x2006 } // Block ends with unconditional jump to 0x1fae label_2006: // Incoming jump from 0x1FFE, if !((memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (~0x1f & stack[-1] + 0x1f) > 0xffffffffffffffff)) // Inputs[4] // { // @2009 stack[-1] // @200A stack[-4] // @200A stack[-2] // @200B stack[-3] // } 2006 5B JUMPDEST 2007 60 PUSH1 0x40 2009 52 MSTORE 200A 91 SWAP2 200B 90 SWAP1 200C 50 POP 200D 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2009 memory[0x40:0x60] = stack[-1] // @200A stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_200E: // Incoming call from 0x2315, returns to 0x1F32 // Incoming call from 0x2085, returns to 0x0F65 // Inputs[1] { @201A stack[-2] } 200E 5B JUMPDEST 200F 60 PUSH1 0x00 2011 67 PUSH8 0xffffffffffffffff 201A 83 DUP4 201B 11 GT 201C 15 ISZERO 201D 61 PUSH2 0x2028 2020 57 *JUMPI // Stack delta = +1 // Outputs[1] { @200F stack[0] = 0x00 } // Block ends with conditional jump to 0x2028, if !(stack[-2] > 0xffffffffffffffff) label_2021: // Incoming jump from 0x2020, if not !(stack[-2] > 0xffffffffffffffff) 2021 61 PUSH2 0x2028 2024 61 PUSH2 0x1fae 2027 56 *JUMP // Stack delta = +1 // Outputs[1] { @2021 stack[0] = 0x2028 } // Block ends with unconditional jump to 0x1fae label_2028: // Incoming jump from 0x2020, if !(stack[-2] > 0xffffffffffffffff) // Inputs[1] { @2033 stack[-3] } 2028 5B JUMPDEST 2029 61 PUSH2 0x203b 202C 60 PUSH1 0x20 202E 60 PUSH1 0x1f 2030 19 NOT 2031 60 PUSH1 0x1f 2033 86 DUP7 2034 01 ADD 2035 16 AND 2036 01 ADD 2037 61 PUSH2 0x1fdd 203A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2029 stack[0] = 0x203b // @2036 stack[1] = (stack[-3] + 0x1f & ~0x1f) + 0x20 // } // Block ends with call to 0x1fdd, returns to 0x203B label_203B: // Incoming return from call to 0x1FDD at 0x203A // Inputs[5] // { // @203C stack[-1] // @203C stack[-2] // @203E stack[-4] // @2041 stack[-5] // @2043 stack[-3] // } 203B 5B JUMPDEST 203C 90 SWAP1 203D 50 POP 203E 82 DUP3 203F 81 DUP2 2040 52 MSTORE 2041 83 DUP4 2042 83 DUP4 2043 83 DUP4 2044 01 ADD 2045 11 GT 2046 15 ISZERO 2047 61 PUSH2 0x204f 204A 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @203C stack[-2] = stack[-1] // @2040 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // } // Block ends with conditional jump to 0x204f, if !(stack[-3] + stack[-4] > stack[-5]) label_204B: // Incoming jump from 0x204A, if not !(stack[-3] + stack[-4] > stack[-5]) // Inputs[1] { @204E memory[0x00:0x00] } 204B 60 PUSH1 0x00 204D 80 DUP1 204E FD *REVERT // Stack delta = +0 // Outputs[1] { @204E revert(memory[0x00:0x00]); } // Block terminates label_204F: // Incoming jump from 0x204A, if !(stack[-3] + stack[-4] > stack[-5]) // Inputs[6] // { // @2050 stack[-3] // @2051 stack[-2] // @2054 stack[-1] // @2056 msg.data[stack[-2]:stack[-2] + stack[-3]] // @2060 stack[-5] // @2061 stack[-4] // } 204F 5B JUMPDEST 2050 82 DUP3 2051 82 DUP3 2052 60 PUSH1 0x20 2054 83 DUP4 2055 01 ADD 2056 37 CALLDATACOPY 2057 60 PUSH1 0x00 2059 60 PUSH1 0x20 205B 84 DUP5 205C 83 DUP4 205D 01 ADD 205E 01 ADD 205F 52 MSTORE 2060 93 SWAP4 2061 92 SWAP3 2062 50 POP 2063 50 POP 2064 50 POP 2065 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2056 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-3]] = msg.data[stack[-2]:stack[-2] + stack[-3]] // @205F memory[stack[-1] + stack[-3] + 0x20:stack[-1] + stack[-3] + 0x20 + 0x20] = 0x00 // @2060 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_2066: // Incoming call from 0x2530, returns to 0x2531 // Incoming call from 0x20C9, returns to 0x20CA // Inputs[2] // { // @2069 stack[-2] // @206C stack[-1] // } 2066 5B JUMPDEST 2067 60 PUSH1 0x00 2069 82 DUP3 206A 60 PUSH1 0x1f 206C 83 DUP4 206D 01 ADD 206E 12 SLT 206F 61 PUSH2 0x2077 2072 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2067 stack[0] = 0x00 } // Block ends with conditional jump to 0x2077, if stack[-1] + 0x1f i< stack[-2] label_2073: // Incoming jump from 0x2072, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2076 memory[0x00:0x00] } 2073 60 PUSH1 0x00 2075 80 DUP1 2076 FD *REVERT // Stack delta = +0 // Outputs[1] { @2076 revert(memory[0x00:0x00]); } // Block terminates label_2077: // Incoming jump from 0x2072, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @207B stack[-3] // @207C stack[-2] // @207D msg.data[stack[-2]:stack[-2] + 0x20] // } 2077 5B JUMPDEST 2078 61 PUSH2 0x0f65 207B 83 DUP4 207C 83 DUP4 207D 35 CALLDATALOAD 207E 60 PUSH1 0x20 2080 85 DUP6 2081 01 ADD 2082 61 PUSH2 0x200e 2085 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2078 stack[0] = 0x0f65 // @207B stack[1] = stack[-3] // @207D stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @2081 stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x200e, returns to 0x0F65 label_2086: // Incoming call from 0x0221, returns to 0x0222 // Inputs[2] // { // @208C stack[-1] // @208D stack[-2] // } 2086 5B JUMPDEST 2087 60 PUSH1 0x00 2089 80 DUP1 208A 60 PUSH1 0x40 208C 83 DUP4 208D 85 DUP6 208E 03 SUB 208F 12 SLT 2090 15 ISZERO 2091 61 PUSH2 0x2099 2094 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2087 stack[0] = 0x00 // @2089 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2099, if !(stack[-2] - stack[-1] i< 0x40) label_2095: // Incoming jump from 0x2094, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2098 memory[0x00:0x00] } 2095 60 PUSH1 0x00 2097 80 DUP1 2098 FD *REVERT // Stack delta = +0 // Outputs[1] { @2098 revert(memory[0x00:0x00]); } // Block terminates label_2099: // Incoming jump from 0x2094, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @209D stack[-3] } 2099 5B JUMPDEST 209A 61 PUSH2 0x20a2 209D 83 DUP4 209E 61 PUSH2 0x1f85 20A1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @209A stack[0] = 0x20a2 // @209D stack[1] = stack[-3] // } // Block ends with call to 0x1f85, returns to 0x20A2 label_20A2: // Incoming return from call to 0x1F85 at 0x20A1 // Inputs[4] // { // @20A3 stack[-1] // @20A3 stack[-3] // @20A7 stack[-4] // @20A9 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 20A2 5B JUMPDEST 20A3 91 SWAP2 20A4 50 POP 20A5 60 PUSH1 0x20 20A7 83 DUP4 20A8 01 ADD 20A9 35 CALLDATALOAD 20AA 67 PUSH8 0xffffffffffffffff 20B3 81 DUP2 20B4 11 GT 20B5 15 ISZERO 20B6 61 PUSH2 0x20be 20B9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @20A3 stack[-3] = stack[-1] // @20A9 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x20be, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) label_20BA: // Incoming jump from 0x20B9, if not !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @20BD memory[0x00:0x00] } 20BA 60 PUSH1 0x00 20BC 80 DUP1 20BD FD *REVERT // Stack delta = +0 // Outputs[1] { @20BD revert(memory[0x00:0x00]); } // Block terminates label_20BE: // Incoming jump from 0x20B9, if !(msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @20C2 stack[-5] // @20C3 stack[-1] // @20C4 stack[-4] // } 20BE 5B JUMPDEST 20BF 61 PUSH2 0x20ca 20C2 85 DUP6 20C3 82 DUP3 20C4 86 DUP7 20C5 01 ADD 20C6 61 PUSH2 0x2066 20C9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20BF stack[0] = 0x20ca // @20C2 stack[1] = stack[-5] // @20C5 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x2066, returns to 0x20CA label_20CA: // Incoming return from call to 0x2066 at 0x20C9 // Inputs[6] // { // @20CB stack[-3] // @20CB stack[-1] // @20CE stack[-6] // @20D0 stack[-7] // @20D0 stack[-4] // @20D1 stack[-5] // } 20CA 5B JUMPDEST 20CB 91 SWAP2 20CC 50 POP 20CD 50 POP 20CE 92 SWAP3 20CF 50 POP 20D0 92 SWAP3 20D1 90 SWAP1 20D2 50 POP 20D3 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @20CE stack[-6] = stack[-1] // @20D0 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_20D4: // Incoming call from 0x0243, returns to 0x0244 // Inputs[2] // { // @20DA stack[-1] // @20DB stack[-2] // } 20D4 5B JUMPDEST 20D5 60 PUSH1 0x00 20D7 80 DUP1 20D8 60 PUSH1 0x40 20DA 83 DUP4 20DB 85 DUP6 20DC 03 SUB 20DD 12 SLT 20DE 15 ISZERO 20DF 61 PUSH2 0x20e7 20E2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20D5 stack[0] = 0x00 // @20D7 stack[1] = 0x00 // } // Block ends with conditional jump to 0x20e7, if !(stack[-2] - stack[-1] i< 0x40) label_20E3: // Incoming jump from 0x20E2, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20E6 memory[0x00:0x00] } 20E3 60 PUSH1 0x00 20E5 80 DUP1 20E6 FD *REVERT // Stack delta = +0 // Outputs[1] { @20E6 revert(memory[0x00:0x00]); } // Block terminates label_20E7: // Incoming jump from 0x20E2, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @20EB stack[-3] } 20E7 5B JUMPDEST 20E8 61 PUSH2 0x20f0 20EB 83 DUP4 20EC 61 PUSH2 0x1f85 20EF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20E8 stack[0] = 0x20f0 // @20EB stack[1] = stack[-3] // } // Block ends with call to 0x1f85, returns to 0x20F0 label_20F0: // Incoming return from call to 0x1F85 at 0x20EF // Inputs[4] // { // @20F1 stack[-3] // @20F1 stack[-1] // @20F5 stack[-4] // @20F7 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 20F0 5B JUMPDEST 20F1 91 SWAP2 20F2 50 POP 20F3 60 PUSH1 0x20 20F5 83 DUP4 20F6 01 ADD 20F7 35 CALLDATALOAD 20F8 6B PUSH12 0xffffffffffffffffffffffff 2105 81 DUP2 2106 16 AND 2107 81 DUP2 2108 14 EQ 2109 61 PUSH2 0x2111 210C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @20F1 stack[-3] = stack[-1] // @20F7 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2111, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & 0xffffffffffffffffffffffff label_210D: // Incoming jump from 0x210C, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & 0xffffffffffffffffffffffff // Inputs[1] { @2110 memory[0x00:0x00] } 210D 60 PUSH1 0x00 210F 80 DUP1 2110 FD *REVERT // Stack delta = +0 // Outputs[1] { @2110 revert(memory[0x00:0x00]); } // Block terminates label_2111: // Incoming jump from 0x210C, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & 0xffffffffffffffffffffffff // Incoming return from call to 0x249B at 0x24D4 // Inputs[6] // { // @2112 stack[-1] // @2113 stack[-2] // @2116 stack[-5] // @2118 stack[-3] // @2118 stack[-6] // @2119 stack[-4] // } 2111 5B JUMPDEST 2112 80 DUP1 2113 91 SWAP2 2114 50 POP 2115 50 POP 2116 92 SWAP3 2117 50 POP 2118 92 SWAP3 2119 90 SWAP1 211A 50 POP 211B 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2116 stack[-5] = stack[-1] // @2118 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_211C: // Incoming call from 0x2157, returns to 0x2158 // Incoming call from 0x25D3, returns to 0x25D4 // Inputs[1] { @2120 stack[-3] } 211C 5B JUMPDEST 211D 60 PUSH1 0x00 211F 5B JUMPDEST 2120 83 DUP4 2121 81 DUP2 2122 10 LT 2123 15 ISZERO 2124 61 PUSH2 0x2137 2127 57 *JUMPI // Stack delta = +1 // Outputs[1] { @211D stack[0] = 0x00 } // Block ends with conditional jump to 0x2137, if !(0x00 < stack[-3]) label_2128: // Incoming jump from 0x2127, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x2127, if not !(0x00 < stack[-3]) // Inputs[4] // { // @2128 stack[-2] // @2129 stack[-1] // @212B memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @212C stack[-3] // } 2128 81 DUP2 2129 81 DUP2 212A 01 ADD 212B 51 MLOAD 212C 83 DUP4 212D 82 DUP3 212E 01 ADD 212F 52 MSTORE 2130 60 PUSH1 0x20 2132 01 ADD 2133 61 PUSH2 0x211f 2136 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @212F memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @2132 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x211f label_2137: // Incoming jump from 0x2127, if !(stack[-1] < stack[-4]) // Incoming jump from 0x2127, if !(0x00 < stack[-3]) // Inputs[3] // { // @213C stack[-4] // @213D stack[-3] // @213F stack[-5] // } 2137 5B JUMPDEST 2138 50 POP 2139 50 POP 213A 60 PUSH1 0x00 213C 91 SWAP2 213D 01 ADD 213E 52 MSTORE 213F 56 *JUMP // Stack delta = -5 // Outputs[1] { @213E memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_2140: // Incoming call from 0x2893, returns to 0x2894 // Incoming call from 0x217E, returns to 0x0F65 // Inputs[3] // { // @2143 stack[-1] // @2144 memory[stack[-1]:stack[-1] + 0x20] // @2146 stack[-2] // } 2140 5B JUMPDEST 2141 60 PUSH1 0x00 2143 81 DUP2 2144 51 MLOAD 2145 80 DUP1 2146 84 DUP5 2147 52 MSTORE 2148 61 PUSH2 0x2158 214B 81 DUP2 214C 60 PUSH1 0x20 214E 86 DUP7 214F 01 ADD 2150 60 PUSH1 0x20 2152 86 DUP7 2153 01 ADD 2154 61 PUSH2 0x211c 2157 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @2141 stack[0] = 0x00 // @2144 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2147 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2148 stack[2] = 0x2158 // @214B stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @214F stack[4] = stack[-2] + 0x20 // @2153 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x211c, returns to 0x2158 label_2158: // Incoming return from call to 0x211C at 0x2157 // Inputs[4] // { // @215B stack[-1] // @2160 stack[-4] // @2161 stack[-2] // @2167 stack[-5] // } 2158 5B JUMPDEST 2159 60 PUSH1 0x1f 215B 01 ADD 215C 60 PUSH1 0x1f 215E 19 NOT 215F 16 AND 2160 92 SWAP3 2161 90 SWAP1 2162 92 SWAP3 2163 01 ADD 2164 60 PUSH1 0x20 2166 01 ADD 2167 92 SWAP3 2168 91 SWAP2 2169 50 POP 216A 50 POP 216B 56 *JUMP // Stack delta = -4 // Outputs[1] { @2167 stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_216C: // Incoming jump from 0x026A // Inputs[2] // { // @216F stack[-1] // @217A stack[-2] // } 216C 5B JUMPDEST 216D 60 PUSH1 0x20 216F 81 DUP2 2170 52 MSTORE 2171 60 PUSH1 0x00 2173 61 PUSH2 0x0f65 2176 60 PUSH1 0x20 2178 83 DUP4 2179 01 ADD 217A 84 DUP5 217B 61 PUSH2 0x2140 217E 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2170 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2171 stack[0] = 0x00 // @2173 stack[1] = 0x0f65 // @2179 stack[2] = stack[-1] + 0x20 // @217A stack[3] = stack[-2] // } // Block ends with call to 0x2140, returns to 0x0F65 label_217F: // Incoming call from 0x0285, returns to 0x0286 // Incoming call from 0x0571, returns to 0x0572 // Incoming call from 0x042F, returns to 0x0430 // Incoming call from 0x0544, returns to 0x0545 // Inputs[2] // { // @2184 stack[-1] // @2185 stack[-2] // } 217F 5B JUMPDEST 2180 60 PUSH1 0x00 2182 60 PUSH1 0x20 2184 82 DUP3 2185 84 DUP5 2186 03 SUB 2187 12 SLT 2188 15 ISZERO 2189 61 PUSH2 0x2191 218C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2180 stack[0] = 0x00 } // Block ends with conditional jump to 0x2191, if !(stack[-2] - stack[-1] i< 0x20) label_218D: // Incoming jump from 0x218C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2190 memory[0x00:0x00] } 218D 60 PUSH1 0x00 218F 80 DUP1 2190 FD *REVERT // Stack delta = +0 // Outputs[1] { @2190 revert(memory[0x00:0x00]); } // Block terminates label_2191: // Incoming jump from 0x218C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @2193 stack[-2] // @2193 msg.data[stack[-2]:stack[-2] + 0x20] // @2194 stack[-4] // @2195 stack[-3] // } 2191 5B JUMPDEST 2192 50 POP 2193 35 CALLDATALOAD 2194 91 SWAP2 2195 90 SWAP1 2196 50 POP 2197 56 *JUMP // Stack delta = -3 // Outputs[1] { @2194 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2198: // Incoming call from 0x02BD, returns to 0x02BE // Inputs[2] // { // @219E stack[-1] // @219F stack[-2] // } 2198 5B JUMPDEST 2199 60 PUSH1 0x00 219B 80 DUP1 219C 60 PUSH1 0x40 219E 83 DUP4 219F 85 DUP6 21A0 03 SUB 21A1 12 SLT 21A2 15 ISZERO 21A3 61 PUSH2 0x21ab 21A6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2199 stack[0] = 0x00 // @219B stack[1] = 0x00 // } // Block ends with conditional jump to 0x21ab, if !(stack[-2] - stack[-1] i< 0x40) label_21A7: // Incoming jump from 0x21A6, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @21AA memory[0x00:0x00] } 21A7 60 PUSH1 0x00 21A9 80 DUP1 21AA FD *REVERT // Stack delta = +0 // Outputs[1] { @21AA revert(memory[0x00:0x00]); } // Block terminates label_21AB: // Incoming jump from 0x21A6, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @21AF stack[-3] } 21AB 5B JUMPDEST 21AC 61 PUSH2 0x21b4 21AF 83 DUP4 21B0 61 PUSH2 0x1f85 21B3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21AC stack[0] = 0x21b4 // @21AF stack[1] = stack[-3] // } // Block ends with call to 0x1f85, returns to 0x21B4 label_21B4: // Incoming return from call to 0x1F85 at 0x21B3 // Inputs[5] // { // @21B5 stack[-1] // @21B5 stack[-6] // @21B8 stack[-4] // @21BC msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @21BD stack[-5] // } 21B4 5B JUMPDEST 21B5 94 SWAP5 21B6 60 PUSH1 0x20 21B8 93 SWAP4 21B9 90 SWAP1 21BA 93 SWAP4 21BB 01 ADD 21BC 35 CALLDATALOAD 21BD 93 SWAP4 21BE 50 POP 21BF 50 POP 21C0 50 POP 21C1 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @21B5 stack[-6] = stack[-1] // @21BD stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_21C2: // Incoming call from 0x02F7, returns to 0x02F8 // Incoming call from 0x03C2, returns to 0x03C3 // Inputs[2] // { // @21CA stack[-1] // @21CB stack[-2] // } 21C2 5B JUMPDEST 21C3 60 PUSH1 0x00 21C5 80 DUP1 21C6 60 PUSH1 0x00 21C8 60 PUSH1 0x60 21CA 84 DUP5 21CB 86 DUP7 21CC 03 SUB 21CD 12 SLT 21CE 15 ISZERO 21CF 61 PUSH2 0x21d7 21D2 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @21C3 stack[0] = 0x00 // @21C5 stack[1] = 0x00 // @21C6 stack[2] = 0x00 // } // Block ends with conditional jump to 0x21d7, if !(stack[-2] - stack[-1] i< 0x60) label_21D3: // Incoming jump from 0x21D2, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @21D6 memory[0x00:0x00] } 21D3 60 PUSH1 0x00 21D5 80 DUP1 21D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @21D6 revert(memory[0x00:0x00]); } // Block terminates label_21D7: // Incoming jump from 0x21D2, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @21DB stack[-4] } 21D7 5B JUMPDEST 21D8 61 PUSH2 0x21e0 21DB 84 DUP5 21DC 61 PUSH2 0x1f85 21DF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21D8 stack[0] = 0x21e0 // @21DB stack[1] = stack[-4] // } // Block ends with call to 0x1f85, returns to 0x21E0 label_21E0: // Incoming return from call to 0x1F85 at 0x21DF // Inputs[3] // { // @21E1 stack[-4] // @21E1 stack[-1] // @21E8 stack[-5] // } 21E0 5B JUMPDEST 21E1 92 SWAP3 21E2 50 POP 21E3 61 PUSH2 0x21ee 21E6 60 PUSH1 0x20 21E8 85 DUP6 21E9 01 ADD 21EA 61 PUSH2 0x1f85 21ED 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @21E1 stack[-4] = stack[-1] // @21E3 stack[-1] = 0x21ee // @21E9 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1f85, returns to 0x21EE label_21EE: // Incoming return from call to 0x1F85 at 0x21ED // Inputs[8] // { // @21EF stack[-3] // @21EF stack[-1] // @21F3 stack[-5] // @21F5 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @21F6 stack[-2] // @21FA stack[-6] // @21FC stack[-7] // @21FC stack[-4] // } 21EE 5B JUMPDEST 21EF 91 SWAP2 21F0 50 POP 21F1 60 PUSH1 0x40 21F3 84 DUP5 21F4 01 ADD 21F5 35 CALLDATALOAD 21F6 90 SWAP1 21F7 50 POP 21F8 92 SWAP3 21F9 50 POP 21FA 92 SWAP3 21FB 50 POP 21FC 92 SWAP3 21FD 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @21F8 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @21FA stack[-6] = stack[-1] // @21FC stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_21FE: // Incoming call from 0x0317, returns to 0x0318 // Inputs[2] // { // @2204 stack[-1] // @2205 stack[-2] // } 21FE 5B JUMPDEST 21FF 60 PUSH1 0x00 2201 80 DUP1 2202 60 PUSH1 0x40 2204 83 DUP4 2205 85 DUP6 2206 03 SUB 2207 12 SLT 2208 15 ISZERO 2209 61 PUSH2 0x2211 220C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21FF stack[0] = 0x00 // @2201 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2211, if !(stack[-2] - stack[-1] i< 0x40) label_220D: // Incoming jump from 0x220C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2210 memory[0x00:0x00] } 220D 60 PUSH1 0x00 220F 80 DUP1 2210 FD *REVERT // Stack delta = +0 // Outputs[1] { @2210 revert(memory[0x00:0x00]); } // Block terminates label_2211: // Incoming jump from 0x220C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @2214 stack[-3] // @2215 msg.data[stack[-3]:stack[-3] + 0x20] // @2216 stack[-5] // @221C msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @221D stack[-4] // } 2211 5B JUMPDEST 2212 50 POP 2213 50 POP 2214 80 DUP1 2215 35 CALLDATALOAD 2216 92 SWAP3 2217 60 PUSH1 0x20 2219 90 SWAP1 221A 91 SWAP2 221B 01 ADD 221C 35 CALLDATALOAD 221D 91 SWAP2 221E 50 POP 221F 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2216 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @221D stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_2220: // Incoming call from 0x0378, returns to 0x0379 // Inputs[2] // { // @2226 stack[-1] // @2227 stack[-2] // } 2220 5B JUMPDEST 2221 60 PUSH1 0x00 2223 60 PUSH1 0x20 2225 80 DUP1 2226 83 DUP4 2227 85 DUP6 2228 03 SUB 2229 12 SLT 222A 15 ISZERO 222B 61 PUSH2 0x2233 222E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2221 stack[0] = 0x00 // @2223 stack[1] = 0x20 // } // Block ends with conditional jump to 0x2233, if !(stack[-2] - stack[-1] i< 0x20) label_222F: // Incoming jump from 0x222E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2232 memory[0x00:0x00] } 222F 60 PUSH1 0x00 2231 80 DUP1 2232 FD *REVERT // Stack delta = +0 // Outputs[1] { @2232 revert(memory[0x00:0x00]); } // Block terminates label_2233: // Incoming jump from 0x222E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2234 stack[-3] // @2235 msg.data[stack[-3]:stack[-3] + 0x20] // } 2233 5B JUMPDEST 2234 82 DUP3 2235 35 CALLDATALOAD 2236 67 PUSH8 0xffffffffffffffff 223F 80 DUP1 2240 82 DUP3 2241 11 GT 2242 15 ISZERO 2243 61 PUSH2 0x224b 2246 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2235 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @2236 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x224b, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_2247: // Incoming jump from 0x2246, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @224A memory[0x00:0x00] } 2247 60 PUSH1 0x00 2249 80 DUP1 224A FD *REVERT // Stack delta = +0 // Outputs[1] { @224A revert(memory[0x00:0x00]); } // Block terminates label_224B: // Incoming jump from 0x2246, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @224C stack[-2] // @224D stack[-5] // @2251 stack[-6] // } 224B 5B JUMPDEST 224C 81 DUP2 224D 85 DUP6 224E 01 ADD 224F 91 SWAP2 2250 50 POP 2251 85 DUP6 2252 60 PUSH1 0x1f 2254 83 DUP4 2255 01 ADD 2256 12 SLT 2257 61 PUSH2 0x225f 225A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @224F stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x225f, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_225B: // Incoming jump from 0x225A, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @225E memory[0x00:0x00] } 225B 60 PUSH1 0x00 225D 80 DUP1 225E FD *REVERT // Stack delta = +0 // Outputs[1] { @225E revert(memory[0x00:0x00]); } // Block terminates label_225F: // Incoming jump from 0x225A, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @2260 stack[-2] // @2261 msg.data[stack[-2]:stack[-2] + 0x20] // @2262 stack[-1] // } 225F 5B JUMPDEST 2260 81 DUP2 2261 35 CALLDATALOAD 2262 81 DUP2 2263 81 DUP2 2264 11 GT 2265 15 ISZERO 2266 61 PUSH2 0x2271 2269 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2261 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2271, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_226A: // Incoming jump from 0x2269, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) 226A 61 PUSH2 0x2271 226D 61 PUSH2 0x1fae 2270 56 *JUMP // Stack delta = +1 // Outputs[1] { @226A stack[0] = 0x2271 } // Block ends with unconditional jump to 0x1fae label_2271: // Incoming jump from 0x2269, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @2272 stack[-1] // @2276 stack[-2] // @227B stack[-4] // } 2271 5B JUMPDEST 2272 80 DUP1 2273 60 PUSH1 0x05 2275 1B SHL 2276 91 SWAP2 2277 50 POP 2278 61 PUSH2 0x2282 227B 84 DUP5 227C 83 DUP4 227D 01 ADD 227E 61 PUSH2 0x1fdd 2281 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2276 stack[-2] = stack[-1] << 0x05 // @2278 stack[0] = 0x2282 // @227D stack[1] = (stack[-1] << 0x05) + stack[-4] // } // Block ends with call to 0x1fdd, returns to 0x2282 label_2282: // Incoming return from call to 0x1FDD at 0x2281 // Inputs[6] // { // @2283 stack[-2] // @2284 stack[-1] // @2286 stack[-3] // @2287 stack[-4] // @2289 stack[-5] // @2290 stack[-8] // } 2282 5B JUMPDEST 2283 81 DUP2 2284 81 DUP2 2285 52 MSTORE 2286 91 SWAP2 2287 83 DUP4 2288 01 ADD 2289 84 DUP5 228A 01 ADD 228B 91 SWAP2 228C 84 DUP5 228D 81 DUP2 228E 01 ADD 228F 90 SWAP1 2290 88 DUP9 2291 84 DUP5 2292 11 GT 2293 15 ISZERO 2294 61 PUSH2 0x229c 2297 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @2285 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] // @228B stack[-3] = stack[-5] + stack[-4] + stack[-3] // @228F stack[-1] = stack[-1] + stack[-5] // @228F stack[0] = stack[-1] // } // Block ends with conditional jump to 0x229c, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) label_2298: // Incoming jump from 0x2297, if not !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[1] { @229B memory[0x00:0x00] } 2298 60 PUSH1 0x00 229A 80 DUP1 229B FD *REVERT // Stack delta = +0 // Outputs[1] { @229B revert(memory[0x00:0x00]); } // Block terminates label_229C: // Incoming jump from 0x2297, if !(stack[-5] + stack[-4] + stack[-3] > stack[-8]) // Inputs[4] // { // @229D stack[-1] // @229D stack[-5] // @229E stack[-6] // @22A2 stack[-4] // } 229C 5B JUMPDEST 229D 93 SWAP4 229E 85 DUP6 229F 01 ADD 22A0 93 SWAP4 22A1 5B JUMPDEST 22A2 83 DUP4 22A3 85 DUP6 22A4 10 LT 22A5 15 ISZERO 22A6 61 PUSH2 0x22c1 22A9 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @22A0 stack[-5] = stack[-6] + stack[-5] // @22A0 stack[-1] = stack[-1] // } // Block ends with conditional jump to 0x22c1, if !(stack[-6] + stack[-5] < stack[-4]) label_22AA: // Incoming jump from 0x22A9, if not !(stack[-6] + stack[-5] < stack[-4]) // Incoming jump from 0x22A9, if not !(stack[-5] < stack[-4]) // Inputs[1] { @22AD stack[-5] } 22AA 61 PUSH2 0x22b2 22AD 85 DUP6 22AE 61 PUSH2 0x1f85 22B1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22AA stack[0] = 0x22b2 // @22AD stack[1] = stack[-5] // } // Block ends with call to 0x1f85, returns to 0x22B2 label_22B2: // Incoming return from call to 0x1F85 at 0x22B1 // Inputs[5] // { // @22B3 stack[-3] // @22B4 stack[-1] // @22B5 stack[-2] // @22B5 stack[-6] // @22B6 stack[-7] // } 22B2 5B JUMPDEST 22B3 82 DUP3 22B4 52 MSTORE 22B5 93 SWAP4 22B6 85 DUP6 22B7 01 ADD 22B8 93 SWAP4 22B9 90 SWAP1 22BA 85 DUP6 22BB 01 ADD 22BC 90 SWAP1 22BD 61 PUSH2 0x22a1 22C0 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @22B4 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @22B8 stack[-6] = stack[-7] + stack[-6] // @22BC stack[-2] = stack[-2] // @22BC stack[-3] = stack[-7] + stack[-3] // } // Block ends with unconditional jump to 0x22a1 label_22C1: // Incoming jump from 0x22A9, if !(stack[-6] + stack[-5] < stack[-4]) // Incoming jump from 0x22A9, if !(stack[-5] < stack[-4]) // Inputs[3] // { // @22C2 stack[-1] // @22C2 stack[-10] // @22C3 stack[-9] // } 22C1 5B JUMPDEST 22C2 98 SWAP9 22C3 97 SWAP8 22C4 50 POP 22C5 50 POP 22C6 50 POP 22C7 50 POP 22C8 50 POP 22C9 50 POP 22CA 50 POP 22CB 50 POP 22CC 56 *JUMP // Stack delta = -9 // Outputs[1] { @22C2 stack[-10] = stack[-1] } // Block ends with unconditional jump to stack[-10] label_22CD: // Incoming call from 0x03E2, returns to 0x03E3 // Inputs[2] // { // @22D2 stack[-1] // @22D3 stack[-2] // } 22CD 5B JUMPDEST 22CE 60 PUSH1 0x00 22D0 60 PUSH1 0x20 22D2 82 DUP3 22D3 84 DUP5 22D4 03 SUB 22D5 12 SLT 22D6 15 ISZERO 22D7 61 PUSH2 0x22df 22DA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22CE stack[0] = 0x00 } // Block ends with conditional jump to 0x22df, if !(stack[-2] - stack[-1] i< 0x20) label_22DB: // Incoming jump from 0x22DA, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22DE memory[0x00:0x00] } 22DB 60 PUSH1 0x00 22DD 80 DUP1 22DE FD *REVERT // Stack delta = +0 // Outputs[1] { @22DE revert(memory[0x00:0x00]); } // Block terminates label_22DF: // Incoming jump from 0x22DA, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @22E0 stack[-2] // @22E1 msg.data[stack[-2]:stack[-2] + 0x20] // } 22DF 5B JUMPDEST 22E0 81 DUP2 22E1 35 CALLDATALOAD 22E2 67 PUSH8 0xffffffffffffffff 22EB 81 DUP2 22EC 11 GT 22ED 15 ISZERO 22EE 61 PUSH2 0x22f6 22F1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22E1 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x22f6, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_22F2: // Incoming jump from 0x22F1, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @22F5 memory[0x00:0x00] } 22F2 60 PUSH1 0x00 22F4 80 DUP1 22F5 FD *REVERT // Stack delta = +0 // Outputs[1] { @22F5 revert(memory[0x00:0x00]); } // Block terminates label_22F6: // Incoming jump from 0x22F1, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @22F7 stack[-3] // @22F8 stack[-1] // @22FD stack[-4] // } 22F6 5B JUMPDEST 22F7 82 DUP3 22F8 01 ADD 22F9 60 PUSH1 0x1f 22FB 81 DUP2 22FC 01 ADD 22FD 84 DUP5 22FE 13 SGT 22FF 61 PUSH2 0x2307 2302 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22F8 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x2307, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_2303: // Incoming jump from 0x2302, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @2306 memory[0x00:0x00] } 2303 60 PUSH1 0x00 2305 80 DUP1 2306 FD *REVERT // Stack delta = +0 // Outputs[1] { @2306 revert(memory[0x00:0x00]); } // Block terminates label_2307: // Incoming jump from 0x2302, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @230B stack[-4] // @230C stack[-1] // @230D msg.data[stack[-1]:stack[-1] + 0x20] // } 2307 5B JUMPDEST 2308 61 PUSH2 0x1f32 230B 84 DUP5 230C 82 DUP3 230D 35 CALLDATALOAD 230E 60 PUSH1 0x20 2310 84 DUP5 2311 01 ADD 2312 61 PUSH2 0x200e 2315 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2308 stack[0] = 0x1f32 // @230B stack[1] = stack[-4] // @230D stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2311 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x200e, returns to 0x1F32 label_2316: // Incoming call from 0x0402, returns to 0x0403 // Inputs[2] // { // @231C stack[-1] // @231D stack[-2] // } 2316 5B JUMPDEST 2317 60 PUSH1 0x00 2319 80 DUP1 231A 60 PUSH1 0x20 231C 83 DUP4 231D 85 DUP6 231E 03 SUB 231F 12 SLT 2320 15 ISZERO 2321 61 PUSH2 0x2329 2324 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2317 stack[0] = 0x00 // @2319 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2329, if !(stack[-2] - stack[-1] i< 0x20) label_2325: // Incoming jump from 0x2324, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2328 memory[0x00:0x00] } 2325 60 PUSH1 0x00 2327 80 DUP1 2328 FD *REVERT // Stack delta = +0 // Outputs[1] { @2328 revert(memory[0x00:0x00]); } // Block terminates label_2329: // Incoming jump from 0x2324, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @232A stack[-3] // @232B msg.data[stack[-3]:stack[-3] + 0x20] // } 2329 5B JUMPDEST 232A 82 DUP3 232B 35 CALLDATALOAD 232C 67 PUSH8 0xffffffffffffffff 2335 80 DUP1 2336 82 DUP3 2337 11 GT 2338 15 ISZERO 2339 61 PUSH2 0x2341 233C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @232B stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @232C stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x2341, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_233D: // Incoming jump from 0x233C, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2340 memory[0x00:0x00] } 233D 60 PUSH1 0x00 233F 80 DUP1 2340 FD *REVERT // Stack delta = +0 // Outputs[1] { @2340 revert(memory[0x00:0x00]); } // Block terminates label_2341: // Incoming jump from 0x233C, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2342 stack[-2] // @2343 stack[-5] // @2347 stack[-6] // } 2341 5B JUMPDEST 2342 81 DUP2 2343 85 DUP6 2344 01 ADD 2345 91 SWAP2 2346 50 POP 2347 85 DUP6 2348 60 PUSH1 0x1f 234A 83 DUP4 234B 01 ADD 234C 12 SLT 234D 61 PUSH2 0x2355 2350 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2345 stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x2355, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_2351: // Incoming jump from 0x2350, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[1] { @2354 memory[0x00:0x00] } 2351 60 PUSH1 0x00 2353 80 DUP1 2354 FD *REVERT // Stack delta = +0 // Outputs[1] { @2354 revert(memory[0x00:0x00]); } // Block terminates label_2355: // Incoming jump from 0x2350, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @2356 stack[-2] // @2357 msg.data[stack[-2]:stack[-2] + 0x20] // @2358 stack[-1] // } 2355 5B JUMPDEST 2356 81 DUP2 2357 35 CALLDATALOAD 2358 81 DUP2 2359 81 DUP2 235A 11 GT 235B 15 ISZERO 235C 61 PUSH2 0x2364 235F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2357 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2364, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_2360: // Incoming jump from 0x235F, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[1] { @2363 memory[0x00:0x00] } 2360 60 PUSH1 0x00 2362 80 DUP1 2363 FD *REVERT // Stack delta = +0 // Outputs[1] { @2363 revert(memory[0x00:0x00]); } // Block terminates label_2364: // Incoming jump from 0x235F, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @2365 stack[-7] // @2368 stack[-1] // @236C stack[-3] // } 2364 5B JUMPDEST 2365 86 DUP7 2366 60 PUSH1 0x20 2368 82 DUP3 2369 60 PUSH1 0x05 236B 1B SHL 236C 85 DUP6 236D 01 ADD 236E 01 ADD 236F 11 GT 2370 15 ISZERO 2371 61 PUSH2 0x2379 2374 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2379, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) label_2375: // Incoming jump from 0x2374, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) // Inputs[1] { @2378 memory[0x00:0x00] } 2375 60 PUSH1 0x00 2377 80 DUP1 2378 FD *REVERT // Stack delta = +0 // Outputs[1] { @2378 revert(memory[0x00:0x00]); } // Block terminates label_2379: // Incoming jump from 0x2374, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-7]) // Inputs[6] // { // @237C stack[-3] // @237D stack[-1] // @2380 stack[-8] // @2382 stack[-7] // @2384 stack[-2] // @2385 stack[-6] // } 2379 5B JUMPDEST 237A 60 PUSH1 0x20 237C 92 SWAP3 237D 90 SWAP1 237E 92 SWAP3 237F 01 ADD 2380 96 SWAP7 2381 91 SWAP2 2382 95 SWAP6 2383 50 POP 2384 90 SWAP1 2385 93 SWAP4 2386 50 POP 2387 50 POP 2388 50 POP 2389 50 POP 238A 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @2380 stack[-8] = 0x20 + stack[-3] // @2382 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_238B: // Incoming call from 0x0414, returns to 0x01FE // Inputs[3] // { // @238F stack[-1] // @2391 stack[-2] // @2392 memory[stack[-2]:stack[-2] + 0x20] // } 238B 5B JUMPDEST 238C 60 PUSH1 0x20 238E 80 DUP1 238F 82 DUP3 2390 52 MSTORE 2391 82 DUP3 2392 51 MLOAD 2393 82 DUP3 2394 82 DUP3 2395 01 ADD 2396 81 DUP2 2397 90 SWAP1 2398 52 MSTORE 2399 60 PUSH1 0x00 239B 91 SWAP2 239C 90 SWAP1 239D 84 DUP5 239E 82 DUP3 239F 01 ADD 23A0 90 SWAP1 23A1 60 PUSH1 0x40 23A3 85 DUP6 23A4 01 ADD 23A5 90 SWAP1 23A6 84 DUP5 23A7 5B JUMPDEST 23A8 81 DUP2 23A9 81 DUP2 23AA 10 LT 23AB 15 ISZERO 23AC 61 PUSH2 0x0d89 23AF 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @2390 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2398 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @239B stack[0] = 0x00 // @239C stack[1] = 0x20 // @23A0 stack[2] = 0x20 + stack[-2] // @23A5 stack[3] = stack[-1] + 0x40 // @23A5 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @23A6 stack[5] = 0x00 // } // Block ends with conditional jump to 0x0d89, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_23B0: // Incoming jump from 0x23AF, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x23AF, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[7] // { // @23B3 stack[-3] // @23B4 stack[-4] // @23B5 memory[stack[-4]:stack[-4] + 0x20] // @23CC memory[memory[stack[-4]:stack[-4] + 0x20]:memory[stack[-4]:stack[-4] + 0x20] + 0x20] // @23DD memory[memory[stack[-4]:stack[-4] + 0x20] + 0x20:memory[stack[-4]:stack[-4] + 0x20] + 0x20 + 0x20] // @23E8 memory[memory[stack[-4]:stack[-4] + 0x20] + 0x40:memory[stack[-4]:stack[-4] + 0x20] + 0x40 + 0x20] // @23F8 memory[memory[stack[-4]:stack[-4] + 0x20] + 0x60:memory[stack[-4]:stack[-4] + 0x20] + 0x60 + 0x20] // } 23B0 61 PUSH2 0x2402 23B3 83 DUP4 23B4 85 DUP6 23B5 51 MLOAD 23B6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 23CB 81 DUP2 23CC 51 MLOAD 23CD 16 AND 23CE 82 DUP3 23CF 52 MSTORE 23D0 67 PUSH8 0xffffffffffffffff 23D9 60 PUSH1 0x20 23DB 82 DUP3 23DC 01 ADD 23DD 51 MLOAD 23DE 16 AND 23DF 60 PUSH1 0x20 23E1 83 DUP4 23E2 01 ADD 23E3 52 MSTORE 23E4 60 PUSH1 0x40 23E6 81 DUP2 23E7 01 ADD 23E8 51 MLOAD 23E9 15 ISZERO 23EA 15 ISZERO 23EB 60 PUSH1 0x40 23ED 83 DUP4 23EE 01 ADD 23EF 52 MSTORE 23F0 62 PUSH3 0xffffff 23F4 60 PUSH1 0x60 23F6 82 DUP3 23F7 01 ADD 23F8 51 MLOAD 23F9 16 AND 23FA 60 PUSH1 0x60 23FC 83 DUP4 23FD 01 ADD 23FE 52 MSTORE 23FF 50 POP 2400 50 POP 2401 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @23CF memory[stack[-3]:stack[-3] + 0x20] = memory[memory[stack[-4]:stack[-4] + 0x20]:memory[stack[-4]:stack[-4] + 0x20] + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // @23E3 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] = memory[memory[stack[-4]:stack[-4] + 0x20] + 0x20:memory[stack[-4]:stack[-4] + 0x20] + 0x20 + 0x20] & 0xffffffffffffffff // @23EF memory[stack[-3] + 0x40:stack[-3] + 0x40 + 0x20] = !!memory[memory[stack[-4]:stack[-4] + 0x20] + 0x40:memory[stack[-4]:stack[-4] + 0x20] + 0x40 + 0x20] // @23FE memory[stack[-3] + 0x60:stack[-3] + 0x60 + 0x20] = memory[memory[stack[-4]:stack[-4] + 0x20] + 0x60:memory[stack[-4]:stack[-4] + 0x20] + 0x60 + 0x20] & 0xffffff // } // Block ends with unconditional jump to 0x2402 label_2402: // Incoming jump from 0x2401 // Inputs[4] // { // @2403 stack[-4] // @2403 stack[-1] // @2404 stack[-5] // @2409 stack[-3] // } 2402 5B JUMPDEST 2403 92 SWAP3 2404 84 DUP5 2405 01 ADD 2406 92 SWAP3 2407 60 PUSH1 0x80 2409 92 SWAP3 240A 90 SWAP1 240B 92 SWAP3 240C 01 ADD 240D 91 SWAP2 240E 60 PUSH1 0x01 2410 01 ADD 2411 61 PUSH2 0x23a7 2414 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2406 stack[-4] = stack[-5] + stack[-4] // @240D stack[-3] = 0x80 + stack[-3] // @2410 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x23a7 label_2415: // Incoming call from 0x05E7, returns to 0x05E8 // Incoming call from 0x044F, returns to 0x0450 // Incoming call from 0x0484, returns to 0x0485 // Inputs[2] // { // @241A stack[-1] // @241B stack[-2] // } 2415 5B JUMPDEST 2416 60 PUSH1 0x00 2418 60 PUSH1 0x20 241A 82 DUP3 241B 84 DUP5 241C 03 SUB 241D 12 SLT 241E 15 ISZERO 241F 61 PUSH2 0x2427 2422 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2416 stack[0] = 0x00 } // Block ends with conditional jump to 0x2427, if !(stack[-2] - stack[-1] i< 0x20) label_2423: // Incoming jump from 0x2422, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2426 memory[0x00:0x00] } 2423 60 PUSH1 0x00 2425 80 DUP1 2426 FD *REVERT // Stack delta = +0 // Outputs[1] { @2426 revert(memory[0x00:0x00]); } // Block terminates label_2427: // Incoming jump from 0x2422, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @242B stack[-2] } 2427 5B JUMPDEST 2428 61 PUSH2 0x0f65 242B 82 DUP3 242C 61 PUSH2 0x1f85 242F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2428 stack[0] = 0x0f65 // @242B stack[1] = stack[-2] // } // Block ends with call to 0x1f85, returns to 0x0F65 label_2430: // Incoming call from 0x0496, returns to 0x01FE // Inputs[3] // { // @2434 stack[-1] // @2436 stack[-2] // @2437 memory[stack[-2]:stack[-2] + 0x20] // } 2430 5B JUMPDEST 2431 60 PUSH1 0x20 2433 80 DUP1 2434 82 DUP3 2435 52 MSTORE 2436 82 DUP3 2437 51 MLOAD 2438 82 DUP3 2439 82 DUP3 243A 01 ADD 243B 81 DUP2 243C 90 SWAP1 243D 52 MSTORE 243E 60 PUSH1 0x00 2440 91 SWAP2 2441 90 SWAP1 2442 84 DUP5 2443 82 DUP3 2444 01 ADD 2445 90 SWAP1 2446 60 PUSH1 0x40 2448 85 DUP6 2449 01 ADD 244A 90 SWAP1 244B 84 DUP5 244C 5B JUMPDEST 244D 81 DUP2 244E 81 DUP2 244F 10 LT 2450 15 ISZERO 2451 61 PUSH2 0x0d89 2454 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @2435 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @243D memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @2440 stack[0] = 0x00 // @2441 stack[1] = 0x20 // @2445 stack[2] = 0x20 + stack[-2] // @244A stack[3] = stack[-1] + 0x40 // @244A stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @244B stack[5] = 0x00 // } // Block ends with conditional jump to 0x0d89, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_2455: // Incoming jump from 0x2454, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2454, if not !(stack[-1] < stack[-2]) // Inputs[5] // { // @2455 stack[-4] // @2456 memory[stack[-4]:stack[-4] + 0x20] // @2457 stack[-3] // @2459 stack[-1] // @245A stack[-5] // } 2455 83 DUP4 2456 51 MLOAD 2457 83 DUP4 2458 52 MSTORE 2459 92 SWAP3 245A 84 DUP5 245B 01 ADD 245C 92 SWAP3 245D 91 SWAP2 245E 84 DUP5 245F 01 ADD 2460 91 SWAP2 2461 60 PUSH1 0x01 2463 01 ADD 2464 61 PUSH2 0x244c 2467 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2458 memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @245C stack[-4] = stack[-5] + stack[-4] // @2460 stack[-3] = stack[-5] + stack[-3] // @2463 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x244c label_2468: // Incoming call from 0x04F1, returns to 0x04F2 // Inputs[2] // { // @2470 stack[-1] // @2471 stack[-2] // } 2468 5B JUMPDEST 2469 60 PUSH1 0x00 246B 80 DUP1 246C 60 PUSH1 0x00 246E 60 PUSH1 0x60 2470 84 DUP5 2471 86 DUP7 2472 03 SUB 2473 12 SLT 2474 15 ISZERO 2475 61 PUSH2 0x247d 2478 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2469 stack[0] = 0x00 // @246B stack[1] = 0x00 // @246C stack[2] = 0x00 // } // Block ends with conditional jump to 0x247d, if !(stack[-2] - stack[-1] i< 0x60) label_2479: // Incoming jump from 0x2478, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @247C memory[0x00:0x00] } 2479 60 PUSH1 0x00 247B 80 DUP1 247C FD *REVERT // Stack delta = +0 // Outputs[1] { @247C revert(memory[0x00:0x00]); } // Block terminates label_247D: // Incoming jump from 0x2478, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2481 stack[-4] } 247D 5B JUMPDEST 247E 61 PUSH2 0x2486 2481 84 DUP5 2482 61 PUSH2 0x1f85 2485 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @247E stack[0] = 0x2486 // @2481 stack[1] = stack[-4] // } // Block ends with call to 0x1f85, returns to 0x2486 label_2486: // Incoming return from call to 0x1F85 at 0x2485 // Inputs[7] // { // @2487 stack[-7] // @2487 stack[-1] // @248A stack[-5] // @248C msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @248D stack[-6] // @2494 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2496 stack[-4] // } 2486 5B JUMPDEST 2487 95 SWAP6 2488 60 PUSH1 0x20 248A 85 DUP6 248B 01 ADD 248C 35 CALLDATALOAD 248D 95 SWAP6 248E 50 POP 248F 60 PUSH1 0x40 2491 90 SWAP1 2492 94 SWAP5 2493 01 ADD 2494 35 CALLDATALOAD 2495 93 SWAP4 2496 92 SWAP3 2497 50 POP 2498 50 POP 2499 50 POP 249A 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2487 stack[-7] = stack[-1] // @248D stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2495 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_249B: // Incoming call from 0x24D4, returns to 0x2111 // Incoming call from 0x2854, returns to 0x0F65 // Inputs[1] { @249C stack[-1] } 249B 5B JUMPDEST 249C 80 DUP1 249D 15 ISZERO 249E 15 ISZERO 249F 81 DUP2 24A0 14 EQ 24A1 61 PUSH2 0x1192 24A4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1192, if stack[-1] == !!stack[-1] label_24A5: // Incoming jump from 0x24A4, if not stack[-1] == !!stack[-1] // Inputs[1] { @24A8 memory[0x00:0x00] } 24A5 60 PUSH1 0x00 24A7 80 DUP1 24A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @24A8 revert(memory[0x00:0x00]); } // Block terminates label_24A9: // Incoming jump from 0x0511 // Inputs[2] // { // @24AF stack[-1] // @24B0 stack[-2] // } 24A9 5B JUMPDEST 24AA 60 PUSH1 0x00 24AC 80 DUP1 24AD 60 PUSH1 0x40 24AF 83 DUP4 24B0 85 DUP6 24B1 03 SUB 24B2 12 SLT 24B3 15 ISZERO 24B4 61 PUSH2 0x24bc 24B7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @24AA stack[0] = 0x00 // @24AC stack[1] = 0x00 // } // Block ends with conditional jump to 0x24bc, if !(stack[-2] - stack[-1] i< 0x40) label_24B8: // Incoming jump from 0x24B7, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @24BB memory[0x00:0x00] } 24B8 60 PUSH1 0x00 24BA 80 DUP1 24BB FD *REVERT // Stack delta = +0 // Outputs[1] { @24BB revert(memory[0x00:0x00]); } // Block terminates label_24BC: // Incoming jump from 0x24B7, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @24C0 stack[-3] } 24BC 5B JUMPDEST 24BD 61 PUSH2 0x24c5 24C0 83 DUP4 24C1 61 PUSH2 0x1f85 24C4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24BD stack[0] = 0x24c5 // @24C0 stack[1] = stack[-3] // } // Block ends with call to 0x1f85, returns to 0x24C5 label_24C5: // Incoming return from call to 0x1F85 at 0x24C4 // Inputs[4] // { // @24C6 stack[-3] // @24C6 stack[-1] // @24CA stack[-4] // @24CC msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 24C5 5B JUMPDEST 24C6 91 SWAP2 24C7 50 POP 24C8 60 PUSH1 0x20 24CA 83 DUP4 24CB 01 ADD 24CC 35 CALLDATALOAD 24CD 61 PUSH2 0x2111 24D0 81 DUP2 24D1 61 PUSH2 0x249b 24D4 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @24C6 stack[-3] = stack[-1] // @24CC stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @24CD stack[0] = 0x2111 // @24D0 stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x249b, returns to 0x2111 label_24D5: // Incoming call from 0x0524, returns to 0x0525 // Inputs[2] // { // @24DE stack[-1] // @24DF stack[-2] // } 24D5 5B JUMPDEST 24D6 60 PUSH1 0x00 24D8 80 DUP1 24D9 60 PUSH1 0x00 24DB 80 DUP1 24DC 60 PUSH1 0x80 24DE 85 DUP6 24DF 87 DUP8 24E0 03 SUB 24E1 12 SLT 24E2 15 ISZERO 24E3 61 PUSH2 0x24eb 24E6 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @24D6 stack[0] = 0x00 // @24D8 stack[1] = 0x00 // @24D9 stack[2] = 0x00 // @24DB stack[3] = 0x00 // } // Block ends with conditional jump to 0x24eb, if !(stack[-2] - stack[-1] i< 0x80) label_24E7: // Incoming jump from 0x24E6, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @24EA memory[0x00:0x00] } 24E7 60 PUSH1 0x00 24E9 80 DUP1 24EA FD *REVERT // Stack delta = +0 // Outputs[1] { @24EA revert(memory[0x00:0x00]); } // Block terminates label_24EB: // Incoming jump from 0x24E6, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @24EF stack[-5] } 24EB 5B JUMPDEST 24EC 61 PUSH2 0x24f4 24EF 85 DUP6 24F0 61 PUSH2 0x1f85 24F3 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @24EC stack[0] = 0x24f4 // @24EF stack[1] = stack[-5] // } // Block ends with call to 0x1f85, returns to 0x24F4 label_24F4: // Incoming return from call to 0x1F85 at 0x24F3 // Inputs[3] // { // @24F5 stack[-5] // @24F5 stack[-1] // @24FC stack[-6] // } 24F4 5B JUMPDEST 24F5 93 SWAP4 24F6 50 POP 24F7 61 PUSH2 0x2502 24FA 60 PUSH1 0x20 24FC 86 DUP7 24FD 01 ADD 24FE 61 PUSH2 0x1f85 2501 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @24F5 stack[-5] = stack[-1] // @24F7 stack[-1] = 0x2502 // @24FD stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1f85, returns to 0x2502 label_2502: // Incoming return from call to 0x1F85 at 0x2501 // Inputs[6] // { // @2503 stack[-1] // @2503 stack[-4] // @2507 stack[-6] // @2509 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @250A stack[-3] // @2510 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2502 5B JUMPDEST 2503 92 SWAP3 2504 50 POP 2505 60 PUSH1 0x40 2507 85 DUP6 2508 01 ADD 2509 35 CALLDATALOAD 250A 91 SWAP2 250B 50 POP 250C 60 PUSH1 0x60 250E 85 DUP6 250F 01 ADD 2510 35 CALLDATALOAD 2511 67 PUSH8 0xffffffffffffffff 251A 81 DUP2 251B 11 GT 251C 15 ISZERO 251D 61 PUSH2 0x2525 2520 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2503 stack[-4] = stack[-1] // @250A stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2510 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2525, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2521: // Incoming jump from 0x2520, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[1] { @2524 memory[0x00:0x00] } 2521 60 PUSH1 0x00 2523 80 DUP1 2524 FD *REVERT // Stack delta = +0 // Outputs[1] { @2524 revert(memory[0x00:0x00]); } // Block terminates label_2525: // Incoming jump from 0x2520, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2529 stack[-7] // @252A stack[-1] // @252B stack[-6] // } 2525 5B JUMPDEST 2526 61 PUSH2 0x2531 2529 87 DUP8 252A 82 DUP3 252B 88 DUP9 252C 01 ADD 252D 61 PUSH2 0x2066 2530 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2526 stack[0] = 0x2531 // @2529 stack[1] = stack[-7] // @252C stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x2066, returns to 0x2531 label_2531: // Incoming return from call to 0x2066 at 0x2530 // Inputs[8] // { // @2532 stack[-3] // @2532 stack[-1] // @2535 stack[-6] // @2536 stack[-9] // @2537 stack[-5] // @2538 stack[-8] // @253A stack[-7] // @253A stack[-4] // } 2531 5B JUMPDEST 2532 91 SWAP2 2533 50 POP 2534 50 POP 2535 92 SWAP3 2536 95 SWAP6 2537 91 SWAP2 2538 94 SWAP5 2539 50 POP 253A 92 SWAP3 253B 50 POP 253C 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @2535 stack[-6] = stack[-1] // @2536 stack[-9] = stack[-6] // @2538 stack[-8] = stack[-5] // @253A stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_253D: // Incoming call from 0x0556, returns to 0x01FE // Inputs[6] // { // @253E stack[-2] // @253F memory[stack[-2]:stack[-2] + 0x20] // @2556 stack[-1] // @255D memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2571 memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @257D memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // } 253D 5B JUMPDEST 253E 81 DUP2 253F 51 MLOAD 2540 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2555 16 AND 2556 81 DUP2 2557 52 MSTORE 2558 60 PUSH1 0x20 255A 80 DUP1 255B 83 DUP4 255C 01 ADD 255D 51 MLOAD 255E 67 PUSH8 0xffffffffffffffff 2567 16 AND 2568 90 SWAP1 2569 82 DUP3 256A 01 ADD 256B 52 MSTORE 256C 60 PUSH1 0x40 256E 80 DUP1 256F 83 DUP4 2570 01 ADD 2571 51 MLOAD 2572 15 ISZERO 2573 15 ISZERO 2574 90 SWAP1 2575 82 DUP3 2576 01 ADD 2577 52 MSTORE 2578 60 PUSH1 0x60 257A 80 DUP1 257B 83 DUP4 257C 01 ADD 257D 51 MLOAD 257E 62 PUSH3 0xffffff 2582 16 AND 2583 90 SWAP1 2584 82 DUP3 2585 01 ADD 2586 52 MSTORE 2587 60 PUSH1 0x80 2589 81 DUP2 258A 01 ADD 258B 61 PUSH2 0x0643 258E 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @2557 memory[stack[-1]:stack[-1] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] // @256B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0xffffffffffffffff & memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @2577 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = !!memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] // @2586 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0xffffff & memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] // @258A stack[0] = stack[-1] + 0x80 // } // Block ends with unconditional jump to 0x0643 label_258F: // Incoming call from 0x0591, returns to 0x0592 // Inputs[2] // { // @2595 stack[-1] // @2596 stack[-2] // } 258F 5B JUMPDEST 2590 60 PUSH1 0x00 2592 80 DUP1 2593 60 PUSH1 0x40 2595 83 DUP4 2596 85 DUP6 2597 03 SUB 2598 12 SLT 2599 15 ISZERO 259A 61 PUSH2 0x25a2 259D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2590 stack[0] = 0x00 // @2592 stack[1] = 0x00 // } // Block ends with conditional jump to 0x25a2, if !(stack[-2] - stack[-1] i< 0x40) label_259E: // Incoming jump from 0x259D, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25A1 memory[0x00:0x00] } 259E 60 PUSH1 0x00 25A0 80 DUP1 25A1 FD *REVERT // Stack delta = +0 // Outputs[1] { @25A1 revert(memory[0x00:0x00]); } // Block terminates label_25A2: // Incoming jump from 0x259D, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @25A6 stack[-3] } 25A2 5B JUMPDEST 25A3 61 PUSH2 0x25ab 25A6 83 DUP4 25A7 61 PUSH2 0x1f85 25AA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @25A3 stack[0] = 0x25ab // @25A6 stack[1] = stack[-3] // } // Block ends with call to 0x1f85, returns to 0x25AB label_25AB: // Incoming return from call to 0x1F85 at 0x25AA // Inputs[3] // { // @25AC stack[-1] // @25AC stack[-3] // @25B3 stack[-4] // } 25AB 5B JUMPDEST 25AC 91 SWAP2 25AD 50 POP 25AE 61 PUSH2 0x25b9 25B1 60 PUSH1 0x20 25B3 84 DUP5 25B4 01 ADD 25B5 61 PUSH2 0x1f85 25B8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @25AC stack[-3] = stack[-1] // @25AE stack[-1] = 0x25b9 // @25B4 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1f85, returns to 0x25B9 label_25B9: // Incoming return from call to 0x1F85 at 0x25B8 // Inputs[6] // { // @25BA stack[-2] // @25BA stack[-1] // @25BC stack[-5] // @25BE stack[-3] // @25BE stack[-6] // @25BF stack[-4] // } 25B9 5B JUMPDEST 25BA 90 SWAP1 25BB 50 POP 25BC 92 SWAP3 25BD 50 POP 25BE 92 SWAP3 25BF 90 SWAP1 25C0 50 POP 25C1 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @25BC stack[-5] = stack[-1] // @25BE stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_25C2: // Incoming call from 0x0677, returns to 0x0678 // Inputs[3] // { // @25C5 stack[-2] // @25C6 memory[stack[-2]:stack[-2] + 0x20] // @25CB stack[-1] // } 25C2 5B JUMPDEST 25C3 60 PUSH1 0x00 25C5 82 DUP3 25C6 51 MLOAD 25C7 61 PUSH2 0x25d4 25CA 81 DUP2 25CB 84 DUP5 25CC 60 PUSH1 0x20 25CE 87 DUP8 25CF 01 ADD 25D0 61 PUSH2 0x211c 25D3 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @25C3 stack[0] = 0x00 // @25C6 stack[1] = memory[stack[-2]:stack[-2] + 0x20] // @25C7 stack[2] = 0x25d4 // @25CA stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @25CB stack[4] = stack[-1] // @25CF stack[5] = stack[-2] + 0x20 // } // Block ends with call to 0x211c, returns to 0x25D4 label_25D4: // Incoming return from call to 0x211C at 0x25D3 // Inputs[5] // { // @25D5 stack[-3] // @25D5 stack[-1] // @25D6 stack[-2] // @25D9 stack[-5] // @25DA stack[-4] // } 25D4 5B JUMPDEST 25D5 91 SWAP2 25D6 90 SWAP1 25D7 91 SWAP2 25D8 01 ADD 25D9 92 SWAP3 25DA 91 SWAP2 25DB 50 POP 25DC 50 POP 25DD 56 *JUMP // Stack delta = -4 // Outputs[1] { @25D9 stack[-5] = stack[-1] + stack[-3] } // Block ends with unconditional jump to stack[-5] label_25DE: // Incoming call from 0x0DA3, returns to 0x0754 // Incoming call from 0x0990, returns to 0x0991 // Incoming call from 0x077F, returns to 0x0780 // Incoming call from 0x09BC, returns to 0x09BD // Incoming call from 0x0753, returns to 0x0754 // Incoming call from 0x2770, returns to 0x2771 // Incoming call from 0x1D99, returns to 0x0754 // Inputs[1] { @25E1 stack[-1] } 25DE 5B JUMPDEST 25DF 60 PUSH1 0x01 25E1 81 DUP2 25E2 81 DUP2 25E3 1C SHR 25E4 90 SWAP1 25E5 82 DUP3 25E6 16 AND 25E7 80 DUP1 25E8 61 PUSH2 0x25f2 25EB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @25E4 stack[0] = stack[-1] >> 0x01 // @25E6 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x25f2, if stack[-1] & 0x01 label_25EC: // Incoming jump from 0x25EB, if not stack[-1] & 0x01 // Inputs[2] // { // @25EE stack[-2] // @25F7 stack[-1] // } 25EC 60 PUSH1 0x7f 25EE 82 DUP3 25EF 16 AND 25F0 91 SWAP2 25F1 50 POP 25F2 5B JUMPDEST 25F3 60 PUSH1 0x20 25F5 82 DUP3 25F6 10 LT 25F7 81 DUP2 25F8 03 SUB 25F9 61 PUSH2 0x262b 25FC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @25F0 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x262b, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_25FD: // Incoming jump from 0x25FC, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x25FC, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @262A memory[0x00:0x24] } 25FD 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 261E 60 PUSH1 0x00 2620 52 MSTORE 2621 60 PUSH1 0x22 2623 60 PUSH1 0x04 2625 52 MSTORE 2626 60 PUSH1 0x24 2628 60 PUSH1 0x00 262A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2620 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @2625 memory[0x04:0x24] = 0x22 // @262A revert(memory[0x00:0x24]); // } // Block terminates label_262B: // Incoming jump from 0x25FC, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x25FC, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @262D stack[-2] // @262D stack[-4] // @262E stack[-3] // } 262B 5B JUMPDEST 262C 50 POP 262D 91 SWAP2 262E 90 SWAP1 262F 50 POP 2630 56 *JUMP // Stack delta = -3 // Outputs[1] { @262D stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2631: // Incoming jump from 0x2679 // Incoming jump from 0x26FB // Inputs[1] { @265F memory[0x00:0x24] } 2631 5B JUMPDEST 2632 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 2653 60 PUSH1 0x00 2655 52 MSTORE 2656 60 PUSH1 0x11 2658 60 PUSH1 0x04 265A 52 MSTORE 265B 60 PUSH1 0x24 265D 60 PUSH1 0x00 265F FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2655 memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @265A memory[0x04:0x24] = 0x11 // @265F revert(memory[0x00:0x24]); // } // Block terminates label_2660: // Incoming call from 0x096B, returns to 0x096C // Incoming call from 0x096B, returns to 0x096C // Inputs[2] // { // @2663 stack[-1] // @2668 stack[-2] // } 2660 5B JUMPDEST 2661 60 PUSH1 0x00 2663 81 DUP2 2664 60 PUSH1 0x00 2666 19 NOT 2667 04 DIV 2668 83 DUP4 2669 11 GT 266A 82 DUP3 266B 15 ISZERO 266C 15 ISZERO 266D 16 AND 266E 15 ISZERO 266F 61 PUSH2 0x267a 2672 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2661 stack[0] = 0x00 } // Block ends with conditional jump to 0x267a, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_2673: // Incoming jump from 0x2672, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 2673 61 PUSH2 0x267a 2676 61 PUSH2 0x2631 2679 56 *JUMP // Stack delta = +1 // Outputs[1] { @2673 stack[0] = 0x267a } // Block ends with unconditional jump to 0x2631 label_267A: // Incoming jump from 0x2672, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @267C stack[-2] // @267C stack[-3] // @267D stack[-4] // } 267A 5B JUMPDEST 267B 50 POP 267C 02 MUL 267D 90 SWAP1 267E 56 *JUMP // Stack delta = -3 // Outputs[1] { @267D stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_267F: // Incoming call from 0x0975, returns to 0x0976 // Inputs[1] { @2682 stack[-2] } 267F 5B JUMPDEST 2680 60 PUSH1 0x00 2682 82 DUP3 2683 61 PUSH2 0x26b5 2686 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2680 stack[0] = 0x00 } // Block ends with conditional jump to 0x26b5, if stack[-2] label_2687: // Incoming jump from 0x2686, if not stack[-2] // Inputs[1] { @26B4 memory[0x00:0x24] } 2687 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 26A8 60 PUSH1 0x00 26AA 52 MSTORE 26AB 60 PUSH1 0x12 26AD 60 PUSH1 0x04 26AF 52 MSTORE 26B0 60 PUSH1 0x24 26B2 60 PUSH1 0x00 26B4 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26AA memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @26AF memory[0x04:0x24] = 0x12 // @26B4 revert(memory[0x00:0x24]); // } // Block terminates label_26B5: // Incoming jump from 0x2686, if stack[-2] // Inputs[3] // { // @26B7 stack[-3] // @26B7 stack[-2] // @26B8 stack[-4] // } 26B5 5B JUMPDEST 26B6 50 POP 26B7 04 DIV 26B8 90 SWAP1 26B9 56 *JUMP // Stack delta = -3 // Outputs[1] { @26B8 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_26BA: // Incoming jump from 0x0B8E // Incoming jump from 0x0BAC // Incoming jump from 0x0A3A // Incoming jump from 0x0F43 // Incoming jump from 0x0D73 // Inputs[1] { @26E8 memory[0x00:0x24] } 26BA 5B JUMPDEST 26BB 7F PUSH32 0x4e487b7100000000000000000000000000000000000000000000000000000000 26DC 60 PUSH1 0x00 26DE 52 MSTORE 26DF 60 PUSH1 0x32 26E1 60 PUSH1 0x04 26E3 52 MSTORE 26E4 60 PUSH1 0x24 26E6 60 PUSH1 0x00 26E8 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26DE memory[0x00:0x20] = 0x4e487b7100000000000000000000000000000000000000000000000000000000 // @26E3 memory[0x04:0x24] = 0x32 // @26E8 revert(memory[0x00:0x24]); // } // Block terminates label_26E9: // Incoming call from 0x0A53, returns to 0x0A54 // Inputs[1] { @26EF stack[-1] } 26E9 5B JUMPDEST 26EA 60 PUSH1 0x00 26EC 60 PUSH1 0x00 26EE 19 NOT 26EF 82 DUP3 26F0 03 SUB 26F1 61 PUSH2 0x26fc 26F4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26EA stack[0] = 0x00 } // Block ends with conditional jump to 0x26fc, if stack[-1] - ~0x00 label_26F5: // Incoming jump from 0x26F4, if not stack[-1] - ~0x00 26F5 61 PUSH2 0x26fc 26F8 61 PUSH2 0x2631 26FB 56 *JUMP // Stack delta = +1 // Outputs[1] { @26F5 stack[0] = 0x26fc } // Block ends with unconditional jump to 0x2631 label_26FC: // Incoming jump from 0x26F4, if stack[-1] - ~0x00 // Inputs[2] // { // @2700 stack[-2] // @2701 stack[-3] // } 26FC 5B JUMPDEST 26FD 50 POP 26FE 60 PUSH1 0x01 2700 01 ADD 2701 90 SWAP1 2702 56 *JUMP // Stack delta = -2 // Outputs[1] { @2701 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_2703: // Incoming jump from 0x2776 // Inputs[1] { @2706 stack[-2] } 2703 5B JUMPDEST 2704 60 PUSH1 0x1f 2706 82 DUP3 2707 11 GT 2708 15 ISZERO 2709 61 PUSH2 0x072a 270C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x072a, if !(stack[-2] > 0x1f) label_270D: // Incoming jump from 0x270C, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @270F stack[-1] // @2715 memory[0x00:0x20] // @2718 stack[-3] // } 270D 60 PUSH1 0x00 270F 81 DUP2 2710 81 DUP2 2711 52 MSTORE 2712 60 PUSH1 0x20 2714 81 DUP2 2715 20 SHA3 2716 60 PUSH1 0x1f 2718 85 DUP6 2719 01 ADD 271A 60 PUSH1 0x05 271C 1C SHR 271D 81 DUP2 271E 01 ADD 271F 60 PUSH1 0x20 2721 86 DUP7 2722 10 LT 2723 15 ISZERO 2724 61 PUSH2 0x272a 2727 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @270D stack[0] = 0x00 // @2711 memory[0x00:0x20] = stack[-1] // @2715 stack[1] = keccak256(memory[0x00:0x20]) // @271E stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x272a, if !(stack[-3] < 0x20) label_2728: // Incoming jump from 0x2727, if not !(stack[-3] < 0x20) // Inputs[2] // { // @2729 stack[-2] // @272D stack[-5] // } 2728 50 POP 2729 80 DUP1 272A 5B JUMPDEST 272B 60 PUSH1 0x1f 272D 85 DUP6 272E 01 ADD 272F 60 PUSH1 0x05 2731 1C SHR 2732 82 DUP3 2733 01 ADD 2734 91 SWAP2 2735 50 POP 2736 5B JUMPDEST 2737 81 DUP2 2738 81 DUP2 2739 10 LT 273A 15 ISZERO 273B 61 PUSH2 0x18ce 273E 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2729 stack[-1] = stack[-2] // @2734 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x18ce, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_273F: // Incoming jump from 0x273E, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x273E, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x273E, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @273F stack[-3] // @2740 stack[-1] // } 273F 82 DUP3 2740 81 DUP2 2741 55 SSTORE 2742 60 PUSH1 0x01 2744 01 ADD 2745 61 PUSH2 0x2736 2748 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2741 storage[stack[-1]] = stack[-3] // @2744 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2736 label_2749: // Incoming call from 0x0AFC, returns to 0x0741 // Inputs[2] // { // @274A stack[-2] // @274B memory[stack[-2]:stack[-2] + 0x20] // } 2749 5B JUMPDEST 274A 81 DUP2 274B 51 MLOAD 274C 67 PUSH8 0xffffffffffffffff 2755 81 DUP2 2756 11 GT 2757 15 ISZERO 2758 61 PUSH2 0x2763 275B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @274B stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x2763, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_275C: // Incoming jump from 0x275B, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 275C 61 PUSH2 0x2763 275F 61 PUSH2 0x1fae 2762 56 *JUMP // Stack delta = +1 // Outputs[1] { @275C stack[0] = 0x2763 } // Block ends with unconditional jump to 0x1fae label_2763: // Incoming jump from 0x275B, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @2767 stack[-1] // @276B stack[-2] // @276C storage[stack[-2]] // } 2763 5B JUMPDEST 2764 61 PUSH2 0x2777 2767 81 DUP2 2768 61 PUSH2 0x2771 276B 84 DUP5 276C 54 SLOAD 276D 61 PUSH2 0x25de 2770 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2764 stack[0] = 0x2777 // @2767 stack[1] = stack[-1] // @2768 stack[2] = 0x2771 // @276C stack[3] = storage[stack[-2]] // } // Block ends with call to 0x25de, returns to 0x2771 label_2771: // Incoming return from call to 0x25DE at 0x2770 // Inputs[1] { @2772 stack[-5] } 2771 5B JUMPDEST 2772 84 DUP5 2773 61 PUSH2 0x2703 2776 56 *JUMP // Stack delta = +1 // Outputs[1] { @2772 stack[0] = stack[-5] } // Block ends with unconditional jump to 0x2703 label_2777: // Incoming return from call to 0x2771 at 0x2770 // Inputs[1] { @277D stack[-1] } 2777 5B JUMPDEST 2778 60 PUSH1 0x20 277A 80 DUP1 277B 60 PUSH1 0x1f 277D 83 DUP4 277E 11 GT 277F 60 PUSH1 0x01 2781 81 DUP2 2782 14 EQ 2783 61 PUSH2 0x27ac 2786 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2778 stack[0] = 0x20 // @277A stack[1] = 0x20 // @277E stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x27ac, if (stack[-1] > 0x1f) == 0x01 label_2787: // Incoming jump from 0x2786, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @2789 stack[-4] } 2787 60 PUSH1 0x00 2789 84 DUP5 278A 15 ISZERO 278B 61 PUSH2 0x2794 278E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2787 stack[0] = 0x00 } // Block ends with conditional jump to 0x2794, if !stack[-4] label_278F: // Incoming jump from 0x278E, if not !stack[-4] // Inputs[5] // { // @2790 stack[-7] // @2791 stack[-4] // @2793 memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @279A stack[-5] // @27A6 stack[-6] // } 278F 50 POP 2790 85 DUP6 2791 83 DUP4 2792 01 ADD 2793 51 MLOAD 2794 5B JUMPDEST 2795 60 PUSH1 0x00 2797 19 NOT 2798 60 PUSH1 0x03 279A 86 DUP7 279B 90 SWAP1 279C 1B SHL 279D 1C SHR 279E 19 NOT 279F 16 AND 27A0 60 PUSH1 0x01 27A2 85 DUP6 27A3 90 SWAP1 27A4 1B SHL 27A5 17 OR 27A6 85 DUP6 27A7 55 SSTORE 27A8 61 PUSH2 0x18ce 27AB 56 *JUMP // Stack delta = -1 // Outputs[1] { @27A7 storage[stack[-6]] = (stack[-5] << 0x01) | (~(~0x00 >> (stack[-5] << 0x03)) & memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20]) } // Block ends with unconditional jump to 0x18ce label_27AC: // Incoming jump from 0x2786, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @27AF stack[-5] // @27B5 memory[0x00:0x20] // @27B9 stack[-4] // } 27AC 5B JUMPDEST 27AD 60 PUSH1 0x00 27AF 85 DUP6 27B0 81 DUP2 27B1 52 MSTORE 27B2 60 PUSH1 0x20 27B4 81 DUP2 27B5 20 SHA3 27B6 60 PUSH1 0x1f 27B8 19 NOT 27B9 86 DUP7 27BA 16 AND 27BB 91 SWAP2 27BC 5B JUMPDEST 27BD 82 DUP3 27BE 81 DUP2 27BF 10 LT 27C0 15 ISZERO 27C1 61 PUSH2 0x27db 27C4 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @27B1 memory[0x00:0x20] = stack[-5] // @27B5 stack[1] = keccak256(memory[0x00:0x20]) // @27BB stack[0] = stack[-4] & ~0x1f // @27BB stack[2] = 0x00 // } // Block ends with conditional jump to 0x27db, if !(0x00 < stack[-4] & ~0x1f) label_27C5: // Incoming jump from 0x27C4, if not !(0x00 < stack[-4] & ~0x1f) // Incoming jump from 0x27C4, if not !(stack[-1] < stack[-3]) // Inputs[6] // { // @27C5 stack[-9] // @27C6 stack[-6] // @27C8 memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @27C9 stack[-2] // @27CB stack[-1] // @27CC stack[-5] // } 27C5 88 DUP9 27C6 86 DUP7 27C7 01 ADD 27C8 51 MLOAD 27C9 82 DUP3 27CA 55 SSTORE 27CB 94 SWAP5 27CC 84 DUP5 27CD 01 ADD 27CE 94 SWAP5 27CF 60 PUSH1 0x01 27D1 90 SWAP1 27D2 91 SWAP2 27D3 01 ADD 27D4 90 SWAP1 27D5 84 DUP5 27D6 01 ADD 27D7 61 PUSH2 0x27bc 27DA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @27CA storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @27CE stack[-6] = stack[-5] + stack[-6] // @27D4 stack[-2] = stack[-2] + 0x01 // @27D6 stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x27bc label_27DB: // Incoming jump from 0x27C4, if !(0x00 < stack[-4] & ~0x1f) // Incoming jump from 0x27C4, if !(stack[-1] < stack[-3]) // Inputs[2] // { // @27DD stack[-7] // @27DE stack[-3] // } 27DB 5B JUMPDEST 27DC 50 POP 27DD 85 DUP6 27DE 82 DUP3 27DF 10 LT 27E0 15 ISZERO 27E1 61 PUSH2 0x27f9 27E4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x27f9, if !(stack[-3] < stack[-7]) label_27E5: // Incoming jump from 0x27E4, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @27E5 stack[-8] // @27E6 stack[-5] // @27E8 memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @27EE stack[-6] // @27F7 stack[-1] // @2805 stack[-7] // @2808 stack[-9] // } 27E5 87 DUP8 27E6 85 DUP6 27E7 01 ADD 27E8 51 MLOAD 27E9 60 PUSH1 0x00 27EB 19 NOT 27EC 60 PUSH1 0x03 27EE 88 DUP9 27EF 90 SWAP1 27F0 1B SHL 27F1 60 PUSH1 0xf8 27F3 16 AND 27F4 1C SHR 27F5 19 NOT 27F6 16 AND 27F7 81 DUP2 27F8 55 SSTORE 27F9 5B JUMPDEST 27FA 50 POP 27FB 50 POP 27FC 50 POP 27FD 50 POP 27FE 50 POP 27FF 60 PUSH1 0x01 2801 90 SWAP1 2802 81 DUP2 2803 1B SHL 2804 01 ADD 2805 90 SWAP1 2806 55 SSTORE 2807 50 POP 2808 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @27F8 storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @2806 storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] 2809 5B JUMPDEST 280A 60 PUSH1 0x00 280C 83 DUP4 280D 51 MLOAD 280E 61 PUSH2 0x281b 2811 81 DUP2 2812 84 DUP5 2813 60 PUSH1 0x20 2815 88 DUP9 2816 01 ADD 2817 61 PUSH2 0x211c 281A 56 *JUMP 281B 5B JUMPDEST 281C 83 DUP4 281D 51 MLOAD 281E 90 SWAP1 281F 83 DUP4 2820 01 ADD 2821 90 SWAP1 2822 61 PUSH2 0x282f 2825 81 DUP2 2826 83 DUP4 2827 60 PUSH1 0x20 2829 88 DUP9 282A 01 ADD 282B 61 PUSH2 0x211c 282E 56 *JUMP 282F 5B JUMPDEST 2830 01 ADD 2831 94 SWAP5 2832 93 SWAP4 2833 50 POP 2834 50 POP 2835 50 POP 2836 50 POP 2837 56 *JUMP label_2838: // Incoming call from 0x152A, returns to 0x152B // Inputs[2] // { // @283D stack[-1] // @283E stack[-2] // } 2838 5B JUMPDEST 2839 60 PUSH1 0x00 283B 60 PUSH1 0x20 283D 82 DUP3 283E 84 DUP5 283F 03 SUB 2840 12 SLT 2841 15 ISZERO 2842 61 PUSH2 0x284a 2845 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2839 stack[0] = 0x00 } // Block ends with conditional jump to 0x284a, if !(stack[-2] - stack[-1] i< 0x20) label_2846: // Incoming jump from 0x2845, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2849 memory[0x00:0x00] } 2846 60 PUSH1 0x00 2848 80 DUP1 2849 FD *REVERT // Stack delta = +0 // Outputs[1] { @2849 revert(memory[0x00:0x00]); } // Block terminates label_284A: // Incoming jump from 0x2845, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @284B stack[-2] // @284C memory[stack[-2]:stack[-2] + 0x20] // } 284A 5B JUMPDEST 284B 81 DUP2 284C 51 MLOAD 284D 61 PUSH2 0x0f65 2850 81 DUP2 2851 61 PUSH2 0x249b 2854 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @284C stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @284D stack[1] = 0x0f65 // @2850 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x249b, returns to 0x0F65 label_2855: // Incoming call from 0x1E38, returns to 0x1E39 // Inputs[5] // { // @286E stack[-5] // @2870 stack[-1] // @2873 stack[-4] // @287B stack[-3] // @288F stack[-2] // } 2855 5B JUMPDEST 2856 60 PUSH1 0x00 2858 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 286D 80 DUP1 286E 87 DUP8 286F 16 AND 2870 83 DUP4 2871 52 MSTORE 2872 80 DUP1 2873 86 DUP7 2874 16 AND 2875 60 PUSH1 0x20 2877 84 DUP5 2878 01 ADD 2879 52 MSTORE 287A 50 POP 287B 83 DUP4 287C 60 PUSH1 0x40 287E 83 DUP4 287F 01 ADD 2880 52 MSTORE 2881 60 PUSH1 0x80 2883 60 PUSH1 0x60 2885 83 DUP4 2886 01 ADD 2887 52 MSTORE 2888 61 PUSH2 0x2894 288B 60 PUSH1 0x80 288D 83 DUP4 288E 01 ADD 288F 84 DUP5 2890 61 PUSH2 0x2140 2893 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @2856 stack[0] = 0x00 // @2871 memory[stack[-1]:stack[-1] + 0x20] = stack[-5] & 0xffffffffffffffffffffffffffffffffffffffff // @2879 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff // @2880 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @2887 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @2888 stack[1] = 0x2894 // @288E stack[2] = stack[-1] + 0x80 // @288F stack[3] = stack[-2] // } // Block ends with call to 0x2140, returns to 0x2894 label_2894: // Incoming return from call to 0x2140 at 0x2893 // Inputs[3] // { // @2895 stack[-8] // @2895 stack[-1] // @2896 stack[-7] // } 2894 5B JUMPDEST 2895 96 SWAP7 2896 95 SWAP6 2897 50 POP 2898 50 POP 2899 50 POP 289A 50 POP 289B 50 POP 289C 50 POP 289D 56 *JUMP // Stack delta = -7 // Outputs[1] { @2895 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_289E: // Incoming jump from 0x1E70 // Inputs[2] // { // @28A3 stack[-1] // @28A4 stack[-2] // } 289E 5B JUMPDEST 289F 60 PUSH1 0x00 28A1 60 PUSH1 0x20 28A3 82 DUP3 28A4 84 DUP5 28A5 03 SUB 28A6 12 SLT 28A7 15 ISZERO 28A8 61 PUSH2 0x28b0 28AB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @289F stack[0] = 0x00 } // Block ends with conditional jump to 0x28b0, if !(stack[-2] - stack[-1] i< 0x20) label_28AC: // Incoming jump from 0x28AB, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @28AF memory[0x00:0x00] } 28AC 60 PUSH1 0x00 28AE 80 DUP1 28AF FD *REVERT // Stack delta = +0 // Outputs[1] { @28AF revert(memory[0x00:0x00]); } // Block terminates label_28B0: // Incoming jump from 0x28AB, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @28B1 stack[-2] // @28B2 memory[stack[-2]:stack[-2] + 0x20] // } 28B0 5B JUMPDEST 28B1 81 DUP2 28B2 51 MLOAD 28B3 61 PUSH2 0x0f65 28B6 81 DUP2 28B7 61 PUSH2 0x1f3a 28BA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @28B2 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @28B3 stack[1] = 0x0f65 // @28B6 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1f3a, returns to 0x0F65 28BB FE *ASSERT 28BC A2 LOG2 28BD 64 PUSH5 0x6970667358 28C3 22 22 28C4 12 SLT 28C5 20 SHA3 28C6 BE BE 28C7 0B SIGNEXTEND 28C8 12 SLT 28C9 21 21 28CA DB DB 28CB 17 OR 28CC 0F 0F 28CD 51 MLOAD 28CE C8 C8 28CF 8B DUP12 28D0 E7 E7 28D1 0E 0E 28D2 88 DUP9 28D3 AC AC 28D4 EF EF 28D5 49 49 28D6 C8 C8 28D7 BC BC 28D8 D0 D0 28D9 29 29 28DA AC AC 28DB 48 BASEFEE 28DC 2C 2C 28DD FB FB 28DE E1 E1 28DF A9 A9 28E0 99 SWAP10 28E1 1C SHR 28E2 6B PUSH12 0x51d6ac64736f6c6343000810 28EF 00 *STOP 28F0 33 CALLER