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 0x0225 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x0225, 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 0x715018a6 0019 11 GT 001A 61 PUSH2 0x0123 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0123, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xbac426d0 0024 11 GT 0025 61 PUSH2 0x00ab 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ab, if 0xbac426d0 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xbac426d0 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xe36b0b37 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xe36b0b37 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xe36b0b37 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe36b0b37 003A 14 EQ 003B 61 PUSH2 0x0695 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0695, if 0xe36b0b37 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe36b0b37 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe4f2487a 0045 14 EQ 0046 61 PUSH2 0x06aa 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06aa, if 0xe4f2487a == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe4f2487a == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe6d37b88 0050 14 EQ 0051 61 PUSH2 0x06cb 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06cb, if 0xe6d37b88 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe6d37b88 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x06de 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06de, if 0xe985e9c5 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x0727 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0727, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == stack[-1] // Inputs[1] { @006E memory[0x00:0x00] } 006B 60 PUSH1 0x00 006D 80 DUP1 006E FD *REVERT // Stack delta = +0 // Outputs[1] { @006E revert(memory[0x00:0x00]); } // Block terminates label_006F: // Incoming jump from 0x0033, if 0xe36b0b37 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xbac426d0 0076 14 EQ 0077 61 PUSH2 0x05f2 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f2, if 0xbac426d0 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xbac426d0 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xc23dc68f 0081 14 EQ 0082 61 PUSH2 0x0612 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0612, if 0xc23dc68f == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xc23dc68f == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc870c012 008C 14 EQ 008D 61 PUSH2 0x063f 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x063f, if 0xc870c012 == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc870c012 == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xc87b56dd 0097 14 EQ 0098 61 PUSH2 0x065f 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x065f, if 0xc87b56dd == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xc87b56dd == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xd5abeb01 00A2 14 EQ 00A3 61 PUSH2 0x067f 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x067f, if 0xd5abeb01 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xd5abeb01 == stack[-1] // Inputs[1] { @00AA memory[0x00:0x00] } 00A7 60 PUSH1 0x00 00A9 80 DUP1 00AA FD *REVERT // Stack delta = +0 // Outputs[1] { @00AA revert(memory[0x00:0x00]); } // Block terminates label_00AB: // Incoming jump from 0x0028, if 0xbac426d0 > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AB 5B JUMPDEST 00AC 80 DUP1 00AD 63 PUSH4 0x99a2557a 00B2 11 GT 00B3 61 PUSH2 0x00f2 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f2, if 0x99a2557a > stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x99a2557a > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x99a2557a 00BD 14 EQ 00BE 61 PUSH2 0x054c 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x054c, if 0x99a2557a == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x99a2557a == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0xa22cb465 00C8 14 EQ 00C9 61 PUSH2 0x056c 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x056c, if 0xa22cb465 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xb467e43a 00D3 14 EQ 00D4 61 PUSH2 0x058c 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x058c, if 0xb467e43a == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xb467e43a == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0xb88d4fde 00DE 14 EQ 00DF 61 PUSH2 0x05bf 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05bf, if 0xb88d4fde == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xb88d4fde == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xba70732b 00E9 14 EQ 00EA 61 PUSH2 0x05d2 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05d2, if 0xba70732b == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xba70732b == stack[-1] // Inputs[1] { @00F1 memory[0x00:0x00] } 00EE 60 PUSH1 0x00 00F0 80 DUP1 00F1 FD *REVERT // Stack delta = +0 // Outputs[1] { @00F1 revert(memory[0x00:0x00]); } // Block terminates label_00F2: // Incoming jump from 0x00B6, if 0x99a2557a > stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F2 5B JUMPDEST 00F3 80 DUP1 00F4 63 PUSH4 0x715018a6 00F9 14 EQ 00FA 61 PUSH2 0x04d7 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d7, if 0x715018a6 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x715018a6 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x8462151c 0104 14 EQ 0105 61 PUSH2 0x04ec 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04ec, if 0x8462151c == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x8462151c == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x8da5cb5b 010F 14 EQ 0110 61 PUSH2 0x0519 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0519, if 0x8da5cb5b == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x95d89b41 011A 14 EQ 011B 61 PUSH2 0x0537 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0537, if 0x95d89b41 == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x95d89b41 == stack[-1] // Inputs[1] { @0122 memory[0x00:0x00] } 011F 60 PUSH1 0x00 0121 80 DUP1 0122 FD *REVERT // Stack delta = +0 // Outputs[1] { @0122 revert(memory[0x00:0x00]); } // Block terminates label_0123: // Incoming jump from 0x001D, if 0x715018a6 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0124 stack[-1] } 0123 5B JUMPDEST 0124 80 DUP1 0125 63 PUSH4 0x2785bf16 012A 11 GT 012B 61 PUSH2 0x01b1 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01b1, if 0x2785bf16 > stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x2785bf16 > stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x484b973c 0135 11 GT 0136 61 PUSH2 0x0175 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0175, if 0x484b973c > stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x484b973c > stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x484b973c 0140 14 EQ 0141 61 PUSH2 0x042a 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x042a, if 0x484b973c == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x484b973c == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x5bbb2177 014B 14 EQ 014C 61 PUSH2 0x044a 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x044a, if 0x5bbb2177 == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x5bbb2177 == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x6352211e 0156 14 EQ 0157 61 PUSH2 0x0477 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0477, if 0x6352211e == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x6352211e == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x6f8b44b0 0161 14 EQ 0162 61 PUSH2 0x0497 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0497, if 0x6f8b44b0 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x6f8b44b0 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x70a08231 016C 14 EQ 016D 61 PUSH2 0x04b7 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04b7, if 0x70a08231 == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x70a08231 == stack[-1] // Inputs[1] { @0174 memory[0x00:0x00] } 0171 60 PUSH1 0x00 0173 80 DUP1 0174 FD *REVERT // Stack delta = +0 // Outputs[1] { @0174 revert(memory[0x00:0x00]); } // Block terminates label_0175: // Incoming jump from 0x0139, if 0x484b973c > stack[-1] // Inputs[1] { @0176 stack[-1] } 0175 5B JUMPDEST 0176 80 DUP1 0177 63 PUSH4 0x2785bf16 017C 14 EQ 017D 61 PUSH2 0x0381 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0381, if 0x2785bf16 == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x2785bf16 == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x2a55205a 0187 14 EQ 0188 61 PUSH2 0x03a1 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a1, if 0x2a55205a == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x2a55205a == stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x3ccfd60b 0192 14 EQ 0193 61 PUSH2 0x03e0 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e0, if 0x3ccfd60b == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x41f43434 019D 14 EQ 019E 61 PUSH2 0x03f5 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f5, if 0x41f43434 == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x41f43434 == stack[-1] // Inputs[1] { @01A2 stack[-1] } 01A2 80 DUP1 01A3 63 PUSH4 0x42842e0e 01A8 14 EQ 01A9 61 PUSH2 0x0417 01AC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0417, if 0x42842e0e == stack[-1] label_01AD: // Incoming jump from 0x01AC, if not 0x42842e0e == stack[-1] // Inputs[1] { @01B0 memory[0x00:0x00] } 01AD 60 PUSH1 0x00 01AF 80 DUP1 01B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01B0 revert(memory[0x00:0x00]); } // Block terminates label_01B1: // Incoming jump from 0x012E, if 0x2785bf16 > stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B1 5B JUMPDEST 01B2 80 DUP1 01B3 63 PUSH4 0x095ea7b3 01B8 11 GT 01B9 61 PUSH2 0x01f8 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f8, if 0x095ea7b3 > stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x095ea7b3 01C3 14 EQ 01C4 61 PUSH2 0x02db 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02db, if 0x095ea7b3 == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C8 80 DUP1 01C9 63 PUSH4 0x13faede6 01CE 14 EQ 01CF 61 PUSH2 0x02ee 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ee, if 0x13faede6 == stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x13faede6 == stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x18160ddd 01D9 14 EQ 01DA 61 PUSH2 0x0326 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0326, if 0x18160ddd == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x18160ddd == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x1d610dd1 01E4 14 EQ 01E5 61 PUSH2 0x034e 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x034e, if 0x1d610dd1 == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x1d610dd1 == stack[-1] // Inputs[1] { @01E9 stack[-1] } 01E9 80 DUP1 01EA 63 PUSH4 0x23b872dd 01EF 14 EQ 01F0 61 PUSH2 0x036e 01F3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036e, if 0x23b872dd == stack[-1] label_01F4: // Incoming jump from 0x01F3, if not 0x23b872dd == stack[-1] // Inputs[1] { @01F7 memory[0x00:0x00] } 01F4 60 PUSH1 0x00 01F6 80 DUP1 01F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F7 revert(memory[0x00:0x00]); } // Block terminates label_01F8: // Incoming jump from 0x01BC, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01F9 stack[-1] } 01F8 5B JUMPDEST 01F9 80 DUP1 01FA 63 PUSH4 0x01ffc9a7 01FF 14 EQ 0200 61 PUSH2 0x022a 0203 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x022a, if 0x01ffc9a7 == stack[-1] label_0204: // Incoming jump from 0x0203, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0204 stack[-1] } 0204 80 DUP1 0205 63 PUSH4 0x04634d8d 020A 14 EQ 020B 61 PUSH2 0x025f 020E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025f, if 0x04634d8d == stack[-1] label_020F: // Incoming jump from 0x020E, if not 0x04634d8d == stack[-1] // Inputs[1] { @020F stack[-1] } 020F 80 DUP1 0210 63 PUSH4 0x06fdde03 0215 14 EQ 0216 61 PUSH2 0x0281 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0281, if 0x06fdde03 == stack[-1] label_021A: // Incoming jump from 0x0219, if not 0x06fdde03 == stack[-1] // Inputs[1] { @021A stack[-1] } 021A 80 DUP1 021B 63 PUSH4 0x081812fc 0220 14 EQ 0221 61 PUSH2 0x02a3 0224 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a3, if 0x081812fc == stack[-1] label_0225: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0224, if not 0x081812fc == stack[-1] // Inputs[1] { @0229 memory[0x00:0x00] } 0225 5B JUMPDEST 0226 60 PUSH1 0x00 0228 80 DUP1 0229 FD *REVERT // Stack delta = +0 // Outputs[1] { @0229 revert(memory[0x00:0x00]); } // Block terminates label_022A: // Incoming jump from 0x0203, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @022B msg.value } 022A 5B JUMPDEST 022B 34 CALLVALUE 022C 80 DUP1 022D 15 ISZERO 022E 61 PUSH2 0x0236 0231 57 *JUMPI // Stack delta = +1 // Outputs[1] { @022B stack[0] = msg.value } // Block ends with conditional jump to 0x0236, if !msg.value label_0232: // Incoming jump from 0x0231, if not !msg.value // Inputs[1] { @0235 memory[0x00:0x00] } 0232 60 PUSH1 0x00 0234 80 DUP1 0235 FD *REVERT // Stack delta = +0 // Outputs[1] { @0235 revert(memory[0x00:0x00]); } // Block terminates label_0236: // Incoming jump from 0x0231, if !msg.value // Inputs[1] { @023E msg.data.length } 0236 5B JUMPDEST 0237 50 POP 0238 61 PUSH2 0x024a 023B 61 PUSH2 0x0245 023E 36 CALLDATASIZE 023F 60 PUSH1 0x04 0241 61 PUSH2 0x1e18 0244 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0238 stack[-1] = 0x024a // @023B stack[0] = 0x0245 // @023E stack[1] = msg.data.length // @023F stack[2] = 0x04 // } // Block ends with call to 0x1e18, returns to 0x0245 label_0245: // Incoming return from call to 0x1E18 at 0x0244 0245 5B JUMPDEST 0246 61 PUSH2 0x0747 0249 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0747 label_024A: // Incoming return from call to 0x0245 at 0x0244 // Incoming return from call to 0x06F9 at 0x06F8 // Inputs[2] // { // @024D memory[0x40:0x60] // @024E stack[-1] // } 024A 5B JUMPDEST 024B 60 PUSH1 0x40 024D 51 MLOAD 024E 90 SWAP1 024F 15 ISZERO 0250 15 ISZERO 0251 81 DUP2 0252 52 MSTORE 0253 60 PUSH1 0x20 0255 01 ADD // Stack delta = +0 // Outputs[2] // { // @0252 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0255 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_0256: // Incoming return from call to 0x215D at 0x0476 // Incoming jump from 0x05BE // Incoming jump from 0x034D // Incoming return from call to 0x230E at 0x063E // Incoming jump from 0x02DA // Incoming return from call to 0x21BA at 0x0518 // Incoming jump from 0x0255 // Incoming jump from 0x0325 // Incoming jump from 0x034D // Inputs[3] // { // @0259 memory[0x40:0x60] // @025B stack[-1] // @025E memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0256 5B JUMPDEST 0257 60 PUSH1 0x40 0259 51 MLOAD 025A 80 DUP1 025B 91 SWAP2 025C 03 SUB 025D 90 SWAP1 025E F3 *RETURN // Stack delta = -1 // Outputs[1] { @025E return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_025F: // Incoming jump from 0x020E, if 0x04634d8d == stack[-1] // Inputs[1] { @0260 msg.value } 025F 5B JUMPDEST 0260 34 CALLVALUE 0261 80 DUP1 0262 15 ISZERO 0263 61 PUSH2 0x026b 0266 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0260 stack[0] = msg.value } // Block ends with conditional jump to 0x026b, if !msg.value label_0267: // Incoming jump from 0x0266, if not !msg.value // Inputs[1] { @026A memory[0x00:0x00] } 0267 60 PUSH1 0x00 0269 80 DUP1 026A FD *REVERT // Stack delta = +0 // Outputs[1] { @026A revert(memory[0x00:0x00]); } // Block terminates label_026B: // Incoming jump from 0x0266, if !msg.value // Inputs[1] { @0273 msg.data.length } 026B 5B JUMPDEST 026C 50 POP 026D 61 PUSH2 0x027f 0270 61 PUSH2 0x027a 0273 36 CALLDATASIZE 0274 60 PUSH1 0x04 0276 61 PUSH2 0x1e4c 0279 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @026D stack[-1] = 0x027f // @0270 stack[0] = 0x027a // @0273 stack[1] = msg.data.length // @0274 stack[2] = 0x04 // } // Block ends with call to 0x1e4c, returns to 0x027A label_027A: // Incoming return from call to 0x1E4C at 0x0279 027A 5B JUMPDEST 027B 61 PUSH2 0x0767 027E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0767 label_027F: // Incoming return from call to 0x0742 at 0x0741 // Incoming return from call to 0x039C at 0x039B // Incoming return from call to 0x0369 at 0x0368 // Incoming return from call to 0x0F6D at 0x06A9 // Incoming return from call to 0x0B2D at 0x03F4 // Incoming return from call to 0x04B2 at 0x04B1 // Incoming return from call to 0x060D at 0x060C // Incoming return from call to 0x027A at 0x0279 027F 5B JUMPDEST 0280 00 *STOP // Stack delta = +0 // Outputs[1] { @0280 stop(); } // Block terminates label_0281: // Incoming jump from 0x0219, if 0x06fdde03 == stack[-1] // Inputs[1] { @0282 msg.value } 0281 5B JUMPDEST 0282 34 CALLVALUE 0283 80 DUP1 0284 15 ISZERO 0285 61 PUSH2 0x028d 0288 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0282 stack[0] = msg.value } // Block ends with conditional jump to 0x028d, if !msg.value label_0289: // Incoming jump from 0x0288, if not !msg.value // Inputs[1] { @028C memory[0x00:0x00] } 0289 60 PUSH1 0x00 028B 80 DUP1 028C FD *REVERT // Stack delta = +0 // Outputs[1] { @028C revert(memory[0x00:0x00]); } // Block terminates label_028D: // Incoming jump from 0x0288, if !msg.value 028D 5B JUMPDEST 028E 50 POP 028F 61 PUSH2 0x0296 0292 61 PUSH2 0x077d 0295 56 *JUMP // Stack delta = +0 // Outputs[1] { @028F stack[-1] = 0x0296 } // Block ends with call to 0x077d, returns to 0x0296 label_0296: // Incoming return from call to 0x077D at 0x0295 // Incoming return from call to 0x0D17 at 0x054B // Inputs[2] // { // @0299 memory[0x40:0x60] // @029D stack[-1] // } 0296 5B JUMPDEST 0297 60 PUSH1 0x40 0299 51 MLOAD 029A 61 PUSH2 0x0256 029D 91 SWAP2 029E 90 SWAP1 029F 61 PUSH2 0x1edf 02A2 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @029D stack[-1] = 0x0256 // @029E stack[1] = memory[0x40:0x60] // @029E stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x1edf label_02A3: // Incoming jump from 0x0224, if 0x081812fc == stack[-1] // Inputs[1] { @02A4 msg.value } 02A3 5B JUMPDEST 02A4 34 CALLVALUE 02A5 80 DUP1 02A6 15 ISZERO 02A7 61 PUSH2 0x02af 02AA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A4 stack[0] = msg.value } // Block ends with conditional jump to 0x02af, if !msg.value label_02AB: // Incoming jump from 0x02AA, if not !msg.value // Inputs[1] { @02AE memory[0x00:0x00] } 02AB 60 PUSH1 0x00 02AD 80 DUP1 02AE FD *REVERT // Stack delta = +0 // Outputs[1] { @02AE revert(memory[0x00:0x00]); } // Block terminates label_02AF: // Incoming jump from 0x02AA, if !msg.value // Inputs[1] { @02B7 msg.data.length } 02AF 5B JUMPDEST 02B0 50 POP 02B1 61 PUSH2 0x02c3 02B4 61 PUSH2 0x02be 02B7 36 CALLDATASIZE 02B8 60 PUSH1 0x04 02BA 61 PUSH2 0x1ef2 02BD 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02B1 stack[-1] = 0x02c3 // @02B4 stack[0] = 0x02be // @02B7 stack[1] = msg.data.length // @02B8 stack[2] = 0x04 // } // Block ends with call to 0x1ef2, returns to 0x02BE label_02BE: // Incoming return from call to 0x1EF2 at 0x02BD 02BE 5B JUMPDEST 02BF 61 PUSH2 0x080f 02C2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x080f label_02C3: // Incoming return from call to 0x0492 at 0x0491 // Incoming jump from 0x0416 // Incoming return from call to 0x02BE at 0x02BD // Incoming jump from 0x0536 // Inputs[2] // { // @02C6 memory[0x40:0x60] // @02D0 stack[-1] // } 02C3 5B JUMPDEST 02C4 60 PUSH1 0x40 02C6 51 MLOAD 02C7 60 PUSH1 0x01 02C9 60 PUSH1 0x01 02CB 60 PUSH1 0xa0 02CD 1B SHL 02CE 03 SUB 02CF 90 SWAP1 02D0 91 SWAP2 02D1 16 AND 02D2 81 DUP2 02D3 52 MSTORE 02D4 60 PUSH1 0x20 02D6 01 ADD 02D7 61 PUSH2 0x0256 02DA 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02D3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @02D6 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0256 label_02DB: // Incoming jump from 0x01C7, if 0x095ea7b3 == stack[-1] // Inputs[1] { @02E2 msg.data.length } 02DB 5B JUMPDEST 02DC 61 PUSH2 0x027f 02DF 61 PUSH2 0x02e9 02E2 36 CALLDATASIZE 02E3 60 PUSH1 0x04 02E5 61 PUSH2 0x1f0b 02E8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02DC stack[0] = 0x027f // @02DF stack[1] = 0x02e9 // @02E2 stack[2] = msg.data.length // @02E3 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x1f0b 02E9 5B JUMPDEST 02EA 61 PUSH2 0x084a 02ED 56 *JUMP label_02EE: // Incoming jump from 0x01D2, if 0x13faede6 == stack[-1] // Inputs[1] { @02EF msg.value } 02EE 5B JUMPDEST 02EF 34 CALLVALUE 02F0 80 DUP1 02F1 15 ISZERO 02F2 61 PUSH2 0x02fa 02F5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02EF stack[0] = msg.value } // Block ends with conditional jump to 0x02fa, if !msg.value label_02F6: // Incoming jump from 0x02F5, if not !msg.value // Inputs[1] { @02F9 memory[0x00:0x00] } 02F6 60 PUSH1 0x00 02F8 80 DUP1 02F9 FD *REVERT // Stack delta = +0 // Outputs[1] { @02F9 revert(memory[0x00:0x00]); } // Block terminates label_02FA: // Incoming jump from 0x02F5, if !msg.value // Inputs[1] { @02FE storage[0x0f] } 02FA 5B JUMPDEST 02FB 50 POP 02FC 60 PUSH1 0x0f 02FE 54 SLOAD 02FF 61 PUSH2 0x030e 0302 90 SWAP1 0303 60 PUSH1 0x01 0305 60 PUSH1 0x01 0307 60 PUSH1 0x40 0309 1B SHL 030A 03 SUB 030B 16 AND 030C 81 DUP2 030D 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0302 stack[-1] = 0x030e // @030B stack[0] = (0x01 << 0x40) - 0x01 & storage[0x0f] // } // Block ends with unconditional jump to 0x030e label_030E: // Incoming jump from 0x030D // Inputs[2] // { // @0311 memory[0x40:0x60] // @031B stack[-1] // } 030E 5B JUMPDEST 030F 60 PUSH1 0x40 0311 51 MLOAD 0312 60 PUSH1 0x01 0314 60 PUSH1 0x01 0316 60 PUSH1 0x40 0318 1B SHL 0319 03 SUB 031A 90 SWAP1 031B 91 SWAP2 031C 16 AND 031D 81 DUP2 031E 52 MSTORE 031F 60 PUSH1 0x20 0321 01 ADD 0322 61 PUSH2 0x0256 0325 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @031E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0x40) - 0x01 // @0321 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0256 label_0326: // Incoming jump from 0x01DD, if 0x18160ddd == stack[-1] // Inputs[1] { @0327 msg.value } 0326 5B JUMPDEST 0327 34 CALLVALUE 0328 80 DUP1 0329 15 ISZERO 032A 61 PUSH2 0x0332 032D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0327 stack[0] = msg.value } // Block ends with conditional jump to 0x0332, if !msg.value label_032E: // Incoming jump from 0x032D, if not !msg.value // Inputs[1] { @0331 memory[0x00:0x00] } 032E 60 PUSH1 0x00 0330 80 DUP1 0331 FD *REVERT // Stack delta = +0 // Outputs[1] { @0331 revert(memory[0x00:0x00]); } // Block terminates label_0332: // Incoming jump from 0x032D, if !msg.value // Inputs[3] // { // @0336 storage[0x02] // @0339 storage[0x01] // @0343 memory[0x40:0x60] // } 0332 5B JUMPDEST 0333 50 POP 0334 60 PUSH1 0x02 0336 54 SLOAD 0337 60 PUSH1 0x01 0339 54 SLOAD 033A 03 SUB 033B 61 PUSH2 0x059b 033E 19 NOT 033F 01 ADD 0340 5B JUMPDEST 0341 60 PUSH1 0x40 0343 51 MLOAD 0344 90 SWAP1 0345 81 DUP2 0346 52 MSTORE 0347 60 PUSH1 0x20 0349 01 ADD 034A 61 PUSH2 0x0256 034D 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0346 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = ~0x059b + (storage[0x01] - storage[0x02]) // @0349 stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0256 label_034E: // Incoming jump from 0x01E8, if 0x1d610dd1 == stack[-1] // Inputs[1] { @034F msg.value } 034E 5B JUMPDEST 034F 34 CALLVALUE 0350 80 DUP1 0351 15 ISZERO 0352 61 PUSH2 0x035a 0355 57 *JUMPI // Stack delta = +1 // Outputs[1] { @034F stack[0] = msg.value } // Block ends with conditional jump to 0x035a, if !msg.value label_0356: // Incoming jump from 0x0355, if not !msg.value // Inputs[1] { @0359 memory[0x00:0x00] } 0356 60 PUSH1 0x00 0358 80 DUP1 0359 FD *REVERT // Stack delta = +0 // Outputs[1] { @0359 revert(memory[0x00:0x00]); } // Block terminates label_035A: // Incoming jump from 0x0355, if !msg.value // Inputs[1] { @0362 msg.data.length } 035A 5B JUMPDEST 035B 50 POP 035C 61 PUSH2 0x027f 035F 61 PUSH2 0x0369 0362 36 CALLDATASIZE 0363 60 PUSH1 0x04 0365 61 PUSH2 0x1f35 0368 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @035C stack[-1] = 0x027f // @035F stack[0] = 0x0369 // @0362 stack[1] = msg.data.length // @0363 stack[2] = 0x04 // } // Block ends with call to 0x1f35, returns to 0x0369 label_0369: // Incoming return from call to 0x1F35 at 0x0368 0369 5B JUMPDEST 036A 61 PUSH2 0x0863 036D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0863 label_036E: // Incoming jump from 0x01F3, if 0x23b872dd == stack[-1] // Inputs[1] { @0375 msg.data.length } 036E 5B JUMPDEST 036F 61 PUSH2 0x027f 0372 61 PUSH2 0x037c 0375 36 CALLDATASIZE 0376 60 PUSH1 0x04 0378 61 PUSH2 0x1f5f 037B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @036F stack[0] = 0x027f // @0372 stack[1] = 0x037c // @0375 stack[2] = msg.data.length // @0376 stack[3] = 0x04 // } // Block ends with call to 0x1f5f, returns to 0x037C label_037C: // Incoming return from call to 0x1F5F at 0x037B 037C 5B JUMPDEST 037D 61 PUSH2 0x0952 0380 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0952 label_0381: // Incoming jump from 0x0180, if 0x2785bf16 == stack[-1] // Inputs[1] { @0382 msg.value } 0381 5B JUMPDEST 0382 34 CALLVALUE 0383 80 DUP1 0384 15 ISZERO 0385 61 PUSH2 0x038d 0388 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0382 stack[0] = msg.value } // Block ends with conditional jump to 0x038d, if !msg.value label_0389: // Incoming jump from 0x0388, if not !msg.value // Inputs[1] { @038C memory[0x00:0x00] } 0389 60 PUSH1 0x00 038B 80 DUP1 038C FD *REVERT // Stack delta = +0 // Outputs[1] { @038C revert(memory[0x00:0x00]); } // Block terminates label_038D: // Incoming jump from 0x0388, if !msg.value // Inputs[1] { @0395 msg.data.length } 038D 5B JUMPDEST 038E 50 POP 038F 61 PUSH2 0x027f 0392 61 PUSH2 0x039c 0395 36 CALLDATASIZE 0396 60 PUSH1 0x04 0398 61 PUSH2 0x2046 039B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @038F stack[-1] = 0x027f // @0392 stack[0] = 0x039c // @0395 stack[1] = msg.data.length // @0396 stack[2] = 0x04 // } // Block ends with call to 0x2046, returns to 0x039C label_039C: // Incoming return from call to 0x2046 at 0x039B 039C 5B JUMPDEST 039D 61 PUSH2 0x097d 03A0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x097d label_03A1: // Incoming jump from 0x018B, if 0x2a55205a == stack[-1] // Inputs[1] { @03A2 msg.value } 03A1 5B JUMPDEST 03A2 34 CALLVALUE 03A3 80 DUP1 03A4 15 ISZERO 03A5 61 PUSH2 0x03ad 03A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A2 stack[0] = msg.value } // Block ends with conditional jump to 0x03ad, if !msg.value label_03A9: // Incoming jump from 0x03A8, if not !msg.value // Inputs[1] { @03AC memory[0x00:0x00] } 03A9 60 PUSH1 0x00 03AB 80 DUP1 03AC FD *REVERT // Stack delta = +0 // Outputs[1] { @03AC revert(memory[0x00:0x00]); } // Block terminates label_03AD: // Incoming jump from 0x03A8, if !msg.value // Inputs[1] { @03B5 msg.data.length } 03AD 5B JUMPDEST 03AE 50 POP 03AF 61 PUSH2 0x03c1 03B2 61 PUSH2 0x03bc 03B5 36 CALLDATASIZE 03B6 60 PUSH1 0x04 03B8 61 PUSH2 0x207a 03BB 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03AF stack[-1] = 0x03c1 // @03B2 stack[0] = 0x03bc // @03B5 stack[1] = msg.data.length // @03B6 stack[2] = 0x04 // } // Block ends with call to 0x207a, returns to 0x03BC label_03BC: // Incoming return from call to 0x207A at 0x03BB 03BC 5B JUMPDEST 03BD 61 PUSH2 0x0a7f 03C0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a7f 03C1 5B JUMPDEST 03C2 60 PUSH1 0x40 03C4 80 DUP1 03C5 51 MLOAD 03C6 60 PUSH1 0x01 03C8 60 PUSH1 0x01 03CA 60 PUSH1 0xa0 03CC 1B SHL 03CD 03 SUB 03CE 90 SWAP1 03CF 93 SWAP4 03D0 16 AND 03D1 83 DUP4 03D2 52 MSTORE 03D3 60 PUSH1 0x20 03D5 83 DUP4 03D6 01 ADD 03D7 91 SWAP2 03D8 90 SWAP1 03D9 91 SWAP2 03DA 52 MSTORE 03DB 01 ADD 03DC 61 PUSH2 0x0256 03DF 56 *JUMP label_03E0: // Incoming jump from 0x0196, if 0x3ccfd60b == stack[-1] // Inputs[1] { @03E1 msg.value } 03E0 5B JUMPDEST 03E1 34 CALLVALUE 03E2 80 DUP1 03E3 15 ISZERO 03E4 61 PUSH2 0x03ec 03E7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03E1 stack[0] = msg.value } // Block ends with conditional jump to 0x03ec, if !msg.value label_03E8: // Incoming jump from 0x03E7, if not !msg.value // Inputs[1] { @03EB memory[0x00:0x00] } 03E8 60 PUSH1 0x00 03EA 80 DUP1 03EB FD *REVERT // Stack delta = +0 // Outputs[1] { @03EB revert(memory[0x00:0x00]); } // Block terminates label_03EC: // Incoming jump from 0x03E7, if !msg.value 03EC 5B JUMPDEST 03ED 50 POP 03EE 61 PUSH2 0x027f 03F1 61 PUSH2 0x0b2d 03F4 56 *JUMP // Stack delta = +0 // Outputs[1] { @03EE stack[-1] = 0x027f } // Block ends with call to 0x0b2d, returns to 0x027F label_03F5: // Incoming jump from 0x01A1, if 0x41f43434 == stack[-1] // Inputs[1] { @03F6 msg.value } 03F5 5B JUMPDEST 03F6 34 CALLVALUE 03F7 80 DUP1 03F8 15 ISZERO 03F9 61 PUSH2 0x0401 03FC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F6 stack[0] = msg.value } // Block ends with conditional jump to 0x0401, if !msg.value label_03FD: // Incoming jump from 0x03FC, if not !msg.value // Inputs[1] { @0400 memory[0x00:0x00] } 03FD 60 PUSH1 0x00 03FF 80 DUP1 0400 FD *REVERT // Stack delta = +0 // Outputs[1] { @0400 revert(memory[0x00:0x00]); } // Block terminates label_0401: // Incoming jump from 0x03FC, if !msg.value 0401 5B JUMPDEST 0402 50 POP 0403 61 PUSH2 0x02c3 0406 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 0415 81 DUP2 0416 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0403 stack[-1] = 0x02c3 // @0406 stack[0] = 0xaaeb6d7670e522a718067333cd4e // } // Block ends with unconditional jump to 0x02c3 label_0417: // Incoming jump from 0x01AC, if 0x42842e0e == stack[-1] // Inputs[1] { @041E msg.data.length } 0417 5B JUMPDEST 0418 61 PUSH2 0x027f 041B 61 PUSH2 0x0425 041E 36 CALLDATASIZE 041F 60 PUSH1 0x04 0421 61 PUSH2 0x1f5f 0424 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0418 stack[0] = 0x027f // @041B stack[1] = 0x0425 // @041E stack[2] = msg.data.length // @041F stack[3] = 0x04 // } // Block ends with call to 0x1f5f, returns to 0x0425 label_0425: // Incoming return from call to 0x1F5F at 0x0424 0425 5B JUMPDEST 0426 61 PUSH2 0x0b5b 0429 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0b5b label_042A: // Incoming jump from 0x0144, if 0x484b973c == stack[-1] // Inputs[1] { @042B msg.value } 042A 5B JUMPDEST 042B 34 CALLVALUE 042C 80 DUP1 042D 15 ISZERO 042E 61 PUSH2 0x0436 0431 57 *JUMPI // Stack delta = +1 // Outputs[1] { @042B stack[0] = msg.value } // Block ends with conditional jump to 0x0436, if !msg.value label_0432: // Incoming jump from 0x0431, if not !msg.value // Inputs[1] { @0435 memory[0x00:0x00] } 0432 60 PUSH1 0x00 0434 80 DUP1 0435 FD *REVERT // Stack delta = +0 // Outputs[1] { @0435 revert(memory[0x00:0x00]); } // Block terminates label_0436: // Incoming jump from 0x0431, if !msg.value // Inputs[1] { @043E msg.data.length } 0436 5B JUMPDEST 0437 50 POP 0438 61 PUSH2 0x027f 043B 61 PUSH2 0x0445 043E 36 CALLDATASIZE 043F 60 PUSH1 0x04 0441 61 PUSH2 0x1f0b 0444 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0438 stack[-1] = 0x027f // @043B stack[0] = 0x0445 // @043E stack[1] = msg.data.length // @043F stack[2] = 0x04 // } // Block ends with unconditional jump to 0x1f0b 0445 5B JUMPDEST 0446 61 PUSH2 0x0b80 0449 56 *JUMP label_044A: // Incoming jump from 0x014F, if 0x5bbb2177 == stack[-1] // Inputs[1] { @044B msg.value } 044A 5B JUMPDEST 044B 34 CALLVALUE 044C 80 DUP1 044D 15 ISZERO 044E 61 PUSH2 0x0456 0451 57 *JUMPI // Stack delta = +1 // Outputs[1] { @044B stack[0] = msg.value } // Block ends with conditional jump to 0x0456, if !msg.value label_0452: // Incoming jump from 0x0451, if not !msg.value // Inputs[1] { @0455 memory[0x00:0x00] } 0452 60 PUSH1 0x00 0454 80 DUP1 0455 FD *REVERT // Stack delta = +0 // Outputs[1] { @0455 revert(memory[0x00:0x00]); } // Block terminates label_0456: // Incoming jump from 0x0451, if !msg.value // Inputs[1] { @045E msg.data.length } 0456 5B JUMPDEST 0457 50 POP 0458 61 PUSH2 0x046a 045B 61 PUSH2 0x0465 045E 36 CALLDATASIZE 045F 60 PUSH1 0x04 0461 61 PUSH2 0x20e0 0464 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0458 stack[-1] = 0x046a // @045B stack[0] = 0x0465 // @045E stack[1] = msg.data.length // @045F stack[2] = 0x04 // } // Block ends with call to 0x20e0, returns to 0x0465 label_0465: // Incoming return from call to 0x20E0 at 0x0464 0465 5B JUMPDEST 0466 61 PUSH2 0x0bcd 0469 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bcd label_046A: // Incoming return from call to 0x0465 at 0x0464 // Inputs[2] // { // @046D memory[0x40:0x60] // @0471 stack[-1] // } 046A 5B JUMPDEST 046B 60 PUSH1 0x40 046D 51 MLOAD 046E 61 PUSH2 0x0256 0471 91 SWAP2 0472 90 SWAP1 0473 61 PUSH2 0x215d 0476 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0471 stack[-1] = 0x0256 // @0472 stack[1] = memory[0x40:0x60] // @0472 stack[0] = stack[-1] // } // Block ends with call to 0x215d, returns to 0x0256 label_0477: // Incoming jump from 0x015A, if 0x6352211e == stack[-1] // Inputs[1] { @0478 msg.value } 0477 5B JUMPDEST 0478 34 CALLVALUE 0479 80 DUP1 047A 15 ISZERO 047B 61 PUSH2 0x0483 047E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0478 stack[0] = msg.value } // Block ends with conditional jump to 0x0483, if !msg.value label_047F: // Incoming jump from 0x047E, if not !msg.value // Inputs[1] { @0482 memory[0x00:0x00] } 047F 60 PUSH1 0x00 0481 80 DUP1 0482 FD *REVERT // Stack delta = +0 // Outputs[1] { @0482 revert(memory[0x00:0x00]); } // Block terminates label_0483: // Incoming jump from 0x047E, if !msg.value // Inputs[1] { @048B msg.data.length } 0483 5B JUMPDEST 0484 50 POP 0485 61 PUSH2 0x02c3 0488 61 PUSH2 0x0492 048B 36 CALLDATASIZE 048C 60 PUSH1 0x04 048E 61 PUSH2 0x1ef2 0491 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0485 stack[-1] = 0x02c3 // @0488 stack[0] = 0x0492 // @048B stack[1] = msg.data.length // @048C stack[2] = 0x04 // } // Block ends with call to 0x1ef2, returns to 0x0492 label_0492: // Incoming return from call to 0x1EF2 at 0x0491 0492 5B JUMPDEST 0493 61 PUSH2 0x0c19 0496 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c19 label_0497: // Incoming jump from 0x0165, if 0x6f8b44b0 == 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] { @04AB msg.data.length } 04A3 5B JUMPDEST 04A4 50 POP 04A5 61 PUSH2 0x027f 04A8 61 PUSH2 0x04b2 04AB 36 CALLDATASIZE 04AC 60 PUSH1 0x04 04AE 61 PUSH2 0x1ef2 04B1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04A5 stack[-1] = 0x027f // @04A8 stack[0] = 0x04b2 // @04AB stack[1] = msg.data.length // @04AC stack[2] = 0x04 // } // Block ends with call to 0x1ef2, returns to 0x04B2 label_04B2: // Incoming return from call to 0x1EF2 at 0x04B1 04B2 5B JUMPDEST 04B3 61 PUSH2 0x0c24 04B6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c24 label_04B7: // Incoming jump from 0x0170, if 0x70a08231 == stack[-1] // Inputs[1] { @04B8 msg.value } 04B7 5B JUMPDEST 04B8 34 CALLVALUE 04B9 80 DUP1 04BA 15 ISZERO 04BB 61 PUSH2 0x04c3 04BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04B8 stack[0] = msg.value } // Block ends with conditional jump to 0x04c3, if !msg.value label_04BF: // Incoming jump from 0x04BE, if not !msg.value // Inputs[1] { @04C2 memory[0x00:0x00] } 04BF 60 PUSH1 0x00 04C1 80 DUP1 04C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @04C2 revert(memory[0x00:0x00]); } // Block terminates label_04C3: // Incoming jump from 0x04BE, if !msg.value // Inputs[1] { @04CB msg.data.length } 04C3 5B JUMPDEST 04C4 50 POP 04C5 61 PUSH2 0x0340 04C8 61 PUSH2 0x04d2 04CB 36 CALLDATASIZE 04CC 60 PUSH1 0x04 04CE 61 PUSH2 0x219f 04D1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04C5 stack[-1] = 0x0340 // @04C8 stack[0] = 0x04d2 // @04CB stack[1] = msg.data.length // @04CC stack[2] = 0x04 // } // Block ends with call to 0x219f, returns to 0x04D2 label_04D2: // Incoming return from call to 0x219F at 0x04D1 04D2 5B JUMPDEST 04D3 61 PUSH2 0x0c97 04D6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c97 label_04D7: // Incoming jump from 0x00FD, if 0x715018a6 == 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 04E3 5B JUMPDEST 04E4 50 POP 04E5 61 PUSH2 0x027f 04E8 61 PUSH2 0x0cdc 04EB 56 *JUMP // Stack delta = +0 // Outputs[1] { @04E5 stack[-1] = 0x027f } // Block ends with unconditional jump to 0x0cdc label_04EC: // Incoming jump from 0x0108, if 0x8462151c == stack[-1] // Inputs[1] { @04ED msg.value } 04EC 5B JUMPDEST 04ED 34 CALLVALUE 04EE 80 DUP1 04EF 15 ISZERO 04F0 61 PUSH2 0x04f8 04F3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04ED stack[0] = msg.value } // Block ends with conditional jump to 0x04f8, if !msg.value label_04F4: // Incoming jump from 0x04F3, if not !msg.value // Inputs[1] { @04F7 memory[0x00:0x00] } 04F4 60 PUSH1 0x00 04F6 80 DUP1 04F7 FD *REVERT // Stack delta = +0 // Outputs[1] { @04F7 revert(memory[0x00:0x00]); } // Block terminates label_04F8: // Incoming jump from 0x04F3, if !msg.value // Inputs[1] { @0500 msg.data.length } 04F8 5B JUMPDEST 04F9 50 POP 04FA 61 PUSH2 0x050c 04FD 61 PUSH2 0x0507 0500 36 CALLDATASIZE 0501 60 PUSH1 0x04 0503 61 PUSH2 0x219f 0506 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04FA stack[-1] = 0x050c // @04FD stack[0] = 0x0507 // @0500 stack[1] = msg.data.length // @0501 stack[2] = 0x04 // } // Block ends with call to 0x219f, returns to 0x0507 label_0507: // Incoming return from call to 0x219F at 0x0506 0507 5B JUMPDEST 0508 61 PUSH2 0x0cee 050B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cee label_050C: // Incoming return from call to 0x0507 at 0x0506 // Inputs[2] // { // @050F memory[0x40:0x60] // @0513 stack[-1] // } 050C 5B JUMPDEST 050D 60 PUSH1 0x40 050F 51 MLOAD 0510 61 PUSH2 0x0256 0513 91 SWAP2 0514 90 SWAP1 0515 61 PUSH2 0x21ba 0518 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0513 stack[-1] = 0x0256 // @0514 stack[1] = memory[0x40:0x60] // @0514 stack[0] = stack[-1] // } // Block ends with call to 0x21ba, returns to 0x0256 label_0519: // Incoming jump from 0x0113, if 0x8da5cb5b == stack[-1] // Inputs[1] { @051A msg.value } 0519 5B JUMPDEST 051A 34 CALLVALUE 051B 80 DUP1 051C 15 ISZERO 051D 61 PUSH2 0x0525 0520 57 *JUMPI // Stack delta = +1 // Outputs[1] { @051A stack[0] = msg.value } // Block ends with conditional jump to 0x0525, if !msg.value label_0521: // Incoming jump from 0x0520, if not !msg.value // Inputs[1] { @0524 memory[0x00:0x00] } 0521 60 PUSH1 0x00 0523 80 DUP1 0524 FD *REVERT // Stack delta = +0 // Outputs[1] { @0524 revert(memory[0x00:0x00]); } // Block terminates label_0525: // Incoming jump from 0x0520, if !msg.value // Inputs[1] { @0529 storage[0x00] } 0525 5B JUMPDEST 0526 50 POP 0527 60 PUSH1 0x00 0529 54 SLOAD 052A 60 PUSH1 0x01 052C 60 PUSH1 0x01 052E 60 PUSH1 0xa0 0530 1B SHL 0531 03 SUB 0532 16 AND 0533 61 PUSH2 0x02c3 0536 56 *JUMP // Stack delta = +0 // Outputs[1] { @0532 stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x00] } // Block ends with unconditional jump to 0x02c3 label_0537: // Incoming jump from 0x011E, if 0x95d89b41 == stack[-1] // Inputs[1] { @0538 msg.value } 0537 5B JUMPDEST 0538 34 CALLVALUE 0539 80 DUP1 053A 15 ISZERO 053B 61 PUSH2 0x0543 053E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0538 stack[0] = msg.value } // Block ends with conditional jump to 0x0543, if !msg.value label_053F: // Incoming jump from 0x053E, if not !msg.value // Inputs[1] { @0542 memory[0x00:0x00] } 053F 60 PUSH1 0x00 0541 80 DUP1 0542 FD *REVERT // Stack delta = +0 // Outputs[1] { @0542 revert(memory[0x00:0x00]); } // Block terminates label_0543: // Incoming jump from 0x053E, if !msg.value 0543 5B JUMPDEST 0544 50 POP 0545 61 PUSH2 0x0296 0548 61 PUSH2 0x0d17 054B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0545 stack[-1] = 0x0296 } // Block ends with call to 0x0d17, returns to 0x0296 label_054C: // Incoming jump from 0x00C1, if 0x99a2557a == stack[-1] // Inputs[1] { @054D msg.value } 054C 5B JUMPDEST 054D 34 CALLVALUE 054E 80 DUP1 054F 15 ISZERO 0550 61 PUSH2 0x0558 0553 57 *JUMPI // Stack delta = +1 // Outputs[1] { @054D stack[0] = msg.value } // Block ends with conditional jump to 0x0558, if !msg.value label_0554: // Incoming jump from 0x0553, if not !msg.value // Inputs[1] { @0557 memory[0x00:0x00] } 0554 60 PUSH1 0x00 0556 80 DUP1 0557 FD *REVERT // Stack delta = +0 // Outputs[1] { @0557 revert(memory[0x00:0x00]); } // Block terminates label_0558: // Incoming jump from 0x0553, if !msg.value // Inputs[1] { @0560 msg.data.length } 0558 5B JUMPDEST 0559 50 POP 055A 61 PUSH2 0x050c 055D 61 PUSH2 0x0567 0560 36 CALLDATASIZE 0561 60 PUSH1 0x04 0563 61 PUSH2 0x21f2 0566 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @055A stack[-1] = 0x050c // @055D stack[0] = 0x0567 // @0560 stack[1] = msg.data.length // @0561 stack[2] = 0x04 // } // Block ends with call to 0x21f2, returns to 0x0567 label_0567: // Incoming return from call to 0x21F2 at 0x0566 0567 5B JUMPDEST 0568 61 PUSH2 0x0d26 056B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d26 label_056C: // Incoming jump from 0x00CC, if 0xa22cb465 == stack[-1] // Inputs[1] { @056D msg.value } 056C 5B JUMPDEST 056D 34 CALLVALUE 056E 80 DUP1 056F 15 ISZERO 0570 61 PUSH2 0x0578 0573 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056D stack[0] = msg.value } // Block ends with conditional jump to 0x0578, if !msg.value label_0574: // Incoming jump from 0x0573, if not !msg.value // Inputs[1] { @0577 memory[0x00:0x00] } 0574 60 PUSH1 0x00 0576 80 DUP1 0577 FD *REVERT // Stack delta = +0 // Outputs[1] { @0577 revert(memory[0x00:0x00]); } // Block terminates label_0578: // Incoming jump from 0x0573, if !msg.value // Inputs[1] { @0580 msg.data.length } 0578 5B JUMPDEST 0579 50 POP 057A 61 PUSH2 0x027f 057D 61 PUSH2 0x0587 0580 36 CALLDATASIZE 0581 60 PUSH1 0x04 0583 61 PUSH2 0x2233 0586 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @057A stack[-1] = 0x027f // @057D stack[0] = 0x0587 // @0580 stack[1] = msg.data.length // @0581 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x2233 0587 5B JUMPDEST 0588 61 PUSH2 0x0d33 058B 56 *JUMP label_058C: // Incoming jump from 0x00D7, if 0xb467e43a == stack[-1] // Inputs[1] { @058D msg.value } 058C 5B JUMPDEST 058D 34 CALLVALUE 058E 80 DUP1 058F 15 ISZERO 0590 61 PUSH2 0x0598 0593 57 *JUMPI // Stack delta = +1 // Outputs[1] { @058D stack[0] = msg.value } // Block ends with conditional jump to 0x0598, if !msg.value label_0594: // Incoming jump from 0x0593, if not !msg.value // Inputs[1] { @0597 memory[0x00:0x00] } 0594 60 PUSH1 0x00 0596 80 DUP1 0597 FD *REVERT // Stack delta = +0 // Outputs[1] { @0597 revert(memory[0x00:0x00]); } // Block terminates label_0598: // Incoming jump from 0x0593, if !msg.value // Inputs[1] { @059C storage[0x0f] } 0598 5B JUMPDEST 0599 50 POP 059A 60 PUSH1 0x0f 059C 54 SLOAD 059D 61 PUSH2 0x05ad 05A0 90 SWAP1 05A1 60 PUSH1 0x01 05A3 60 PUSH1 0x48 05A5 1B SHL 05A6 90 SWAP1 05A7 04 DIV 05A8 60 PUSH1 0xff 05AA 16 AND 05AB 81 DUP2 05AC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @05A0 stack[-1] = 0x05ad // @05AA stack[0] = 0xff & storage[0x0f] / (0x01 << 0x48) // } // Block ends with unconditional jump to 0x05ad label_05AD: // Incoming jump from 0x05AC // Incoming jump from 0x06CA // Inputs[2] // { // @05B0 memory[0x40:0x60] // @05B4 stack[-1] // } 05AD 5B JUMPDEST 05AE 60 PUSH1 0x40 05B0 51 MLOAD 05B1 60 PUSH1 0xff 05B3 90 SWAP1 05B4 91 SWAP2 05B5 16 AND 05B6 81 DUP2 05B7 52 MSTORE 05B8 60 PUSH1 0x20 05BA 01 ADD 05BB 61 PUSH2 0x0256 05BE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @05B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & 0xff // @05BA stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0256 label_05BF: // Incoming jump from 0x00E2, if 0xb88d4fde == stack[-1] // Inputs[1] { @05C6 msg.data.length } 05BF 5B JUMPDEST 05C0 61 PUSH2 0x027f 05C3 61 PUSH2 0x05cd 05C6 36 CALLDATASIZE 05C7 60 PUSH1 0x04 05C9 61 PUSH2 0x225f 05CC 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @05C0 stack[0] = 0x027f // @05C3 stack[1] = 0x05cd // @05C6 stack[2] = msg.data.length // @05C7 stack[3] = 0x04 // } // Block ends with call to 0x225f, returns to 0x05CD label_05CD: // Incoming return from call to 0x225F at 0x05CC 05CD 5B JUMPDEST 05CE 61 PUSH2 0x0d47 05D1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d47 label_05D2: // Incoming jump from 0x00ED, if 0xba70732b == stack[-1] // Inputs[1] { @05D3 msg.value } 05D2 5B JUMPDEST 05D3 34 CALLVALUE 05D4 80 DUP1 05D5 15 ISZERO 05D6 61 PUSH2 0x05de 05D9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05D3 stack[0] = msg.value } // Block ends with conditional jump to 0x05de, if !msg.value label_05DA: // Incoming jump from 0x05D9, if not !msg.value // Inputs[1] { @05DD memory[0x00:0x00] } 05DA 60 PUSH1 0x00 05DC 80 DUP1 05DD FD *REVERT // Stack delta = +0 // Outputs[1] { @05DD revert(memory[0x00:0x00]); } // Block terminates label_05DE: // Incoming jump from 0x05D9, if !msg.value // Inputs[1] { @05E6 msg.data.length } 05DE 5B JUMPDEST 05DF 50 POP 05E0 61 PUSH2 0x027f 05E3 61 PUSH2 0x05ed 05E6 36 CALLDATASIZE 05E7 60 PUSH1 0x04 05E9 61 PUSH2 0x22c6 05EC 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05E0 stack[-1] = 0x027f // @05E3 stack[0] = 0x05ed // @05E6 stack[1] = msg.data.length // @05E7 stack[2] = 0x04 // } // Block ends with call to 0x22c6, returns to 0x05ED label_05ED: // Incoming return from call to 0x22C6 at 0x05EC 05ED 5B JUMPDEST 05EE 61 PUSH2 0x0d74 05F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d74 label_05F2: // Incoming jump from 0x007A, if 0xbac426d0 == stack[-1] // Inputs[1] { @05F3 msg.value } 05F2 5B JUMPDEST 05F3 34 CALLVALUE 05F4 80 DUP1 05F5 15 ISZERO 05F6 61 PUSH2 0x05fe 05F9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F3 stack[0] = msg.value } // Block ends with conditional jump to 0x05fe, if !msg.value label_05FA: // Incoming jump from 0x05F9, if not !msg.value // Inputs[1] { @05FD memory[0x00:0x00] } 05FA 60 PUSH1 0x00 05FC 80 DUP1 05FD FD *REVERT // Stack delta = +0 // Outputs[1] { @05FD revert(memory[0x00:0x00]); } // Block terminates label_05FE: // Incoming jump from 0x05F9, if !msg.value // Inputs[1] { @0606 msg.data.length } 05FE 5B JUMPDEST 05FF 50 POP 0600 61 PUSH2 0x027f 0603 61 PUSH2 0x060d 0606 36 CALLDATASIZE 0607 60 PUSH1 0x04 0609 61 PUSH2 0x219f 060C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0600 stack[-1] = 0x027f // @0603 stack[0] = 0x060d // @0606 stack[1] = msg.data.length // @0607 stack[2] = 0x04 // } // Block ends with call to 0x219f, returns to 0x060D label_060D: // Incoming return from call to 0x219F at 0x060C 060D 5B JUMPDEST 060E 61 PUSH2 0x0dcb 0611 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0dcb label_0612: // Incoming jump from 0x0085, if 0xc23dc68f == stack[-1] // Inputs[1] { @0613 msg.value } 0612 5B JUMPDEST 0613 34 CALLVALUE 0614 80 DUP1 0615 15 ISZERO 0616 61 PUSH2 0x061e 0619 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0613 stack[0] = msg.value } // Block ends with conditional jump to 0x061e, if !msg.value label_061A: // Incoming jump from 0x0619, if not !msg.value // Inputs[1] { @061D memory[0x00:0x00] } 061A 60 PUSH1 0x00 061C 80 DUP1 061D FD *REVERT // Stack delta = +0 // Outputs[1] { @061D revert(memory[0x00:0x00]); } // Block terminates label_061E: // Incoming jump from 0x0619, if !msg.value // Inputs[1] { @0626 msg.data.length } 061E 5B JUMPDEST 061F 50 POP 0620 61 PUSH2 0x0632 0623 61 PUSH2 0x062d 0626 36 CALLDATASIZE 0627 60 PUSH1 0x04 0629 61 PUSH2 0x1ef2 062C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0620 stack[-1] = 0x0632 // @0623 stack[0] = 0x062d // @0626 stack[1] = msg.data.length // @0627 stack[2] = 0x04 // } // Block ends with call to 0x1ef2, returns to 0x062D label_062D: // Incoming return from call to 0x1EF2 at 0x062C 062D 5B JUMPDEST 062E 61 PUSH2 0x0e57 0631 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e57 label_0632: // Incoming return from call to 0x062D at 0x062C // Incoming return from call to 0x062D at 0x062C // Inputs[2] // { // @0635 memory[0x40:0x60] // @0639 stack[-1] // } 0632 5B JUMPDEST 0633 60 PUSH1 0x40 0635 51 MLOAD 0636 61 PUSH2 0x0256 0639 91 SWAP2 063A 90 SWAP1 063B 61 PUSH2 0x230e 063E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0639 stack[-1] = 0x0256 // @063A stack[1] = memory[0x40:0x60] // @063A stack[0] = stack[-1] // } // Block ends with call to 0x230e, returns to 0x0256 label_063F: // Incoming jump from 0x0090, if 0xc870c012 == stack[-1] // Inputs[1] { @0640 msg.value } 063F 5B JUMPDEST 0640 34 CALLVALUE 0641 80 DUP1 0642 15 ISZERO 0643 61 PUSH2 0x064b 0646 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0640 stack[0] = msg.value } // Block ends with conditional jump to 0x064b, if !msg.value label_0647: // Incoming jump from 0x0646, if not !msg.value // Inputs[1] { @064A memory[0x00:0x00] } 0647 60 PUSH1 0x00 0649 80 DUP1 064A FD *REVERT // Stack delta = +0 // Outputs[1] { @064A revert(memory[0x00:0x00]); } // Block terminates label_064B: // Incoming jump from 0x0646, if !msg.value // Inputs[1] { @0653 msg.data.length } 064B 5B JUMPDEST 064C 50 POP 064D 61 PUSH2 0x027f 0650 61 PUSH2 0x065a 0653 36 CALLDATASIZE 0654 60 PUSH1 0x04 0656 61 PUSH2 0x22c6 0659 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @064D stack[-1] = 0x027f // @0650 stack[0] = 0x065a // @0653 stack[1] = msg.data.length // @0654 stack[2] = 0x04 // } // Block ends with call to 0x22c6, returns to 0x065A label_065A: // Incoming return from call to 0x22C6 at 0x0659 065A 5B JUMPDEST 065B 61 PUSH2 0x0ebc 065E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ebc label_065F: // Incoming jump from 0x009B, if 0xc87b56dd == stack[-1] // Inputs[1] { @0660 msg.value } 065F 5B JUMPDEST 0660 34 CALLVALUE 0661 80 DUP1 0662 15 ISZERO 0663 61 PUSH2 0x066b 0666 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0660 stack[0] = msg.value } // Block ends with conditional jump to 0x066b, if !msg.value label_0667: // Incoming jump from 0x0666, if not !msg.value // Inputs[1] { @066A memory[0x00:0x00] } 0667 60 PUSH1 0x00 0669 80 DUP1 066A FD *REVERT // Stack delta = +0 // Outputs[1] { @066A revert(memory[0x00:0x00]); } // Block terminates label_066B: // Incoming jump from 0x0666, if !msg.value // Inputs[1] { @0673 msg.data.length } 066B 5B JUMPDEST 066C 50 POP 066D 61 PUSH2 0x0296 0670 61 PUSH2 0x067a 0673 36 CALLDATASIZE 0674 60 PUSH1 0x04 0676 61 PUSH2 0x1ef2 0679 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @066D stack[-1] = 0x0296 // @0670 stack[0] = 0x067a // @0673 stack[1] = msg.data.length // @0674 stack[2] = 0x04 // } // Block ends with call to 0x1ef2, returns to 0x067A label_067A: // Incoming return from call to 0x1EF2 at 0x0679 067A 5B JUMPDEST 067B 61 PUSH2 0x0f13 067E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f13 label_067F: // Incoming jump from 0x00A6, if 0xd5abeb01 == stack[-1] // Inputs[1] { @0680 msg.value } 067F 5B JUMPDEST 0680 34 CALLVALUE 0681 80 DUP1 0682 15 ISZERO 0683 61 PUSH2 0x068b 0686 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0680 stack[0] = msg.value } // Block ends with conditional jump to 0x068b, if !msg.value label_0687: // Incoming jump from 0x0686, if not !msg.value // Inputs[1] { @068A memory[0x00:0x00] } 0687 60 PUSH1 0x00 0689 80 DUP1 068A FD *REVERT // Stack delta = +0 // Outputs[1] { @068A revert(memory[0x00:0x00]); } // Block terminates label_068B: // Incoming jump from 0x0686, if !msg.value // Inputs[1] { @0692 storage[0x0b] } 068B 5B JUMPDEST 068C 50 POP 068D 61 PUSH2 0x0340 0690 60 PUSH1 0x0b 0692 54 SLOAD 0693 81 DUP2 0694 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @068D stack[-1] = 0x0340 // @0692 stack[0] = storage[0x0b] // } // Block ends with unconditional jump to 0x0340 label_0695: // Incoming jump from 0x003E, if 0xe36b0b37 == stack[-1] // Inputs[1] { @0696 msg.value } 0695 5B JUMPDEST 0696 34 CALLVALUE 0697 80 DUP1 0698 15 ISZERO 0699 61 PUSH2 0x06a1 069C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0696 stack[0] = msg.value } // Block ends with conditional jump to 0x06a1, if !msg.value label_069D: // Incoming jump from 0x069C, if not !msg.value // Inputs[1] { @06A0 memory[0x00:0x00] } 069D 60 PUSH1 0x00 069F 80 DUP1 06A0 FD *REVERT // Stack delta = +0 // Outputs[1] { @06A0 revert(memory[0x00:0x00]); } // Block terminates label_06A1: // Incoming jump from 0x069C, if !msg.value 06A1 5B JUMPDEST 06A2 50 POP 06A3 61 PUSH2 0x027f 06A6 61 PUSH2 0x0f6d 06A9 56 *JUMP // Stack delta = +0 // Outputs[1] { @06A3 stack[-1] = 0x027f } // Block ends with call to 0x0f6d, returns to 0x027F label_06AA: // Incoming jump from 0x0049, if 0xe4f2487a == stack[-1] // Inputs[1] { @06AB msg.value } 06AA 5B JUMPDEST 06AB 34 CALLVALUE 06AC 80 DUP1 06AD 15 ISZERO 06AE 61 PUSH2 0x06b6 06B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06AB stack[0] = msg.value } // Block ends with conditional jump to 0x06b6, if !msg.value label_06B2: // Incoming jump from 0x06B1, if not !msg.value // Inputs[1] { @06B5 memory[0x00:0x00] } 06B2 60 PUSH1 0x00 06B4 80 DUP1 06B5 FD *REVERT // Stack delta = +0 // Outputs[1] { @06B5 revert(memory[0x00:0x00]); } // Block terminates label_06B6: // Incoming jump from 0x06B1, if !msg.value // Inputs[1] { @06BA storage[0x0f] } 06B6 5B JUMPDEST 06B7 50 POP 06B8 60 PUSH1 0x0f 06BA 54 SLOAD 06BB 61 PUSH2 0x05ad 06BE 90 SWAP1 06BF 60 PUSH1 0x01 06C1 60 PUSH1 0x40 06C3 1B SHL 06C4 90 SWAP1 06C5 04 DIV 06C6 60 PUSH1 0xff 06C8 16 AND 06C9 81 DUP2 06CA 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @06BE stack[-1] = 0x05ad // @06C8 stack[0] = 0xff & storage[0x0f] / (0x01 << 0x40) // } // Block ends with unconditional jump to 0x05ad label_06CB: // Incoming jump from 0x0054, if 0xe6d37b88 == stack[-1] // Inputs[1] { @06D2 msg.data.length } 06CB 5B JUMPDEST 06CC 61 PUSH2 0x027f 06CF 61 PUSH2 0x06d9 06D2 36 CALLDATASIZE 06D3 60 PUSH1 0x04 06D5 61 PUSH2 0x231c 06D8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @06CC stack[0] = 0x027f // @06CF stack[1] = 0x06d9 // @06D2 stack[2] = msg.data.length // @06D3 stack[3] = 0x04 // } // Block ends with call to 0x231c, returns to 0x06D9 label_06D9: // Incoming return from call to 0x231C at 0x06D8 06D9 5B JUMPDEST 06DA 61 PUSH2 0x0fec 06DD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0fec label_06DE: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @06DF msg.value } 06DE 5B JUMPDEST 06DF 34 CALLVALUE 06E0 80 DUP1 06E1 15 ISZERO 06E2 61 PUSH2 0x06ea 06E5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06DF stack[0] = msg.value } // Block ends with conditional jump to 0x06ea, if !msg.value label_06E6: // Incoming jump from 0x06E5, if not !msg.value // Inputs[1] { @06E9 memory[0x00:0x00] } 06E6 60 PUSH1 0x00 06E8 80 DUP1 06E9 FD *REVERT // Stack delta = +0 // Outputs[1] { @06E9 revert(memory[0x00:0x00]); } // Block terminates label_06EA: // Incoming jump from 0x06E5, if !msg.value // Inputs[1] { @06F2 msg.data.length } 06EA 5B JUMPDEST 06EB 50 POP 06EC 61 PUSH2 0x024a 06EF 61 PUSH2 0x06f9 06F2 36 CALLDATASIZE 06F3 60 PUSH1 0x04 06F5 61 PUSH2 0x236e 06F8 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @06EC stack[-1] = 0x024a // @06EF stack[0] = 0x06f9 // @06F2 stack[1] = msg.data.length // @06F3 stack[2] = 0x04 // } // Block ends with call to 0x236e, returns to 0x06F9 label_06F9: // Incoming return from call to 0x236E at 0x06F8 // Incoming call from 0x1410, returns to 0x1411 // Inputs[6] // { // @0702 stack[-2] // @0715 memory[0x00:0x40] // @0716 stack[-1] // @0720 memory[0x00:0x40] // @0721 storage[keccak256(memory[0x00:0x40])] // @0725 stack[-3] // } 06F9 5B JUMPDEST 06FA 60 PUSH1 0x01 06FC 60 PUSH1 0x01 06FE 60 PUSH1 0xa0 0700 1B SHL 0701 03 SUB 0702 91 SWAP2 0703 82 DUP3 0704 16 AND 0705 60 PUSH1 0x00 0707 90 SWAP1 0708 81 DUP2 0709 52 MSTORE 070A 60 PUSH1 0x08 070C 60 PUSH1 0x20 070E 90 SWAP1 070F 81 DUP2 0710 52 MSTORE 0711 60 PUSH1 0x40 0713 80 DUP1 0714 83 DUP4 0715 20 SHA3 0716 93 SWAP4 0717 90 SWAP1 0718 94 SWAP5 0719 16 AND 071A 82 DUP3 071B 52 MSTORE 071C 91 SWAP2 071D 90 SWAP1 071E 91 SWAP2 071F 52 MSTORE 0720 20 SHA3 0721 54 SLOAD 0722 60 PUSH1 0xff 0724 16 AND 0725 90 SWAP1 0726 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @0709 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0710 memory[0x20:0x40] = 0x08 // @071B memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @071F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0725 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0727: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @0728 msg.value } 0727 5B JUMPDEST 0728 34 CALLVALUE 0729 80 DUP1 072A 15 ISZERO 072B 61 PUSH2 0x0733 072E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0728 stack[0] = msg.value } // Block ends with conditional jump to 0x0733, if !msg.value label_072F: // Incoming jump from 0x072E, if not !msg.value // Inputs[1] { @0732 memory[0x00:0x00] } 072F 60 PUSH1 0x00 0731 80 DUP1 0732 FD *REVERT // Stack delta = +0 // Outputs[1] { @0732 revert(memory[0x00:0x00]); } // Block terminates label_0733: // Incoming jump from 0x072E, if !msg.value // Inputs[1] { @073B msg.data.length } 0733 5B JUMPDEST 0734 50 POP 0735 61 PUSH2 0x027f 0738 61 PUSH2 0x0742 073B 36 CALLDATASIZE 073C 60 PUSH1 0x04 073E 61 PUSH2 0x219f 0741 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0735 stack[-1] = 0x027f // @0738 stack[0] = 0x0742 // @073B stack[1] = msg.data.length // @073C stack[2] = 0x04 // } // Block ends with call to 0x219f, returns to 0x0742 label_0742: // Incoming return from call to 0x219F at 0x0741 0742 5B JUMPDEST 0743 61 PUSH2 0x103c 0746 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x103c label_0747: // Incoming jump from 0x0249 // Inputs[1] { @074D stack[-1] } 0747 5B JUMPDEST 0748 60 PUSH1 0x00 074A 61 PUSH2 0x0752 074D 82 DUP3 074E 61 PUSH2 0x10ba 0751 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0748 stack[0] = 0x00 // @074A stack[1] = 0x0752 // @074D stack[2] = stack[-1] // } // Block ends with call to 0x10ba, returns to 0x0752 label_0752: // Incoming return from call to 0x10BA at 0x0751 // Inputs[1] { @0753 stack[-1] } 0752 5B JUMPDEST 0753 80 DUP1 0754 61 PUSH2 0x0761 0757 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0761, if stack[-1] label_0758: // Incoming jump from 0x0757, if not stack[-1] // Inputs[1] { @075C stack[-3] } 0758 50 POP 0759 61 PUSH2 0x0761 075C 82 DUP3 075D 61 PUSH2 0x1108 0760 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0759 stack[-1] = 0x0761 // @075C stack[0] = stack[-3] // } // Block ends with call to 0x1108, returns to 0x0761 label_0761: // Incoming jump from 0x244E, if !(stack[-1] > stack[-2] + stack[-1]) // Incoming jump from 0x1123, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming return from call to 0x1108 at 0x0760 // Incoming return from call to 0x15CB at 0x0C23 // Incoming jump from 0x2419, if (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] // Incoming return from call to 0x186F at 0x0EB6 // Incoming jump from 0x113C // Incoming jump from 0x10F0, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x10F0, if stack[-1] // Incoming return from call to 0x2121 at 0x231B // Incoming jump from 0x18EC // Incoming jump from 0x0757, if stack[-1] // Incoming jump from 0x2402, if !((0xff & stack[-2]) + (0xff & stack[-1]) > 0xff) // Inputs[3] // { // @0762 stack[-4] // @0762 stack[-1] // @0763 stack[-3] // } 0761 5B JUMPDEST 0762 92 SWAP3 0763 91 SWAP2 0764 50 POP 0765 50 POP 0766 56 *JUMP // Stack delta = -3 // Outputs[1] { @0762 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_0767: // Incoming jump from 0x027E 0767 5B JUMPDEST 0768 61 PUSH2 0x076f 076B 61 PUSH2 0x113d 076E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0768 stack[0] = 0x076f } // Block ends with call to 0x113d, returns to 0x076F label_076F: // Incoming return from call to 0x113D at 0x076E // Inputs[2] // { // @0773 stack[-2] // @0774 stack[-1] // } 076F 5B JUMPDEST 0770 61 PUSH2 0x0779 0773 82 DUP3 0774 82 DUP3 0775 61 PUSH2 0x1197 0778 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0770 stack[0] = 0x0779 // @0773 stack[1] = stack[-2] // @0774 stack[2] = stack[-1] // } // Block ends with call to 0x1197, returns to 0x0779 label_0779: // Incoming return from call to 0x1197 at 0x0778 // Incoming return from call to 0x249C at 0x0DCA // Incoming return from call to 0x249C at 0x0F12 // Inputs[1] { @077C stack[-3] } 0779 5B JUMPDEST 077A 50 POP 077B 50 POP 077C 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_077D: // Incoming call from 0x0295, returns to 0x0296 // Inputs[1] { @0783 storage[0x03] } 077D 5B JUMPDEST 077E 60 PUSH1 0x60 0780 60 PUSH1 0x03 0782 80 DUP1 0783 54 SLOAD 0784 61 PUSH2 0x078c 0787 90 SWAP1 0788 61 PUSH2 0x23a1 078B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @077E stack[0] = 0x60 // @0780 stack[1] = 0x03 // @0787 stack[2] = 0x078c // @0787 stack[3] = storage[0x03] // } // Block ends with call to 0x23a1, returns to 0x078C label_078C: // Incoming return from call to 0x23A1 at 0x078B // Incoming return from call to 0x23A1 at 0x1D36 // Incoming return from call to 0x23A1 at 0x0D25 // Inputs[4] // { // @078D stack[-1] // @079C memory[0x40:0x60] // @07A4 stack[-2] // @07AF storage[stack[-2]] // } 078C 5B JUMPDEST 078D 80 DUP1 078E 60 PUSH1 0x1f 0790 01 ADD 0791 60 PUSH1 0x20 0793 80 DUP1 0794 91 SWAP2 0795 04 DIV 0796 02 MUL 0797 60 PUSH1 0x20 0799 01 ADD 079A 60 PUSH1 0x40 079C 51 MLOAD 079D 90 SWAP1 079E 81 DUP2 079F 01 ADD 07A0 60 PUSH1 0x40 07A2 52 MSTORE 07A3 80 DUP1 07A4 92 SWAP3 07A5 91 SWAP2 07A6 90 SWAP1 07A7 81 DUP2 07A8 81 DUP2 07A9 52 MSTORE 07AA 60 PUSH1 0x20 07AC 01 ADD 07AD 82 DUP3 07AE 80 DUP1 07AF 54 SLOAD 07B0 61 PUSH2 0x07b8 07B3 90 SWAP1 07B4 61 PUSH2 0x23a1 07B7 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @07A2 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @07A4 stack[-2] = memory[0x40:0x60] // @07A5 stack[-1] = stack[-2] // @07A6 stack[0] = stack[-1] // @07A9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @07AC stack[1] = 0x20 + memory[0x40:0x60] // @07AD stack[2] = stack[-2] // @07B3 stack[4] = storage[stack[-2]] // @07B3 stack[3] = 0x07b8 // } // Block ends with call to 0x23a1, returns to 0x07B8 label_07B8: // Incoming return from call to 0x23A1 at 0x07B7 // Inputs[1] { @07B9 stack[-1] } 07B8 5B JUMPDEST 07B9 80 DUP1 07BA 15 ISZERO 07BB 61 PUSH2 0x0805 07BE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0805, if !stack[-1] label_07BF: // Incoming jump from 0x07BE, if not !stack[-1] // Inputs[1] { @07BF stack[-1] } 07BF 80 DUP1 07C0 60 PUSH1 0x1f 07C2 10 LT 07C3 61 PUSH2 0x07da 07C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07da, if 0x1f < stack[-1] label_07C7: // Incoming jump from 0x07C6, if not 0x1f < stack[-1] // Inputs[4] // { // @07CB stack[-2] // @07CC storage[stack[-2]] // @07CF stack[-3] // @07D1 stack[-1] // } 07C7 61 PUSH2 0x0100 07CA 80 DUP1 07CB 83 DUP4 07CC 54 SLOAD 07CD 04 DIV 07CE 02 MUL 07CF 83 DUP4 07D0 52 MSTORE 07D1 91 SWAP2 07D2 60 PUSH1 0x20 07D4 01 ADD 07D5 91 SWAP2 07D6 61 PUSH2 0x0805 07D9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @07D0 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @07D5 stack[-1] = stack[-1] // @07D5 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x0805 label_07DA: // Incoming jump from 0x07C6, if 0x1f < stack[-1] // Inputs[5] // { // @07DB stack[-3] // @07DC stack[-1] // @07DE stack[-2] // @07E6 memory[0x00:0x20] // @07EA storage[keccak256(memory[0x00:0x20])] // } 07DA 5B JUMPDEST 07DB 82 DUP3 07DC 01 ADD 07DD 91 SWAP2 07DE 90 SWAP1 07DF 60 PUSH1 0x00 07E1 52 MSTORE 07E2 60 PUSH1 0x20 07E4 60 PUSH1 0x00 07E6 20 SHA3 07E7 90 SWAP1 07E8 5B JUMPDEST 07E9 81 DUP2 07EA 54 SLOAD 07EB 81 DUP2 07EC 52 MSTORE 07ED 90 SWAP1 07EE 60 PUSH1 0x01 07F0 01 ADD 07F1 90 SWAP1 07F2 60 PUSH1 0x20 07F4 01 ADD 07F5 80 DUP1 07F6 83 DUP4 07F7 11 GT 07F8 61 PUSH2 0x07e8 07FB 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @07DD stack[-3] = stack[-3] + stack[-1] // @07E1 memory[0x00:0x20] = stack[-2] // @07EC memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @07F1 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @07F4 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x07e8, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_07FC: // Incoming jump from 0x07FB, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x07FB, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @07FC stack[-3] // @07FD stack[-1] // } 07FC 82 DUP3 07FD 90 SWAP1 07FE 03 SUB 07FF 60 PUSH1 0x1f 0801 16 AND 0802 82 DUP3 0803 01 ADD 0804 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @0804 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @0804 stack[-1] = stack[-3] // } // Block continues label_0805: // Incoming jump from 0x0804 // Incoming jump from 0x07D9 // Incoming jump from 0x07BE, if !stack[-1] // Inputs[3] // { // @080B stack[-7] // @080B stack[-6] // @080D stack[-8] // } 0805 5B JUMPDEST 0806 50 POP 0807 50 POP 0808 50 POP 0809 50 POP 080A 50 POP 080B 90 SWAP1 080C 50 POP 080D 90 SWAP1 080E 56 *JUMP // Stack delta = -7 // Outputs[1] { @080D stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_080F: // Incoming jump from 0x02C2 // Inputs[1] { @0815 stack[-1] } 080F 5B JUMPDEST 0810 60 PUSH1 0x00 0812 61 PUSH2 0x081a 0815 82 DUP3 0816 61 PUSH2 0x1294 0819 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0810 stack[0] = 0x00 // @0812 stack[1] = 0x081a // @0815 stack[2] = stack[-1] // } // Block ends with call to 0x1294, returns to 0x081A label_081A: // Incoming return from call to 0x1294 at 0x0819 // Inputs[1] { @081E stack[-1] } 081A 5B JUMPDEST 081B 61 PUSH2 0x082e 081E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x082e, if stack[-1] label_081F: // Incoming jump from 0x081E, if not stack[-1] 081F 61 PUSH2 0x082e 0822 63 PUSH4 0x33d1c039 0827 60 PUSH1 0xe2 0829 1B SHL 082A 61 PUSH2 0x12e1 082D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @081F stack[0] = 0x082e // @0829 stack[1] = 0x33d1c039 << 0xe2 // } // Block ends with unconditional jump to 0x12e1 label_082E: // Incoming jump from 0x081E, if stack[-1] // Inputs[4] // { // @0832 stack[-2] // @083D memory[0x00:0x40] // @083E storage[keccak256(memory[0x00:0x40])] // @0848 stack[-3] // } 082E 5B JUMPDEST 082F 50 POP 0830 60 PUSH1 0x00 0832 90 SWAP1 0833 81 DUP2 0834 52 MSTORE 0835 60 PUSH1 0x07 0837 60 PUSH1 0x20 0839 52 MSTORE 083A 60 PUSH1 0x40 083C 90 SWAP1 083D 20 SHA3 083E 54 SLOAD 083F 60 PUSH1 0x01 0841 60 PUSH1 0x01 0843 60 PUSH1 0xa0 0845 1B SHL 0846 03 SUB 0847 16 AND 0848 90 SWAP1 0849 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0834 memory[0x00:0x20] = stack[-2] // @0839 memory[0x20:0x40] = 0x07 // @0848 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] 084A 5B JUMPDEST 084B 81 DUP2 084C 61 PUSH2 0x0854 084F 81 DUP2 0850 61 PUSH2 0x12eb 0853 56 *JUMP 0854 5B JUMPDEST 0855 61 PUSH2 0x085e 0858 83 DUP4 0859 83 DUP4 085A 61 PUSH2 0x13a4 085D 56 *JUMP label_085E: // Incoming jump from 0x245F, if !(stack[-2] > 0x1f) // Inputs[1] { @0862 stack[-4] } 085E 5B JUMPDEST 085F 50 POP 0860 50 POP 0861 50 POP 0862 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0863: // Incoming jump from 0x036D // Inputs[2] // { // @0866 storage[0x00] // @0870 msg.sender // } 0863 5B JUMPDEST 0864 60 PUSH1 0x00 0866 54 SLOAD 0867 60 PUSH1 0x01 0869 60 PUSH1 0x01 086B 60 PUSH1 0xa0 086D 1B SHL 086E 03 SUB 086F 16 AND 0870 33 CALLER 0871 14 EQ 0872 80 DUP1 0873 15 ISZERO 0874 90 SWAP1 0875 61 PUSH2 0x0890 0878 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0874 stack[0] = !(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00]) } // Block ends with conditional jump to 0x0890, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0879: // Incoming jump from 0x0878, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[2] // { // @087C storage[0x0f] // @088D msg.sender // } 0879 50 POP 087A 60 PUSH1 0x0f 087C 54 SLOAD 087D 60 PUSH1 0x01 087F 60 PUSH1 0x50 0881 1B SHL 0882 90 SWAP1 0883 04 DIV 0884 60 PUSH1 0x01 0886 60 PUSH1 0x01 0888 60 PUSH1 0xa0 088A 1B SHL 088B 03 SUB 088C 16 AND 088D 33 CALLER 088E 14 EQ 088F 15 ISZERO 0890 5B JUMPDEST 0891 15 ISZERO 0892 61 PUSH2 0x08ae 0895 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x08ae, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) label_0896: // Incoming jump from 0x0895, if not !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Incoming jump from 0x0895, if not !stack[-1] // Inputs[3] // { // @0898 memory[0x40:0x60] // @08A8 memory[0x40:0x60] // @08AD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0896 60 PUSH1 0x40 0898 51 MLOAD 0899 63 PUSH4 0x3b12fc63 089E 60 PUSH1 0xe2 08A0 1B SHL 08A1 81 DUP2 08A2 52 MSTORE 08A3 60 PUSH1 0x04 08A5 01 ADD 08A6 60 PUSH1 0x40 08A8 51 MLOAD 08A9 80 DUP1 08AA 91 SWAP2 08AB 03 SUB 08AC 90 SWAP1 08AD FD *REVERT // Stack delta = +0 // Outputs[2] // { // @08A2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b12fc63 << 0xe2 // @08AD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_08AE: // Incoming jump from 0x0895, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Incoming jump from 0x0895, if !stack[-1] // Inputs[1] { @08B1 storage[0x0f] } 08AE 5B JUMPDEST 08AF 60 PUSH1 0x0f 08B1 54 SLOAD 08B2 60 PUSH1 0x01 08B4 60 PUSH1 0x40 08B6 1B SHL 08B7 90 SWAP1 08B8 04 DIV 08B9 60 PUSH1 0xff 08BB 16 AND 08BC 60 PUSH1 0x00 08BE 03 SUB 08BF 61 PUSH2 0x08f9 08C2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x08f9, if 0x00 - (0xff & storage[0x0f] / (0x01 << 0x40)) label_08C3: // Incoming jump from 0x08C2, if not 0x00 - (0xff & storage[0x0f] / (0x01 << 0x40)) // Inputs[1] { @08C5 storage[0x0f] } 08C3 60 PUSH1 0x0f 08C5 54 SLOAD 08C6 61 PUSH2 0x08da 08C9 90 SWAP1 08CA 60 PUSH1 0x01 08CC 60 PUSH1 0x48 08CE 1B SHL 08CF 90 SWAP1 08D0 04 DIV 08D1 60 PUSH1 0xff 08D3 16 AND 08D4 60 PUSH1 0x01 08D6 61 PUSH2 0x23f1 08D9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @08C9 stack[0] = 0x08da // @08D3 stack[1] = 0xff & storage[0x0f] / (0x01 << 0x48) // @08D4 stack[2] = 0x01 // } // Block ends with call to 0x23f1, returns to 0x08DA label_08DA: // Incoming return from call to 0x23F1 at 0x08D9 // Inputs[2] // { // @08E4 storage[0x0f] // @08EC stack[-1] // } 08DA 5B JUMPDEST 08DB 60 PUSH1 0x0f 08DD 60 PUSH1 0x08 08DF 61 PUSH2 0x0100 08E2 0A EXP 08E3 81 DUP2 08E4 54 SLOAD 08E5 81 DUP2 08E6 60 PUSH1 0xff 08E8 02 MUL 08E9 19 NOT 08EA 16 AND 08EB 90 SWAP1 08EC 83 DUP4 08ED 60 PUSH1 0xff 08EF 16 AND 08F0 02 MUL 08F1 17 OR 08F2 90 SWAP1 08F3 55 SSTORE 08F4 50 POP 08F5 61 PUSH2 0x092c 08F8 56 *JUMP // Stack delta = -1 // Outputs[1] { @08F3 storage[0x0f] = (0xff & stack[-1]) * 0x0100 ** 0x08 | (~(0xff * 0x0100 ** 0x08) & storage[0x0f]) } // Block ends with unconditional jump to 0x092c label_08F9: // Incoming jump from 0x08C2, if 0x00 - (0xff & storage[0x0f] / (0x01 << 0x40)) // Inputs[1] { @08FC storage[0x0f] } 08F9 5B JUMPDEST 08FA 60 PUSH1 0x0f 08FC 54 SLOAD 08FD 61 PUSH2 0x0911 0900 90 SWAP1 0901 60 PUSH1 0x01 0903 60 PUSH1 0x40 0905 1B SHL 0906 90 SWAP1 0907 04 DIV 0908 60 PUSH1 0xff 090A 16 AND 090B 60 PUSH1 0x01 090D 61 PUSH2 0x23f1 0910 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0900 stack[0] = 0x0911 // @090A stack[1] = 0xff & storage[0x0f] / (0x01 << 0x40) // @090B stack[2] = 0x01 // } // Block ends with call to 0x23f1, returns to 0x0911 label_0911: // Incoming return from call to 0x23F1 at 0x0910 // Inputs[6] // { // @091B storage[0x0f] // @0923 stack[-1] // @092F stack[-2] // @0933 storage[0x0f] // @0947 stack[-3] // @0951 stack[-4] // } 0911 5B JUMPDEST 0912 60 PUSH1 0x0f 0914 60 PUSH1 0x08 0916 61 PUSH2 0x0100 0919 0A EXP 091A 81 DUP2 091B 54 SLOAD 091C 81 DUP2 091D 60 PUSH1 0xff 091F 02 MUL 0920 19 NOT 0921 16 AND 0922 90 SWAP1 0923 83 DUP4 0924 60 PUSH1 0xff 0926 16 AND 0927 02 MUL 0928 17 OR 0929 90 SWAP1 092A 55 SSTORE 092B 50 POP 092C 5B JUMPDEST 092D 60 PUSH1 0x0e 092F 55 SSTORE 0930 60 PUSH1 0x0f 0932 80 DUP1 0933 54 SLOAD 0934 67 PUSH8 0xffffffffffffffff 093D 19 NOT 093E 16 AND 093F 60 PUSH1 0x01 0941 60 PUSH1 0x01 0943 60 PUSH1 0x40 0945 1B SHL 0946 03 SUB 0947 92 SWAP3 0948 90 SWAP1 0949 92 SWAP3 094A 16 AND 094B 91 SWAP2 094C 90 SWAP1 094D 91 SWAP2 094E 17 OR 094F 90 SWAP1 0950 55 SSTORE 0951 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @092A storage[0x0f] = (0xff & stack[-1]) * 0x0100 ** 0x08 | (~(0xff * 0x0100 ** 0x08) & storage[0x0f]) // @092F storage[0x0e] = stack[-2] // @0950 storage[0x0f] = ((0x01 << 0x40) - 0x01 & stack[-3]) | (~0xffffffffffffffff & storage[0x0f]) // } // Block ends with unconditional jump to stack[-4] label_0952: // Incoming jump from 0x0380 // Incoming jump from 0x183E // Inputs[2] // { // @0953 stack[-3] // @095E msg.sender // } 0952 5B JUMPDEST 0953 82 DUP3 0954 60 PUSH1 0x01 0956 60 PUSH1 0x01 0958 60 PUSH1 0xa0 095A 1B SHL 095B 03 SUB 095C 81 DUP2 095D 16 AND 095E 33 CALLER 095F 14 EQ 0960 61 PUSH2 0x096c 0963 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0953 stack[0] = stack[-3] } // Block ends with conditional jump to 0x096c, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_0964: // Incoming jump from 0x0963, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0967 msg.sender } 0964 61 PUSH2 0x096c 0967 33 CALLER 0968 61 PUSH2 0x12eb 096B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0964 stack[0] = 0x096c // @0967 stack[1] = msg.sender // } // Block ends with call to 0x12eb, returns to 0x096C label_096C: // Incoming jump from 0x0963, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x12EB at 0x096B // Inputs[3] // { // @0970 stack[-4] // @0971 stack[-3] // @0972 stack[-2] // } 096C 5B JUMPDEST 096D 61 PUSH2 0x0977 0970 84 DUP5 0971 84 DUP5 0972 84 DUP5 0973 61 PUSH2 0x13b0 0976 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @096D stack[0] = 0x0977 // @0970 stack[1] = stack[-4] // @0971 stack[2] = stack[-3] // @0972 stack[3] = stack[-2] // } // Block ends with call to 0x13b0, returns to 0x0977 label_0977: // Incoming return from call to 0x151E at 0x103B // Incoming return from call to 0x13B0 at 0x0976 // Incoming jump from 0x19F2, if 0x00 - !!stack[-1] // Inputs[1] { @097C stack[-5] } 0977 5B JUMPDEST 0978 50 POP 0979 50 POP 097A 50 POP 097B 50 POP 097C 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_097D: // Incoming jump from 0x03A0 097D 5B JUMPDEST 097E 61 PUSH2 0x0985 0981 61 PUSH2 0x113d 0984 56 *JUMP // Stack delta = +1 // Outputs[1] { @097E stack[0] = 0x0985 } // Block ends with call to 0x113d, returns to 0x0985 label_0985: // Incoming return from call to 0x113D at 0x0984 // Inputs[3] // { // @0986 stack[-1] // @0987 memory[stack[-1]:stack[-1] + 0x20] // @098C storage[0x01] // } 0985 5B JUMPDEST 0986 80 DUP1 0987 51 MLOAD 0988 81 DUP2 0989 01 ADD 098A 60 PUSH1 0x01 098C 54 SLOAD 098D 80 DUP1 098E 61 PUSH2 0x059d 0991 10 LT 0992 15 ISZERO 0993 61 PUSH2 0x09a4 0996 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0989 stack[0] = stack[-1] + memory[stack[-1]:stack[-1] + 0x20] // @098C stack[1] = storage[0x01] // } // Block ends with conditional jump to 0x09a4, if !(0x059d < storage[0x01]) label_0997: // Incoming jump from 0x0996, if not !(0x059d < storage[0x01]) // Inputs[1] { @09A3 memory[0x1c:0x20] } 0997 63 PUSH4 0xe37dc650 099C 60 PUSH1 0x00 099E 52 MSTORE 099F 60 PUSH1 0x04 09A1 60 PUSH1 0x1c 09A3 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @099E memory[0x00:0x20] = 0xe37dc650 // @09A3 revert(memory[0x1c:0x20]); // } // Block terminates label_09A4: // Incoming jump from 0x0996, if !(0x059d < storage[0x01]) // Inputs[11] // { // @09A5 block.timestamp // @09B7 memory[0x40:0x60] // @09CC stack[-3] // @09D3 memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @09D9 stack[-1] // @09E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40] // @09F0 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x40] // @09F9 memory[0x00:0x20] // @0A02 memory[0x00:0x20] // @0A08 memory[0x00:0x00] // @0A0A stack[-2] // } 09A4 5B JUMPDEST 09A5 42 TIMESTAMP 09A6 60 PUSH1 0xa0 09A8 1C SHR 09A9 60 PUSH1 0x01 09AB 60 PUSH1 0xe1 09AD 1B SHL 09AE 60 PUSH1 0x01 09B0 80 DUP1 09B1 60 PUSH1 0x40 09B3 1B SHL 09B4 17 OR 09B5 60 PUSH1 0x40 09B7 51 MLOAD 09B8 60 PUSH1 0x40 09BA 81 DUP2 09BB 01 ADD 09BC 60 PUSH1 0x05 09BE 60 PUSH1 0x20 09C0 83 DUP4 09C1 01 ADD 09C2 52 MSTORE 09C3 60 PUSH1 0x06 09C5 60 PUSH1 0x20 09C7 82 DUP3 09C8 01 ADD 09C9 52 MSTORE 09CA 60 PUSH1 0x20 09CC 88 DUP9 09CD 01 ADD 09CE 60 PUSH1 0x00 09D0 80 DUP1 09D1 5B JUMPDEST 09D2 82 DUP3 09D3 51 MLOAD 09D4 60 PUSH1 0x60 09D6 1C SHR 09D7 91 SWAP2 09D8 50 POP 09D9 88 DUP9 09DA 85 DUP6 09DB 52 MSTORE 09DC 86 DUP7 09DD 88 DUP9 09DE 83 DUP4 09DF 17 OR 09E0 17 OR 09E1 90 SWAP1 09E2 50 POP 09E3 80 DUP1 09E4 60 PUSH1 0x40 09E6 86 DUP7 09E7 20 SHA3 09E8 55 SSTORE 09E9 81 DUP2 09EA 84 DUP5 09EB 52 MSTORE 09EC 85 DUP6 09ED 60 PUSH1 0x40 09EF 85 DUP6 09F0 20 SHA3 09F1 55 SSTORE 09F2 88 DUP9 09F3 82 DUP3 09F4 60 PUSH1 0x00 09F6 60 PUSH1 0x00 09F8 80 DUP1 09F9 51 MLOAD 09FA 60 PUSH1 0x20 09FC 61 PUSH2 0x26d5 09FF 83 DUP4 0A00 39 CODECOPY 0A01 81 DUP2 0A02 51 MLOAD 0A03 91 SWAP2 0A04 52 MSTORE 0A05 60 PUSH1 0x00 0A07 80 DUP1 0A08 A4 LOG4 0A09 82 DUP3 0A0A 8A DUP11 0A0B 10 LT 0A0C 61 PUSH2 0x0a20 0A0F 57 *JUMPI // Stack delta = +8 // Outputs[17] // { // @09A8 stack[0] = block.timestamp >> 0xa0 // @09AD stack[1] = 0x01 << 0xe1 // @09B4 stack[2] = (0x01 << 0x40) | 0x01 // @09B7 stack[3] = memory[0x40:0x60] // @09BB stack[4] = memory[0x40:0x60] + 0x40 // @09C2 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x05 // @09C9 memory[memory[0x40:0x60] + 0x40 + 0x20:memory[0x40:0x60] + 0x40 + 0x20 + 0x20] = 0x06 // @09CD stack[5] = stack[-3] + 0x20 // @09D7 stack[6] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] >> 0x60 // @09DB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @09E1 stack[7] = (memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] >> 0x60) | (block.timestamp >> 0xa0) | (0x01 << 0xe1) // @09E8 storage[keccak256(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x40])] = (memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] >> 0x60) | (block.timestamp >> 0xa0) | (0x01 << 0xe1) // @09EB memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] >> 0x60 // @09F1 storage[keccak256(memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x40])] = (0x01 << 0x40) | 0x01 // @0A00 memory[0x00:0x20] = code[0x26d5:0x26f5] // @0A04 memory[0x00:0x20] = memory[0x00:0x20] // @0A08 log(memory[0x00:0x00], [memory[0x00:0x20], 0x00, memory[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] >> 0x60, stack[-1]]); // } // Block ends with conditional jump to 0x0a20, if stack[-2] < stack[-3] + 0x20 label_0A10: // Incoming jump from 0x0A0F, if not stack[-10] < stack[-3] // Incoming jump from 0x0A0F, if not stack[-2] < stack[-3] + 0x20 // Inputs[2] // { // @0A12 stack[-3] // @0A18 stack[-9] // } 0A10 60 PUSH1 0x14 0A12 83 DUP4 0A13 01 ADD 0A14 92 SWAP3 0A15 50 POP 0A16 60 PUSH1 0x01 0A18 89 DUP10 0A19 01 ADD 0A1A 98 SWAP9 0A1B 50 POP 0A1C 61 PUSH2 0x09d1 0A1F 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0A14 stack[-3] = stack[-3] + 0x14 // @0A1A stack[-9] = stack[-9] + 0x01 // } // Block ends with unconditional jump to 0x09d1 label_0A20: // Incoming jump from 0x0A0F, if stack[-10] < stack[-3] // Incoming jump from 0x0A0F, if stack[-2] < stack[-3] + 0x20 // Inputs[10] // { // @0A24 msg.sender // @0A27 stack[-9] // @0A29 stack[-10] // @0A35 stack[-5] // @0A37 stack[-7] // @0A38 stack[-8] // @0A42 memory[stack[-5]:stack[-5] + 0x40] // @0A4B memory[0x00:0x20] // @0A54 memory[0x00:0x20] // @0A5A memory[0x00:0x00] // } 0A20 5B JUMPDEST 0A21 50 POP 0A22 50 POP 0A23 50 POP 0A24 33 CALLER 0A25 60 PUSH1 0x64 0A27 87 DUP8 0A28 01 ADD 0A29 97 SWAP8 0A2A 50 POP 0A2B 60 PUSH1 0x00 0A2D 5B JUMPDEST 0A2E 60 PUSH1 0x01 0A30 88 DUP9 0A31 01 ADD 0A32 97 SWAP8 0A33 50 POP 0A34 87 DUP8 0A35 84 DUP5 0A36 52 MSTORE 0A37 85 DUP6 0A38 87 DUP8 0A39 83 DUP4 0A3A 17 OR 0A3B 17 OR 0A3C 90 SWAP1 0A3D 50 POP 0A3E 80 DUP1 0A3F 60 PUSH1 0x40 0A41 85 DUP6 0A42 20 SHA3 0A43 55 SSTORE 0A44 87 DUP8 0A45 82 DUP3 0A46 60 PUSH1 0x00 0A48 60 PUSH1 0x00 0A4A 80 DUP1 0A4B 51 MLOAD 0A4C 60 PUSH1 0x20 0A4E 61 PUSH2 0x26d5 0A51 83 DUP4 0A52 39 CODECOPY 0A53 81 DUP2 0A54 51 MLOAD 0A55 91 SWAP2 0A56 52 MSTORE 0A57 60 PUSH1 0x00 0A59 80 DUP1 0A5A A4 LOG4 0A5B 88 DUP9 0A5C 88 DUP9 0A5D 03 SUB 0A5E 61 PUSH2 0x0a2d 0A61 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @0A24 stack[-3] = msg.sender // @0A29 stack[-10] = stack[-9] + 0x64 // @0A32 stack[-9] = stack[-9] + 0x01 // @0A36 memory[stack[-5]:stack[-5] + 0x20] = stack[-9] + 0x01 // @0A3C stack[-2] = msg.sender | stack[-8] | stack[-7] // @0A43 storage[keccak256(memory[stack[-5]:stack[-5] + 0x40])] = msg.sender | stack[-8] | stack[-7] // @0A52 memory[0x00:0x20] = code[0x26d5:0x26f5] // @0A56 memory[0x00:0x20] = memory[0x00:0x20] // @0A5A log(memory[0x00:0x00], [memory[0x00:0x20], 0x00, msg.sender, stack[-9] + 0x01]); // } // Block ends with conditional jump to 0x0a2d, if (stack[-9] + 0x01) - (stack[-9] + 0x64) label_0A62: // Incoming jump from 0x0A61, if not (stack[-9] + 0x01) - (stack[-9] + 0x64) // Incoming jump from 0x0A61, if not (stack[-8] + 0x01) - stack[-9] // Inputs[7] // { // @0A63 stack[-3] // @0A64 stack[-2] // @0A68 memory[stack[-3]:stack[-3] + 0x40] // @0A6B stack[-5] // @0A6F stack[-4] // @0A77 stack[-8] // @0A7E stack[-11] // } 0A62 50 POP 0A63 81 DUP2 0A64 52 MSTORE 0A65 60 PUSH1 0x40 0A67 90 SWAP1 0A68 20 SHA3 0A69 60 PUSH1 0x64 0A6B 92 SWAP3 0A6C 90 SWAP1 0A6D 92 SWAP3 0A6E 02 MUL 0A6F 90 SWAP1 0A70 91 SWAP2 0A71 55 SSTORE 0A72 50 POP 0A73 50 POP 0A74 50 POP 0A75 60 PUSH1 0x01 0A77 90 SWAP1 0A78 81 DUP2 0A79 01 ADD 0A7A 90 SWAP1 0A7B 55 SSTORE 0A7C 50 POP 0A7D 50 POP 0A7E 56 *JUMP // Stack delta = -11 // Outputs[3] // { // @0A64 memory[stack[-3]:stack[-3] + 0x20] = stack[-2] // @0A71 storage[keccak256(memory[stack[-3]:stack[-3] + 0x40])] = 0x64 * stack[-5] // @0A7B storage[0x01] = 0x01 + stack[-8] // } // Block ends with unconditional jump to stack[-11] label_0A7F: // Incoming jump from 0x03C0 // Inputs[4] // { // @0A82 stack[-2] // @0A90 memory[0x00:0x40] // @0A92 memory[0x40:0x60] // @0A99 storage[keccak256(memory[0x00:0x40])] // } 0A7F 5B JUMPDEST 0A80 60 PUSH1 0x00 0A82 82 DUP3 0A83 81 DUP2 0A84 52 MSTORE 0A85 60 PUSH1 0x0a 0A87 60 PUSH1 0x20 0A89 90 SWAP1 0A8A 81 DUP2 0A8B 52 MSTORE 0A8C 60 PUSH1 0x40 0A8E 80 DUP1 0A8F 83 DUP4 0A90 20 SHA3 0A91 81 DUP2 0A92 51 MLOAD 0A93 80 DUP1 0A94 83 DUP4 0A95 01 ADD 0A96 90 SWAP1 0A97 92 SWAP3 0A98 52 MSTORE 0A99 54 SLOAD 0A9A 60 PUSH1 0x01 0A9C 60 PUSH1 0x01 0A9E 60 PUSH1 0xa0 0AA0 1B SHL 0AA1 03 SUB 0AA2 81 DUP2 0AA3 16 AND 0AA4 80 DUP1 0AA5 83 DUP4 0AA6 52 MSTORE 0AA7 60 PUSH1 0x01 0AA9 60 PUSH1 0xa0 0AAB 1B SHL 0AAC 90 SWAP1 0AAD 91 SWAP2 0AAE 04 DIV 0AAF 60 PUSH1 0x01 0AB1 60 PUSH1 0x01 0AB3 60 PUSH1 0x60 0AB5 1B SHL 0AB6 03 SUB 0AB7 16 AND 0AB8 92 SWAP3 0AB9 82 DUP3 0ABA 01 ADD 0ABB 92 SWAP3 0ABC 90 SWAP1 0ABD 92 SWAP3 0ABE 52 MSTORE 0ABF 82 DUP3 0AC0 91 SWAP2 0AC1 61 PUSH2 0x0af4 0AC4 57 *JUMPI // Stack delta = +3 // Outputs[8] // { // @0A80 stack[0] = 0x00 // @0A84 memory[0x00:0x20] = stack[-2] // @0A8B memory[0x20:0x40] = 0x0a // @0A97 stack[2] = memory[0x40:0x60] // @0A98 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0AA6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @0ABE memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x60) - 0x01 & storage[keccak256(memory[0x00:0x40])] / (0x01 << 0xa0) // @0AC0 stack[1] = 0x00 // } // Block ends with conditional jump to 0x0af4, if storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 label_0AC5: // Incoming jump from 0x0AC4, if not storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0AC9 memory[0x40:0x60] // @0AD2 storage[0x09] // @0AF9 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0B0E stack[-4] // } 0AC5 50 POP 0AC6 60 PUSH1 0x40 0AC8 80 DUP1 0AC9 51 MLOAD 0ACA 80 DUP1 0ACB 82 DUP3 0ACC 01 ADD 0ACD 90 SWAP1 0ACE 91 SWAP2 0ACF 52 MSTORE 0AD0 60 PUSH1 0x09 0AD2 54 SLOAD 0AD3 60 PUSH1 0x01 0AD5 60 PUSH1 0x01 0AD7 60 PUSH1 0xa0 0AD9 1B SHL 0ADA 03 SUB 0ADB 81 DUP2 0ADC 16 AND 0ADD 82 DUP3 0ADE 52 MSTORE 0ADF 60 PUSH1 0x01 0AE1 60 PUSH1 0xa0 0AE3 1B SHL 0AE4 90 SWAP1 0AE5 04 DIV 0AE6 60 PUSH1 0x01 0AE8 60 PUSH1 0x01 0AEA 60 PUSH1 0x60 0AEC 1B SHL 0AED 03 SUB 0AEE 16 AND 0AEF 60 PUSH1 0x20 0AF1 82 DUP3 0AF2 01 ADD 0AF3 52 MSTORE 0AF4 5B JUMPDEST 0AF5 60 PUSH1 0x20 0AF7 81 DUP2 0AF8 01 ADD 0AF9 51 MLOAD 0AFA 60 PUSH1 0x00 0AFC 90 SWAP1 0AFD 61 PUSH2 0x2710 0B00 90 SWAP1 0B01 61 PUSH2 0x0b13 0B04 90 SWAP1 0B05 60 PUSH1 0x01 0B07 60 PUSH1 0x01 0B09 60 PUSH1 0x60 0B0B 1B SHL 0B0C 03 SUB 0B0D 16 AND 0B0E 87 DUP8 0B0F 61 PUSH2 0x240a 0B12 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0ACE stack[-1] = memory[0x40:0x60] // @0ACF memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @0ADE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[0x09] & (0x01 << 0xa0) - 0x01 // @0AF3 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x60) - 0x01 & storage[0x09] / (0x01 << 0xa0) // @0AFC stack[0] = 0x00 // @0B00 stack[1] = 0x2710 // @0B04 stack[2] = 0x0b13 // @0B0D stack[3] = (0x01 << 0x60) - 0x01 & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @0B0E stack[4] = stack[-4] // } // Block ends with call to 0x240a, returns to 0x0B13 label_0B13: // Incoming return from call to 0x240A at 0x0B12 // Incoming return from call to 0x240A at 0x0B12 // Inputs[2] // { // @0B17 stack[-2] // @0B18 stack[-1] // } 0B13 5B JUMPDEST 0B14 61 PUSH2 0x0b1d 0B17 91 SWAP2 0B18 90 SWAP1 0B19 61 PUSH2 0x2421 0B1C 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0B17 stack[-2] = 0x0b1d // @0B18 stack[-1] = stack[-2] // @0B18 stack[0] = stack[-1] // } // Block ends with call to 0x2421, returns to 0x0B1D label_0B1D: // Incoming return from call to 0x2421 at 0x0B1C // Inputs[6] // { // @0B1E stack[-1] // @0B1E stack[-3] // @0B1F memory[stack[-3]:stack[-3] + 0x20] // @0B20 stack[-5] // @0B22 stack[-2] // @0B23 stack[-4] // } 0B1D 5B JUMPDEST 0B1E 91 SWAP2 0B1F 51 MLOAD 0B20 93 SWAP4 0B21 50 POP 0B22 90 SWAP1 0B23 91 SWAP2 0B24 50 POP 0B25 50 POP // Stack delta = -3 // Outputs[2] // { // @0B20 stack[-5] = memory[stack[-3]:stack[-3] + 0x20] // @0B23 stack[-4] = stack[-1] // } // Block continues label_0B26: // Incoming jump from 0x0B25 // Incoming jump from 0x20DB, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[5] // { // @0B27 stack[-4] // @0B27 stack[-1] // @0B29 stack[-5] // @0B29 stack[-2] // @0B2A stack[-3] // } 0B26 5B JUMPDEST 0B27 92 SWAP3 0B28 50 POP 0B29 92 SWAP3 0B2A 90 SWAP1 0B2B 50 POP 0B2C 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @0B27 stack[-4] = stack[-1] // @0B29 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_0B2D: // Incoming call from 0x03F4, returns to 0x027F 0B2D 5B JUMPDEST 0B2E 61 PUSH2 0x0b35 0B31 61 PUSH2 0x113d 0B34 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B2E stack[0] = 0x0b35 } // Block ends with call to 0x113d, returns to 0x0B35 label_0B35: // Incoming return from call to 0x113D at 0x0B34 // Inputs[6] // { // @0B38 memory[0x40:0x60] // @0B39 msg.sender // @0B3B address(this) // @0B3B address(this).balance // @0B4B address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0B4B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // } 0B35 5B JUMPDEST 0B36 60 PUSH1 0x40 0B38 51 MLOAD 0B39 33 CALLER 0B3A 90 SWAP1 0B3B 47 SELFBALANCE 0B3C 80 DUP1 0B3D 15 ISZERO 0B3E 61 PUSH2 0x08fc 0B41 02 MUL 0B42 91 SWAP2 0B43 60 PUSH1 0x00 0B45 81 DUP2 0B46 81 DUP2 0B47 81 DUP2 0B48 85 DUP6 0B49 88 DUP9 0B4A 88 DUP9 0B4B F1 CALL 0B4C 93 SWAP4 0B4D 50 POP 0B4E 50 POP 0B4F 50 POP 0B50 50 POP 0B51 61 PUSH2 0x0b59 0B54 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0B4B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) } // Block ends with conditional jump to 0x0b59, if address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0B55: // Incoming jump from 0x0B54, if not address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[1] { @0B58 memory[0x00:0x00] } 0B55 60 PUSH1 0x00 0B57 80 DUP1 0B58 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B58 revert(memory[0x00:0x00]); } // Block terminates label_0B59: // Incoming return from call to 0x166D at 0x0CED // Incoming jump from 0x0B54, if address(msg.sender).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming jump from 0x114F, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @0B5A stack[-1] } 0B59 5B JUMPDEST 0B5A 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0B5B: // Incoming jump from 0x0429 // Inputs[2] // { // @0B5C stack[-3] // @0B67 msg.sender // } 0B5B 5B JUMPDEST 0B5C 82 DUP3 0B5D 60 PUSH1 0x01 0B5F 60 PUSH1 0x01 0B61 60 PUSH1 0xa0 0B63 1B SHL 0B64 03 SUB 0B65 81 DUP2 0B66 16 AND 0B67 33 CALLER 0B68 14 EQ 0B69 61 PUSH2 0x0b75 0B6C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B5C stack[0] = stack[-3] } // Block ends with conditional jump to 0x0b75, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 label_0B6D: // Incoming jump from 0x0B6C, if not msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0B70 msg.sender } 0B6D 61 PUSH2 0x0b75 0B70 33 CALLER 0B71 61 PUSH2 0x12eb 0B74 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0B6D stack[0] = 0x0b75 // @0B70 stack[1] = msg.sender // } // Block ends with call to 0x12eb, returns to 0x0B75 label_0B75: // Incoming jump from 0x0B6C, if msg.sender == stack[-3] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x12EB at 0x0B74 // Inputs[3] // { // @0B79 stack[-4] // @0B7A stack[-3] // @0B7B stack[-2] // } 0B75 5B JUMPDEST 0B76 61 PUSH2 0x0977 0B79 84 DUP5 0B7A 84 DUP5 0B7B 84 DUP5 0B7C 61 PUSH2 0x1503 0B7F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0B76 stack[0] = 0x0977 // @0B79 stack[1] = stack[-4] // @0B7A stack[2] = stack[-3] // @0B7B stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x1503 0B80 5B JUMPDEST 0B81 61 PUSH2 0x0b88 0B84 61 PUSH2 0x113d 0B87 56 *JUMP 0B88 5B JUMPDEST 0B89 60 PUSH1 0x0b 0B8B 54 SLOAD 0B8C 60 PUSH1 0x02 0B8E 54 SLOAD 0B8F 60 PUSH1 0x01 0B91 54 SLOAD 0B92 83 DUP4 0B93 91 SWAP2 0B94 90 SWAP1 0B95 03 SUB 0B96 61 PUSH2 0x059b 0B99 19 NOT 0B9A 01 ADD 0B9B 61 PUSH2 0x0ba4 0B9E 91 SWAP2 0B9F 90 SWAP1 0BA0 61 PUSH2 0x2443 0BA3 56 *JUMP 0BA4 5B JUMPDEST 0BA5 11 GT 0BA6 15 ISZERO 0BA7 61 PUSH2 0x0bc3 0BAA 57 *JUMPI 0BAB 60 PUSH1 0x40 0BAD 51 MLOAD 0BAE 63 PUSH4 0x5c9a0abb 0BB3 60 PUSH1 0xe0 0BB5 1B SHL 0BB6 81 DUP2 0BB7 52 MSTORE 0BB8 60 PUSH1 0x04 0BBA 01 ADD 0BBB 60 PUSH1 0x40 0BBD 51 MLOAD 0BBE 80 DUP1 0BBF 91 SWAP2 0BC0 03 SUB 0BC1 90 SWAP1 0BC2 FD *REVERT 0BC3 5B JUMPDEST 0BC4 61 PUSH2 0x0779 0BC7 82 DUP3 0BC8 82 DUP3 0BC9 61 PUSH2 0x151e 0BCC 56 *JUMP label_0BCD: // Incoming jump from 0x0469 // Inputs[2] // { // @0BD1 memory[0x40:0x60] // @0BD2 stack[-1] // } 0BCD 5B JUMPDEST 0BCE 60 PUSH1 0x40 0BD0 80 DUP1 0BD1 51 MLOAD 0BD2 82 DUP3 0BD3 81 DUP2 0BD4 52 MSTORE 0BD5 60 PUSH1 0x05 0BD7 83 DUP4 0BD8 90 SWAP1 0BD9 1B SHL 0BDA 80 DUP1 0BDB 82 DUP3 0BDC 01 ADD 0BDD 60 PUSH1 0x20 0BDF 01 ADD 0BE0 90 SWAP1 0BE1 92 SWAP3 0BE2 52 MSTORE 0BE3 60 PUSH1 0x60 0BE5 91 SWAP2 0BE6 5B JUMPDEST 0BE7 80 DUP1 0BE8 15 ISZERO 0BE9 61 PUSH2 0x0c11 0BEC 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @0BD1 stack[1] = memory[0x40:0x60] // @0BD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0BE2 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] + (stack[-1] << 0x05) // @0BE5 stack[0] = 0x60 // @0BE5 stack[2] = stack[-1] << 0x05 // } // Block ends with conditional jump to 0x0c11, if !(stack[-1] << 0x05) label_0BED: // Incoming jump from 0x0BEC, if not !stack[-1] // Incoming jump from 0x0BEC, if not !(stack[-1] << 0x05) // Inputs[3] // { // @0BF1 stack[-1] // @0BF4 stack[-5] // @0BF7 msg.data[stack[-5] + stack[-1] + ~0x1f:stack[-5] + stack[-1] + ~0x1f + 0x20] // } 0BED 60 PUSH1 0x1f 0BEF 19 NOT 0BF0 80 DUP1 0BF1 82 DUP3 0BF2 01 ADD 0BF3 91 SWAP2 0BF4 86 DUP7 0BF5 01 ADD 0BF6 01 ADD 0BF7 35 CALLDATALOAD 0BF8 60 PUSH1 0x00 0BFA 61 PUSH2 0x0c02 0BFD 82 DUP3 0BFE 61 PUSH2 0x0e57 0C01 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @0BF3 stack[-1] = stack[-1] + ~0x1f // @0BF7 stack[0] = msg.data[stack[-5] + stack[-1] + ~0x1f:stack[-5] + stack[-1] + ~0x1f + 0x20] // @0BF8 stack[1] = 0x00 // @0BFA stack[2] = 0x0c02 // @0BFD stack[3] = msg.data[stack[-5] + stack[-1] + ~0x1f:stack[-5] + stack[-1] + ~0x1f + 0x20] // } // Block ends with call to 0x0e57, returns to 0x0C02 label_0C02: // Incoming return from call to 0x0E57 at 0x0C01 // Inputs[4] // { // @0C03 stack[-5] // @0C04 stack[-4] // @0C09 stack[-1] // @0C0E stack[-3] // } 0C02 5B JUMPDEST 0C03 84 DUP5 0C04 84 DUP5 0C05 01 ADD 0C06 60 PUSH1 0x20 0C08 01 ADD 0C09 52 MSTORE 0C0A 50 POP 0C0B 61 PUSH2 0x0be6 0C0E 90 SWAP1 0C0F 50 POP 0C10 56 *JUMP // Stack delta = -3 // Outputs[1] { @0C09 memory[0x20 + stack[-4] + stack[-5]:0x20 + stack[-4] + stack[-5] + 0x20] = stack[-1] } // Block ends with unconditional jump to 0x0be6 label_0C11: // Incoming jump from 0x1D9F, if !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Incoming jump from 0x0BEC, if !stack[-1] // Incoming jump from 0x1D9F, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x0BEC, if !(stack[-1] << 0x05) // Inputs[3] // { // @0C13 stack[-2] // @0C13 stack[-6] // @0C14 stack[-5] // } 0C11 5B JUMPDEST 0C12 50 POP 0C13 93 SWAP4 0C14 92 SWAP3 0C15 50 POP 0C16 50 POP 0C17 50 POP 0C18 56 *JUMP // Stack delta = -5 // Outputs[1] { @0C13 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_0C19: // Incoming jump from 0x0496 // Inputs[1] { @0C1F stack[-1] } 0C19 5B JUMPDEST 0C1A 60 PUSH1 0x00 0C1C 61 PUSH2 0x0761 0C1F 82 DUP3 0C20 61 PUSH2 0x15cb 0C23 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0C1A stack[0] = 0x00 // @0C1C stack[1] = 0x0761 // @0C1F stack[2] = stack[-1] // } // Block ends with call to 0x15cb, returns to 0x0761 label_0C24: // Incoming jump from 0x04B6 // Inputs[2] // { // @0C27 storage[0x00] // @0C31 msg.sender // } 0C24 5B JUMPDEST 0C25 60 PUSH1 0x00 0C27 54 SLOAD 0C28 60 PUSH1 0x01 0C2A 60 PUSH1 0x01 0C2C 60 PUSH1 0xa0 0C2E 1B SHL 0C2F 03 SUB 0C30 16 AND 0C31 33 CALLER 0C32 14 EQ 0C33 80 DUP1 0C34 15 ISZERO 0C35 90 SWAP1 0C36 61 PUSH2 0x0c51 0C39 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C35 stack[0] = !(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00]) } // Block ends with conditional jump to 0x0c51, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0C3A: // Incoming jump from 0x0C39, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[2] // { // @0C3D storage[0x0f] // @0C4E msg.sender // } 0C3A 50 POP 0C3B 60 PUSH1 0x0f 0C3D 54 SLOAD 0C3E 60 PUSH1 0x01 0C40 60 PUSH1 0x50 0C42 1B SHL 0C43 90 SWAP1 0C44 04 DIV 0C45 60 PUSH1 0x01 0C47 60 PUSH1 0x01 0C49 60 PUSH1 0xa0 0C4B 1B SHL 0C4C 03 SUB 0C4D 16 AND 0C4E 33 CALLER 0C4F 14 EQ 0C50 15 ISZERO 0C51 5B JUMPDEST 0C52 15 ISZERO 0C53 61 PUSH2 0x0c6f 0C56 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c6f, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) label_0C57: // Incoming jump from 0x0C56, if not !stack[-1] // Incoming jump from 0x0C56, if not !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Inputs[3] // { // @0C59 memory[0x40:0x60] // @0C69 memory[0x40:0x60] // @0C6E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C57 60 PUSH1 0x40 0C59 51 MLOAD 0C5A 63 PUSH4 0x3b12fc63 0C5F 60 PUSH1 0xe2 0C61 1B SHL 0C62 81 DUP2 0C63 52 MSTORE 0C64 60 PUSH1 0x04 0C66 01 ADD 0C67 60 PUSH1 0x40 0C69 51 MLOAD 0C6A 80 DUP1 0C6B 91 SWAP2 0C6C 03 SUB 0C6D 90 SWAP1 0C6E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C63 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b12fc63 << 0xe2 // @0C6E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C6F: // Incoming jump from 0x0C56, if !stack[-1] // Incoming jump from 0x0C56, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Inputs[2] // { // @0C70 stack[-1] // @0C73 storage[0x0b] // } 0C6F 5B JUMPDEST 0C70 80 DUP1 0C71 60 PUSH1 0x0b 0C73 54 SLOAD 0C74 11 GT 0C75 15 ISZERO 0C76 61 PUSH2 0x0c92 0C79 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0c92, if !(storage[0x0b] > stack[-1]) label_0C7A: // Incoming jump from 0x0C79, if not !(storage[0x0b] > stack[-1]) // Inputs[3] // { // @0C7C memory[0x40:0x60] // @0C8C memory[0x40:0x60] // @0C91 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0C7A 60 PUSH1 0x40 0C7C 51 MLOAD 0C7D 63 PUSH4 0x6956f2ab 0C82 60 PUSH1 0xe1 0C84 1B SHL 0C85 81 DUP2 0C86 52 MSTORE 0C87 60 PUSH1 0x04 0C89 01 ADD 0C8A 60 PUSH1 0x40 0C8C 51 MLOAD 0C8D 80 DUP1 0C8E 91 SWAP2 0C8F 03 SUB 0C90 90 SWAP1 0C91 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0C86 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x6956f2ab << 0xe1 // @0C91 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0C92: // Incoming jump from 0x0C79, if !(storage[0x0b] > stack[-1]) // Inputs[2] // { // @0C95 stack[-1] // @0C96 stack[-2] // } 0C92 5B JUMPDEST 0C93 60 PUSH1 0x0b 0C95 55 SSTORE 0C96 56 *JUMP // Stack delta = -2 // Outputs[1] { @0C95 storage[0x0b] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0C97: // Incoming call from 0x170A, returns to 0x170B // Incoming call from 0x170A, returns to 0x170B // Incoming jump from 0x04D6 // Inputs[1] { @0CA2 stack[-1] } 0C97 5B JUMPDEST 0C98 60 PUSH1 0x00 0C9A 60 PUSH1 0x01 0C9C 60 PUSH1 0x01 0C9E 60 PUSH1 0xa0 0CA0 1B SHL 0CA1 03 SUB 0CA2 82 DUP3 0CA3 16 AND 0CA4 61 PUSH2 0x0cb7 0CA7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0C98 stack[0] = 0x00 } // Block ends with conditional jump to 0x0cb7, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0CA8: // Incoming jump from 0x0CA7, if not stack[-1] & (0x01 << 0xa0) - 0x01 0CA8 61 PUSH2 0x0cb7 0CAB 63 PUSH4 0x23d3ad81 0CB0 60 PUSH1 0xe2 0CB2 1B SHL 0CB3 61 PUSH2 0x12e1 0CB6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CA8 stack[0] = 0x0cb7 // @0CB2 stack[1] = 0x23d3ad81 << 0xe2 // } // Block ends with unconditional jump to 0x12e1 label_0CB7: // Incoming jump from 0x0CA7, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0CC1 stack[-2] // @0CCF memory[0x00:0x40] // @0CD0 storage[keccak256(memory[0x00:0x40])] // @0CDA stack[-3] // } 0CB7 5B JUMPDEST 0CB8 50 POP 0CB9 60 PUSH1 0x01 0CBB 60 PUSH1 0x01 0CBD 60 PUSH1 0xa0 0CBF 1B SHL 0CC0 03 SUB 0CC1 16 AND 0CC2 60 PUSH1 0x00 0CC4 90 SWAP1 0CC5 81 DUP2 0CC6 52 MSTORE 0CC7 60 PUSH1 0x06 0CC9 60 PUSH1 0x20 0CCB 52 MSTORE 0CCC 60 PUSH1 0x40 0CCE 90 SWAP1 0CCF 20 SHA3 0CD0 54 SLOAD 0CD1 60 PUSH1 0x01 0CD3 60 PUSH1 0x01 0CD5 60 PUSH1 0x40 0CD7 1B SHL 0CD8 03 SUB 0CD9 16 AND 0CDA 90 SWAP1 0CDB 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0CC6 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0CCB memory[0x20:0x40] = 0x06 // @0CDA stack[-3] = (0x01 << 0x40) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0CDC: // Incoming jump from 0x04EB 0CDC 5B JUMPDEST 0CDD 61 PUSH2 0x0ce4 0CE0 61 PUSH2 0x113d 0CE3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0CDD stack[0] = 0x0ce4 } // Block ends with call to 0x113d, returns to 0x0CE4 label_0CE4: // Incoming return from call to 0x113D at 0x0CE3 0CE4 5B JUMPDEST 0CE5 61 PUSH2 0x0b59 0CE8 60 PUSH1 0x00 0CEA 61 PUSH2 0x166d 0CED 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0CE5 stack[0] = 0x0b59 // @0CE8 stack[1] = 0x00 // } // Block ends with call to 0x166d, returns to 0x0B59 label_0CEE: // Incoming jump from 0x050B // Inputs[1] { @0CF1 storage[0x01] } 0CEE 5B JUMPDEST 0CEF 60 PUSH1 0x01 0CF1 54 SLOAD 0CF2 60 PUSH1 0x60 0CF4 90 SWAP1 0CF5 61 PUSH2 0x059c 0CF8 90 SWAP1 0CF9 60 PUSH1 0x60 0CFB 81 DUP2 0CFC 83 DUP4 0CFD 14 EQ 0CFE 61 PUSH2 0x0d0f 0D01 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @0CF4 stack[0] = 0x60 // @0CF8 stack[1] = 0x059c // @0CF8 stack[2] = storage[0x01] // @0CF9 stack[3] = 0x60 // } // Block ends with conditional jump to 0x0d0f, if 0x059c == storage[0x01] label_0D02: // Incoming jump from 0x0D01, if not 0x059c == storage[0x01] // Inputs[3] // { // @0D05 stack[-5] // @0D06 stack[-3] // @0D07 stack[-2] // } 0D02 61 PUSH2 0x0d0c 0D05 85 DUP6 0D06 84 DUP5 0D07 84 DUP5 0D08 61 PUSH2 0x16bd 0D0B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D02 stack[0] = 0x0d0c // @0D05 stack[1] = stack[-5] // @0D06 stack[2] = stack[-3] // @0D07 stack[3] = stack[-2] // } // Block ends with call to 0x16bd, returns to 0x0D0C label_0D0C: // Incoming return from call to 0x16BD at 0x0D0B // Inputs[2] // { // @0D0D stack[-2] // @0D0D stack[-1] // } 0D0C 5B JUMPDEST 0D0D 90 SWAP1 0D0E 50 POP // Stack delta = -1 // Outputs[1] { @0D0D stack[-2] = stack[-1] } // Block continues label_0D0F: // Incoming return from call to 0x16BD at 0x0D32 // Incoming return from call to 0x2026 at 0x2079 // Incoming return from call to 0x1FB1 at 0x230D // Incoming jump from 0x0D01, if 0x059c == storage[0x01] // Incoming jump from 0x0D0E // Inputs[3] // { // @0D10 stack[-1] // @0D10 stack[-6] // @0D11 stack[-5] // } 0D0F 5B JUMPDEST 0D10 94 SWAP5 0D11 93 SWAP4 0D12 50 POP 0D13 50 POP 0D14 50 POP 0D15 50 POP 0D16 56 *JUMP // Stack delta = -5 // Outputs[1] { @0D10 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_0D17: // Incoming call from 0x054B, returns to 0x0296 // Inputs[1] { @0D1D storage[0x04] } 0D17 5B JUMPDEST 0D18 60 PUSH1 0x60 0D1A 60 PUSH1 0x04 0D1C 80 DUP1 0D1D 54 SLOAD 0D1E 61 PUSH2 0x078c 0D21 90 SWAP1 0D22 61 PUSH2 0x23a1 0D25 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0D18 stack[0] = 0x60 // @0D1A stack[1] = 0x04 // @0D21 stack[2] = 0x078c // @0D21 stack[3] = storage[0x04] // } // Block ends with call to 0x23a1, returns to 0x078C label_0D26: // Incoming jump from 0x056B // Inputs[3] // { // @0D2C stack[-3] // @0D2D stack[-2] // @0D2E stack[-1] // } 0D26 5B JUMPDEST 0D27 60 PUSH1 0x60 0D29 61 PUSH2 0x0d0f 0D2C 84 DUP5 0D2D 84 DUP5 0D2E 84 DUP5 0D2F 61 PUSH2 0x16bd 0D32 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0D27 stack[0] = 0x60 // @0D29 stack[1] = 0x0d0f // @0D2C stack[2] = stack[-3] // @0D2D stack[3] = stack[-2] // @0D2E stack[4] = stack[-1] // } // Block ends with call to 0x16bd, returns to 0x0D0F 0D33 5B JUMPDEST 0D34 81 DUP2 0D35 61 PUSH2 0x0d3d 0D38 81 DUP2 0D39 61 PUSH2 0x12eb 0D3C 56 *JUMP 0D3D 5B JUMPDEST 0D3E 61 PUSH2 0x085e 0D41 83 DUP4 0D42 83 DUP4 0D43 61 PUSH2 0x17c8 0D46 56 *JUMP label_0D47: // Incoming jump from 0x151D // Incoming jump from 0x05D1 // Inputs[2] // { // @0D48 stack[-4] // @0D53 msg.sender // } 0D47 5B JUMPDEST 0D48 83 DUP4 0D49 60 PUSH1 0x01 0D4B 60 PUSH1 0x01 0D4D 60 PUSH1 0xa0 0D4F 1B SHL 0D50 03 SUB 0D51 81 DUP2 0D52 16 AND 0D53 33 CALLER 0D54 14 EQ 0D55 61 PUSH2 0x0d61 0D58 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D48 stack[0] = stack[-4] } // Block ends with conditional jump to 0x0d61, if msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 label_0D59: // Incoming jump from 0x0D58, if not msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0D5C msg.sender } 0D59 61 PUSH2 0x0d61 0D5C 33 CALLER 0D5D 61 PUSH2 0x12eb 0D60 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0D59 stack[0] = 0x0d61 // @0D5C stack[1] = msg.sender // } // Block ends with call to 0x12eb, returns to 0x0D61 label_0D61: // Incoming jump from 0x0D58, if msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01 // Incoming return from call to 0x12EB at 0x0D60 // Inputs[4] // { // @0D65 stack[-5] // @0D66 stack[-4] // @0D67 stack[-3] // @0D68 stack[-2] // } 0D61 5B JUMPDEST 0D62 61 PUSH2 0x0d6d 0D65 85 DUP6 0D66 85 DUP6 0D67 85 DUP6 0D68 85 DUP6 0D69 61 PUSH2 0x1834 0D6C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0D62 stack[0] = 0x0d6d // @0D65 stack[1] = stack[-5] // @0D66 stack[2] = stack[-4] // @0D67 stack[3] = stack[-3] // @0D68 stack[4] = stack[-2] // } // Block ends with unconditional jump to 0x1834 0D6D 5B JUMPDEST 0D6E 50 POP 0D6F 50 POP 0D70 50 POP 0D71 50 POP 0D72 50 POP 0D73 56 *JUMP label_0D74: // Incoming jump from 0x05F1 // Inputs[2] // { // @0D77 storage[0x00] // @0D81 msg.sender // } 0D74 5B JUMPDEST 0D75 60 PUSH1 0x00 0D77 54 SLOAD 0D78 60 PUSH1 0x01 0D7A 60 PUSH1 0x01 0D7C 60 PUSH1 0xa0 0D7E 1B SHL 0D7F 03 SUB 0D80 16 AND 0D81 33 CALLER 0D82 14 EQ 0D83 80 DUP1 0D84 15 ISZERO 0D85 90 SWAP1 0D86 61 PUSH2 0x0da1 0D89 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D85 stack[0] = !(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00]) } // Block ends with conditional jump to 0x0da1, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0D8A: // Incoming jump from 0x0D89, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[2] // { // @0D8D storage[0x0f] // @0D9E msg.sender // } 0D8A 50 POP 0D8B 60 PUSH1 0x0f 0D8D 54 SLOAD 0D8E 60 PUSH1 0x01 0D90 60 PUSH1 0x50 0D92 1B SHL 0D93 90 SWAP1 0D94 04 DIV 0D95 60 PUSH1 0x01 0D97 60 PUSH1 0x01 0D99 60 PUSH1 0xa0 0D9B 1B SHL 0D9C 03 SUB 0D9D 16 AND 0D9E 33 CALLER 0D9F 14 EQ 0DA0 15 ISZERO 0DA1 5B JUMPDEST 0DA2 15 ISZERO 0DA3 61 PUSH2 0x0dbf 0DA6 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0dbf, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) label_0DA7: // Incoming jump from 0x0DA6, if not !stack[-1] // Incoming jump from 0x0DA6, if not !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Inputs[3] // { // @0DA9 memory[0x40:0x60] // @0DB9 memory[0x40:0x60] // @0DBE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DA7 60 PUSH1 0x40 0DA9 51 MLOAD 0DAA 63 PUSH4 0x3b12fc63 0DAF 60 PUSH1 0xe2 0DB1 1B SHL 0DB2 81 DUP2 0DB3 52 MSTORE 0DB4 60 PUSH1 0x04 0DB6 01 ADD 0DB7 60 PUSH1 0x40 0DB9 51 MLOAD 0DBA 80 DUP1 0DBB 91 SWAP2 0DBC 03 SUB 0DBD 90 SWAP1 0DBE FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0DB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b12fc63 << 0xe2 // @0DBE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0DBF: // Incoming jump from 0x0DA6, if !stack[-1] // Incoming jump from 0x0DA6, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Inputs[1] { @0DC5 stack[-1] } 0DBF 5B JUMPDEST 0DC0 60 PUSH1 0x0d 0DC2 61 PUSH2 0x0779 0DC5 82 DUP3 0DC6 82 DUP3 0DC7 61 PUSH2 0x249c 0DCA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0DC0 stack[0] = 0x0d // @0DC2 stack[1] = 0x0779 // @0DC5 stack[2] = stack[-1] // @0DC6 stack[3] = 0x0d // } // Block ends with call to 0x249c, returns to 0x0779 label_0DCB: // Incoming jump from 0x0611 // Inputs[2] // { // @0DCE storage[0x00] // @0DD8 msg.sender // } 0DCB 5B JUMPDEST 0DCC 60 PUSH1 0x00 0DCE 54 SLOAD 0DCF 60 PUSH1 0x01 0DD1 60 PUSH1 0x01 0DD3 60 PUSH1 0xa0 0DD5 1B SHL 0DD6 03 SUB 0DD7 16 AND 0DD8 33 CALLER 0DD9 14 EQ 0DDA 80 DUP1 0DDB 15 ISZERO 0DDC 90 SWAP1 0DDD 61 PUSH2 0x0df8 0DE0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DDC stack[0] = !(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00]) } // Block ends with conditional jump to 0x0df8, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0DE1: // Incoming jump from 0x0DE0, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[2] // { // @0DE4 storage[0x0f] // @0DF5 msg.sender // } 0DE1 50 POP 0DE2 60 PUSH1 0x0f 0DE4 54 SLOAD 0DE5 60 PUSH1 0x01 0DE7 60 PUSH1 0x50 0DE9 1B SHL 0DEA 90 SWAP1 0DEB 04 DIV 0DEC 60 PUSH1 0x01 0DEE 60 PUSH1 0x01 0DF0 60 PUSH1 0xa0 0DF2 1B SHL 0DF3 03 SUB 0DF4 16 AND 0DF5 33 CALLER 0DF6 14 EQ 0DF7 15 ISZERO 0DF8 5B JUMPDEST 0DF9 15 ISZERO 0DFA 61 PUSH2 0x0e16 0DFD 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0e16, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) label_0DFE: // Incoming jump from 0x0DFD, if not !stack[-1] // Incoming jump from 0x0DFD, if not !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Inputs[3] // { // @0E00 memory[0x40:0x60] // @0E10 memory[0x40:0x60] // @0E15 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DFE 60 PUSH1 0x40 0E00 51 MLOAD 0E01 63 PUSH4 0x3b12fc63 0E06 60 PUSH1 0xe2 0E08 1B SHL 0E09 81 DUP2 0E0A 52 MSTORE 0E0B 60 PUSH1 0x04 0E0D 01 ADD 0E0E 60 PUSH1 0x40 0E10 51 MLOAD 0E11 80 DUP1 0E12 91 SWAP2 0E13 03 SUB 0E14 90 SWAP1 0E15 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E0A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b12fc63 << 0xe2 // @0E15 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0E16: // Incoming jump from 0x0DFD, if !stack[-1] // Incoming jump from 0x0DFD, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Inputs[3] // { // @0E1A storage[0x0f] // @0E24 stack[-1] // @0E56 stack[-2] // } 0E16 5B JUMPDEST 0E17 60 PUSH1 0x0f 0E19 80 DUP1 0E1A 54 SLOAD 0E1B 60 PUSH1 0x01 0E1D 60 PUSH1 0x01 0E1F 60 PUSH1 0xa0 0E21 1B SHL 0E22 03 SUB 0E23 90 SWAP1 0E24 92 SWAP3 0E25 16 AND 0E26 60 PUSH1 0x01 0E28 60 PUSH1 0x50 0E2A 1B SHL 0E2B 02 MUL 0E2C 7F PUSH32 0xffff0000000000000000000000000000000000000000ffffffffffffffffffff 0E4D 90 SWAP1 0E4E 92 SWAP3 0E4F 16 AND 0E50 91 SWAP2 0E51 90 SWAP1 0E52 91 SWAP2 0E53 17 OR 0E54 90 SWAP1 0E55 55 SSTORE 0E56 56 *JUMP // Stack delta = -2 // Outputs[1] { @0E55 storage[0x0f] = (storage[0x0f] & 0xffff0000000000000000000000000000000000000000ffffffffffffffffffff) | (0x01 << 0x50) * (stack[-1] & (0x01 << 0xa0) - 0x01) } // Block ends with unconditional jump to stack[-2] label_0E57: // Incoming call from 0x1743, returns to 0x1744 // Incoming call from 0x1743, returns to 0x1744 // Incoming jump from 0x0631 // Incoming call from 0x0C01, returns to 0x0C02 // Inputs[2] // { // @0E5B memory[0x40:0x60] // @0E7F stack[-1] // } 0E57 5B JUMPDEST 0E58 60 PUSH1 0x40 0E5A 80 DUP1 0E5B 51 MLOAD 0E5C 60 PUSH1 0x80 0E5E 81 DUP2 0E5F 01 ADD 0E60 82 DUP3 0E61 52 MSTORE 0E62 60 PUSH1 0x00 0E64 80 DUP1 0E65 82 DUP3 0E66 52 MSTORE 0E67 60 PUSH1 0x20 0E69 82 DUP3 0E6A 01 ADD 0E6B 81 DUP2 0E6C 90 SWAP1 0E6D 52 MSTORE 0E6E 91 SWAP2 0E6F 81 DUP2 0E70 01 ADD 0E71 82 DUP3 0E72 90 SWAP1 0E73 52 MSTORE 0E74 60 PUSH1 0x60 0E76 81 DUP2 0E77 01 ADD 0E78 91 SWAP2 0E79 90 SWAP1 0E7A 91 SWAP2 0E7B 52 MSTORE 0E7C 61 PUSH2 0x059c 0E7F 82 DUP3 0E80 10 LT 0E81 61 PUSH2 0x0eb7 0E84 57 *JUMPI // Stack delta = +1 // Outputs[6] // { // @0E61 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @0E66 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @0E6D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @0E73 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @0E7A stack[0] = memory[0x40:0x60] // @0E7B memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // } // Block ends with conditional jump to 0x0eb7, if stack[-1] < 0x059c label_0E85: // Incoming jump from 0x0E84, if not stack[-1] < 0x059c // Inputs[2] // { // @0E87 storage[0x01] // @0E88 stack[-2] // } 0E85 60 PUSH1 0x01 0E87 54 SLOAD 0E88 82 DUP3 0E89 10 LT 0E8A 15 ISZERO 0E8B 61 PUSH2 0x0eb7 0E8E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eb7, if !(stack[-2] < storage[0x01]) label_0E8F: // Incoming jump from 0x0EAD // Incoming jump from 0x0E8E, if not !(stack[-2] < storage[0x01]) // Inputs[3] // { // @0E92 stack[-2] // @0E9D memory[0x00:0x40] // @0E9E storage[keccak256(memory[0x00:0x40])] // } 0E8F 5B JUMPDEST 0E90 60 PUSH1 0x00 0E92 82 DUP3 0E93 81 DUP2 0E94 52 MSTORE 0E95 60 PUSH1 0x05 0E97 60 PUSH1 0x20 0E99 52 MSTORE 0E9A 60 PUSH1 0x40 0E9C 90 SWAP1 0E9D 20 SHA3 0E9E 54 SLOAD 0E9F 61 PUSH2 0x0eae 0EA2 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @0E94 memory[0x00:0x20] = stack[-2] // @0E99 memory[0x20:0x40] = 0x05 // } // Block ends with conditional jump to 0x0eae, if storage[keccak256(memory[0x00:0x40])] label_0EA3: // Incoming jump from 0x0EA2, if not storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @0EA6 stack[-1] // @0EA7 stack[-2] // } 0EA3 60 PUSH1 0x00 0EA5 19 NOT 0EA6 90 SWAP1 0EA7 91 SWAP2 0EA8 01 ADD 0EA9 90 SWAP1 0EAA 61 PUSH2 0x0e8f 0EAD 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0EA9 stack[-2] = stack[-2] + ~0x00 // @0EA9 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x0e8f label_0EAE: // Incoming jump from 0x0EA2, if storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0EB2 stack[-2] } 0EAE 5B JUMPDEST 0EAF 61 PUSH2 0x0761 0EB2 82 DUP3 0EB3 61 PUSH2 0x186f 0EB6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0EAF stack[0] = 0x0761 // @0EB2 stack[1] = stack[-2] // } // Block ends with call to 0x186f, returns to 0x0761 label_0EB7: // Incoming jump from 0x1E47, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Incoming jump from 0x129F, if 0x059c > stack[-1] // Incoming jump from 0x0E8E, if !(stack[-2] < storage[0x01]) // Incoming jump from 0x12A9, if !(stack[-2] < storage[0x01]) // Incoming jump from 0x0E84, if stack[-1] < 0x059c // Inputs[3] // { // @0EB8 stack[-1] // @0EB8 stack[-3] // @0EB9 stack[-2] // } 0EB7 5B JUMPDEST 0EB8 91 SWAP2 0EB9 90 SWAP1 0EBA 50 POP 0EBB 56 *JUMP // Stack delta = -2 // Outputs[1] { @0EB8 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_0EBC: // Incoming jump from 0x065E // Inputs[2] // { // @0EBF storage[0x00] // @0EC9 msg.sender // } 0EBC 5B JUMPDEST 0EBD 60 PUSH1 0x00 0EBF 54 SLOAD 0EC0 60 PUSH1 0x01 0EC2 60 PUSH1 0x01 0EC4 60 PUSH1 0xa0 0EC6 1B SHL 0EC7 03 SUB 0EC8 16 AND 0EC9 33 CALLER 0ECA 14 EQ 0ECB 80 DUP1 0ECC 15 ISZERO 0ECD 90 SWAP1 0ECE 61 PUSH2 0x0ee9 0ED1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0ECD stack[0] = !(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00]) } // Block ends with conditional jump to 0x0ee9, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0ED2: // Incoming jump from 0x0ED1, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[2] // { // @0ED5 storage[0x0f] // @0EE6 msg.sender // } 0ED2 50 POP 0ED3 60 PUSH1 0x0f 0ED5 54 SLOAD 0ED6 60 PUSH1 0x01 0ED8 60 PUSH1 0x50 0EDA 1B SHL 0EDB 90 SWAP1 0EDC 04 DIV 0EDD 60 PUSH1 0x01 0EDF 60 PUSH1 0x01 0EE1 60 PUSH1 0xa0 0EE3 1B SHL 0EE4 03 SUB 0EE5 16 AND 0EE6 33 CALLER 0EE7 14 EQ 0EE8 15 ISZERO 0EE9 5B JUMPDEST 0EEA 15 ISZERO 0EEB 61 PUSH2 0x0f07 0EEE 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f07, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) label_0EEF: // Incoming jump from 0x0EEE, if not !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Incoming jump from 0x0EEE, if not !stack[-1] // Inputs[3] // { // @0EF1 memory[0x40:0x60] // @0F01 memory[0x40:0x60] // @0F06 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0EEF 60 PUSH1 0x40 0EF1 51 MLOAD 0EF2 63 PUSH4 0x3b12fc63 0EF7 60 PUSH1 0xe2 0EF9 1B SHL 0EFA 81 DUP2 0EFB 52 MSTORE 0EFC 60 PUSH1 0x04 0EFE 01 ADD 0EFF 60 PUSH1 0x40 0F01 51 MLOAD 0F02 80 DUP1 0F03 91 SWAP2 0F04 03 SUB 0F05 90 SWAP1 0F06 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0EFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b12fc63 << 0xe2 // @0F06 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F07: // Incoming jump from 0x0EEE, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Incoming jump from 0x0EEE, if !stack[-1] // Inputs[1] { @0F0D stack[-1] } 0F07 5B JUMPDEST 0F08 60 PUSH1 0x0c 0F0A 61 PUSH2 0x0779 0F0D 82 DUP3 0F0E 82 DUP3 0F0F 61 PUSH2 0x249c 0F12 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F08 stack[0] = 0x0c // @0F0A stack[1] = 0x0779 // @0F0D stack[2] = stack[-1] // @0F0E stack[3] = 0x0c // } // Block ends with call to 0x249c, returns to 0x0779 label_0F13: // Incoming jump from 0x067E // Inputs[1] { @0F19 stack[-1] } 0F13 5B JUMPDEST 0F14 60 PUSH1 0x60 0F16 61 PUSH2 0x0f1e 0F19 82 DUP3 0F1A 61 PUSH2 0x1294 0F1D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F14 stack[0] = 0x60 // @0F16 stack[1] = 0x0f1e // @0F19 stack[2] = stack[-1] // } // Block ends with call to 0x1294, returns to 0x0F1E label_0F1E: // Incoming return from call to 0x1294 at 0x0F1D // Inputs[1] { @0F22 stack[-1] } 0F1E 5B JUMPDEST 0F1F 61 PUSH2 0x0f3b 0F22 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f3b, if stack[-1] label_0F23: // Incoming jump from 0x0F22, if not stack[-1] // Inputs[3] // { // @0F25 memory[0x40:0x60] // @0F35 memory[0x40:0x60] // @0F3A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F23 60 PUSH1 0x40 0F25 51 MLOAD 0F26 63 PUSH4 0x0c7cc8f9 0F2B 60 PUSH1 0xe4 0F2D 1B SHL 0F2E 81 DUP2 0F2F 52 MSTORE 0F30 60 PUSH1 0x04 0F32 01 ADD 0F33 60 PUSH1 0x40 0F35 51 MLOAD 0F36 80 DUP1 0F37 91 SWAP2 0F38 03 SUB 0F39 90 SWAP1 0F3A FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F2F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x0c7cc8f9 << 0xe4 // @0F3A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0F3B: // Incoming jump from 0x0F22, if stack[-1] // Inputs[1] { @0F3F stack[-2] } 0F3B 5B JUMPDEST 0F3C 61 PUSH2 0x0f44 0F3F 82 DUP3 0F40 61 PUSH2 0x18ed 0F43 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0F3C stack[0] = 0x0f44 // @0F3F stack[1] = stack[-2] // } // Block ends with unconditional jump to 0x18ed 0F44 5B JUMPDEST 0F45 60 PUSH1 0x0d 0F47 60 PUSH1 0x40 0F49 51 MLOAD 0F4A 60 PUSH1 0x20 0F4C 01 ADD 0F4D 61 PUSH2 0x0f57 0F50 92 SWAP3 0F51 91 SWAP2 0F52 90 SWAP1 0F53 61 PUSH2 0x255b 0F56 56 *JUMP 0F57 5B JUMPDEST 0F58 60 PUSH1 0x40 0F5A 51 MLOAD 0F5B 60 PUSH1 0x20 0F5D 81 DUP2 0F5E 83 DUP4 0F5F 03 SUB 0F60 03 SUB 0F61 81 DUP2 0F62 52 MSTORE 0F63 90 SWAP1 0F64 60 PUSH1 0x40 0F66 52 MSTORE 0F67 90 SWAP1 0F68 50 POP 0F69 91 SWAP2 0F6A 90 SWAP1 0F6B 50 POP 0F6C 56 *JUMP label_0F6D: // Incoming call from 0x06A9, returns to 0x027F // Inputs[2] // { // @0F70 storage[0x00] // @0F7A msg.sender // } 0F6D 5B JUMPDEST 0F6E 60 PUSH1 0x00 0F70 54 SLOAD 0F71 60 PUSH1 0x01 0F73 60 PUSH1 0x01 0F75 60 PUSH1 0xa0 0F77 1B SHL 0F78 03 SUB 0F79 16 AND 0F7A 33 CALLER 0F7B 14 EQ 0F7C 80 DUP1 0F7D 15 ISZERO 0F7E 90 SWAP1 0F7F 61 PUSH2 0x0f9a 0F82 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0F7E stack[0] = !(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00]) } // Block ends with conditional jump to 0x0f9a, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_0F83: // Incoming jump from 0x0F82, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[2] // { // @0F86 storage[0x0f] // @0F97 msg.sender // } 0F83 50 POP 0F84 60 PUSH1 0x0f 0F86 54 SLOAD 0F87 60 PUSH1 0x01 0F89 60 PUSH1 0x50 0F8B 1B SHL 0F8C 90 SWAP1 0F8D 04 DIV 0F8E 60 PUSH1 0x01 0F90 60 PUSH1 0x01 0F92 60 PUSH1 0xa0 0F94 1B SHL 0F95 03 SUB 0F96 16 AND 0F97 33 CALLER 0F98 14 EQ 0F99 15 ISZERO 0F9A 5B JUMPDEST 0F9B 15 ISZERO 0F9C 61 PUSH2 0x0fb8 0F9F 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fb8, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) label_0FA0: // Incoming jump from 0x0F9F, if not !stack[-1] // Incoming jump from 0x0F9F, if not !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Inputs[3] // { // @0FA2 memory[0x40:0x60] // @0FB2 memory[0x40:0x60] // @0FB7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FA0 60 PUSH1 0x40 0FA2 51 MLOAD 0FA3 63 PUSH4 0x3b12fc63 0FA8 60 PUSH1 0xe2 0FAA 1B SHL 0FAB 81 DUP2 0FAC 52 MSTORE 0FAD 60 PUSH1 0x04 0FAF 01 ADD 0FB0 60 PUSH1 0x40 0FB2 51 MLOAD 0FB3 80 DUP1 0FB4 91 SWAP2 0FB5 03 SUB 0FB6 90 SWAP1 0FB7 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0FAC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3b12fc63 << 0xe2 // @0FB7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0FB8: // Incoming jump from 0x0F9F, if !stack[-1] // Incoming jump from 0x0F9F, if !!(msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x0f] / (0x01 << 0x50)) // Inputs[2] // { // @0FBC storage[0x0f] // @0FEB stack[-1] // } 0FB8 5B JUMPDEST 0FB9 60 PUSH1 0x0f 0FBB 80 DUP1 0FBC 54 SLOAD 0FBD 68 PUSH9 0xff0000000000000000 0FC7 19 NOT 0FC8 60 PUSH1 0x01 0FCA 60 PUSH1 0x48 0FCC 1B SHL 0FCD 60 PUSH1 0xff 0FCF 60 PUSH1 0x01 0FD1 60 PUSH1 0x40 0FD3 1B SHL 0FD4 84 DUP5 0FD5 04 DIV 0FD6 16 AND 0FD7 02 MUL 0FD8 16 AND 0FD9 69 PUSH10 0xffff0000000000000000 0FE4 19 NOT 0FE5 90 SWAP1 0FE6 91 SWAP2 0FE7 16 AND 0FE8 17 OR 0FE9 90 SWAP1 0FEA 55 SSTORE 0FEB 56 *JUMP // Stack delta = -1 // Outputs[1] { @0FEA storage[0x0f] = (storage[0x0f] & ~0xffff0000000000000000) | ((storage[0x0f] / (0x01 << 0x40) & 0xff) * (0x01 << 0x48) & ~0xff0000000000000000) } // Block ends with unconditional jump to stack[-1] label_0FEC: // Incoming jump from 0x06DD // Inputs[2] // { // @0FED tx.origin // @0FEE msg.sender // } 0FEC 5B JUMPDEST 0FED 32 ORIGIN 0FEE 33 CALLER 0FEF 14 EQ 0FF0 61 PUSH2 0x100c 0FF3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x100c, if msg.sender == tx.origin label_0FF4: // Incoming jump from 0x0FF3, if not msg.sender == tx.origin // Inputs[3] // { // @0FF6 memory[0x40:0x60] // @1006 memory[0x40:0x60] // @100B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0FF4 60 PUSH1 0x40 0FF6 51 MLOAD 0FF7 63 PUSH4 0x4e8153e1 0FFC 60 PUSH1 0xe1 0FFE 1B SHL 0FFF 81 DUP2 1000 52 MSTORE 1001 60 PUSH1 0x04 1003 01 ADD 1004 60 PUSH1 0x40 1006 51 MLOAD 1007 80 DUP1 1008 91 SWAP2 1009 03 SUB 100A 90 SWAP1 100B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1000 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x4e8153e1 << 0xe1 // @100B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_100C: // Incoming jump from 0x0FF3, if msg.sender == tx.origin // Inputs[1] { @100F storage[0x0e] } 100C 5B JUMPDEST 100D 60 PUSH1 0x0e 100F 54 SLOAD 1010 15 ISZERO 1011 61 PUSH2 0x1029 1014 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1029, if !storage[0x0e] label_1015: // Incoming jump from 0x1014, if not !storage[0x0e] // Inputs[3] // { // @1018 stack[-3] // @1019 stack[-2] // @101A stack[-1] // } 1015 61 PUSH2 0x101f 1018 83 DUP4 1019 83 DUP4 101A 83 DUP4 101B 61 PUSH2 0x1968 101E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1015 stack[0] = 0x101f // @1018 stack[1] = stack[-3] // @1019 stack[2] = stack[-2] // @101A stack[3] = stack[-1] // } // Block ends with call to 0x1968, returns to 0x101F label_101F: // Incoming return from call to 0x1968 at 0x101E // Inputs[2] // { // @1023 stack[-4] // @1024 stack[-3] // } 101F 5B JUMPDEST 1020 61 PUSH2 0x1029 1023 84 DUP5 1024 84 DUP5 1025 61 PUSH2 0x1a0b 1028 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1020 stack[0] = 0x1029 // @1023 stack[1] = stack[-4] // @1024 stack[2] = stack[-3] // } // Block ends with unconditional jump to 0x1a0b label_1029: // Incoming jump from 0x1014, if !storage[0x0e] // Inputs[1] { @102D stack[-4] } 1029 5B JUMPDEST 102A 61 PUSH2 0x1032 102D 84 DUP5 102E 61 PUSH2 0x1ac1 1031 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @102A stack[0] = 0x1032 // @102D stack[1] = stack[-4] // } // Block ends with call to 0x1ac1, returns to 0x1032 label_1032: // Incoming return from call to 0x1AC1 at 0x1031 // Inputs[2] // { // @1036 msg.sender // @1037 stack[-4] // } 1032 5B JUMPDEST 1033 61 PUSH2 0x0977 1036 33 CALLER 1037 85 DUP6 1038 61 PUSH2 0x151e 103B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1033 stack[0] = 0x0977 // @1036 stack[1] = msg.sender // @1037 stack[2] = stack[-4] // } // Block ends with call to 0x151e, returns to 0x0977 label_103C: // Incoming jump from 0x0746 103C 5B JUMPDEST 103D 61 PUSH2 0x1044 1040 61 PUSH2 0x113d 1043 56 *JUMP // Stack delta = +1 // Outputs[1] { @103D stack[0] = 0x1044 } // Block ends with call to 0x113d, returns to 0x1044 label_1044: // Incoming return from call to 0x113D at 0x1043 // Inputs[1] { @104D stack[-1] } 1044 5B JUMPDEST 1045 60 PUSH1 0x01 1047 60 PUSH1 0x01 1049 60 PUSH1 0xa0 104B 1B SHL 104C 03 SUB 104D 81 DUP2 104E 16 AND 104F 61 PUSH2 0x10ae 1052 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10ae, if stack[-1] & (0x01 << 0xa0) - 0x01 label_1053: // Incoming jump from 0x1052, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1055 memory[0x40:0x60] } 1053 60 PUSH1 0x40 1055 51 MLOAD 1056 62 PUSH3 0x461bcd 105A 60 PUSH1 0xe5 105C 1B SHL 105D 81 DUP2 105E 52 MSTORE 105F 60 PUSH1 0x20 1061 60 PUSH1 0x04 1063 82 DUP3 1064 01 ADD 1065 52 MSTORE 1066 60 PUSH1 0x26 1068 60 PUSH1 0x24 106A 82 DUP3 106B 01 ADD 106C 52 MSTORE 106D 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 108E 60 PUSH1 0x44 1090 82 DUP3 1091 01 ADD 1092 52 MSTORE 1093 65 PUSH6 0x646472657373 109A 60 PUSH1 0xd0 109C 1B SHL 109D 60 PUSH1 0x64 109F 82 DUP3 10A0 01 ADD 10A1 52 MSTORE 10A2 60 PUSH1 0x84 10A4 01 ADD // Stack delta = +1 // Outputs[6] // { // @105E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1065 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @106C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1092 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @10A1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @10A4 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_10A5: // Incoming jump from 0x125A // Incoming jump from 0x10A4 // Incoming jump from 0x1204 // Incoming jump from 0x1196 // Inputs[3] // { // @10A8 memory[0x40:0x60] // @10AA stack[-1] // @10AD memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 10A5 5B JUMPDEST 10A6 60 PUSH1 0x40 10A8 51 MLOAD 10A9 80 DUP1 10AA 91 SWAP2 10AB 03 SUB 10AC 90 SWAP1 10AD FD *REVERT // Stack delta = -1 // Outputs[1] { @10AD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_10AE: // Incoming jump from 0x1052, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @10B2 stack[-1] } 10AE 5B JUMPDEST 10AF 61 PUSH2 0x10b7 10B2 81 DUP2 10B3 61 PUSH2 0x166d 10B6 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10AF stack[0] = 0x10b7 // @10B2 stack[1] = stack[-1] // } // Block ends with call to 0x166d, returns to 0x10B7 label_10B7: // Incoming return from call to 0x166D at 0x10B6 // Incoming jump from 0x1B8A, if !(stack[-1] > stack[-2]) // Incoming jump from 0x222E, if stack[-1] == !!stack[-1] // Incoming jump from 0x1300, if !address(0xaaeb6d7670e522a718067333cd4e).code.length // Incoming jump from 0x1E13, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @10B9 stack[-2] } 10B7 5B JUMPDEST 10B8 50 POP 10B9 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_10BA: // Incoming call from 0x0751, returns to 0x0752 // Inputs[1] { @10CE stack[-1] } 10BA 5B JUMPDEST 10BB 60 PUSH1 0x00 10BD 63 PUSH4 0x01ffc9a7 10C2 60 PUSH1 0xe0 10C4 1B SHL 10C5 60 PUSH1 0x01 10C7 60 PUSH1 0x01 10C9 60 PUSH1 0xe0 10CB 1B SHL 10CC 03 SUB 10CD 19 NOT 10CE 83 DUP4 10CF 16 AND 10D0 14 EQ 10D1 80 DUP1 10D2 61 PUSH2 0x10eb 10D5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @10BB stack[0] = 0x00 // @10D0 stack[1] = stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // } // Block ends with conditional jump to 0x10eb, if stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 label_10D6: // Incoming jump from 0x10D5, if not stack[-1] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 // Inputs[1] { @10E8 stack[-3] } 10D6 50 POP 10D7 63 PUSH4 0x80ac58cd 10DC 60 PUSH1 0xe0 10DE 1B SHL 10DF 60 PUSH1 0x01 10E1 60 PUSH1 0x01 10E3 60 PUSH1 0xe0 10E5 1B SHL 10E6 03 SUB 10E7 19 NOT 10E8 83 DUP4 10E9 16 AND 10EA 14 EQ 10EB 5B JUMPDEST 10EC 80 DUP1 10ED 61 PUSH2 0x0761 10F0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @10EA stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 } // Block ends with conditional jump to 0x0761, if stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 label_10F1: // Incoming jump from 0x10F0, if not stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x80ac58cd << 0xe0 // Incoming jump from 0x10F0, if not stack[-1] // Inputs[2] // { // @10FC stack[-3] // @1106 stack[-4] // } 10F1 50 POP 10F2 50 POP 10F3 60 PUSH1 0x01 10F5 60 PUSH1 0x01 10F7 60 PUSH1 0xe0 10F9 1B SHL 10FA 03 SUB 10FB 19 NOT 10FC 16 AND 10FD 63 PUSH4 0x5b5e139f 1102 60 PUSH1 0xe0 1104 1B SHL 1105 14 EQ 1106 90 SWAP1 1107 56 *JUMP // Stack delta = -3 // Outputs[1] { @1106 stack[-4] = 0x5b5e139f << 0xe0 == ~((0x01 << 0xe0) - 0x01) & stack[-3] } // Block ends with unconditional jump to stack[-4] label_1108: // Incoming call from 0x0760, returns to 0x0761 // Inputs[1] { @1114 stack[-1] } 1108 5B JUMPDEST 1109 60 PUSH1 0x00 110B 60 PUSH1 0x01 110D 60 PUSH1 0x01 110F 60 PUSH1 0xe0 1111 1B SHL 1112 03 SUB 1113 19 NOT 1114 82 DUP3 1115 16 AND 1116 63 PUSH4 0x152a902d 111B 60 PUSH1 0xe1 111D 1B SHL 111E 14 EQ 111F 80 DUP1 1120 61 PUSH2 0x0761 1123 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1109 stack[0] = 0x00 // @111E stack[1] = 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0761, if 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1124: // Incoming jump from 0x1123, if not 0x152a902d << 0xe1 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1136 stack[-3] } 1124 50 POP 1125 63 PUSH4 0x01ffc9a7 112A 60 PUSH1 0xe0 112C 1B SHL 112D 60 PUSH1 0x01 112F 60 PUSH1 0x01 1131 60 PUSH1 0xe0 1133 1B SHL 1134 03 SUB 1135 19 NOT 1136 83 DUP4 1137 16 AND 1138 14 EQ 1139 61 PUSH2 0x0761 113C 56 *JUMP // Stack delta = +0 // Outputs[1] { @1138 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x0761 label_113D: // Incoming call from 0x0CE3, returns to 0x0CE4 // Incoming call from 0x1043, returns to 0x1044 // Incoming call from 0x0B34, returns to 0x0B35 // Incoming call from 0x076E, returns to 0x076F // Incoming call from 0x0984, returns to 0x0985 // Inputs[2] // { // @1140 storage[0x00] // @114A msg.sender // } 113D 5B JUMPDEST 113E 60 PUSH1 0x00 1140 54 SLOAD 1141 60 PUSH1 0x01 1143 60 PUSH1 0x01 1145 60 PUSH1 0xa0 1147 1B SHL 1148 03 SUB 1149 16 AND 114A 33 CALLER 114B 14 EQ 114C 61 PUSH2 0x0b59 114F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b59, if msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] label_1150: // Incoming jump from 0x114F, if not msg.sender == (0x01 << 0xa0) - 0x01 & storage[0x00] // Inputs[1] { @1152 memory[0x40:0x60] } 1150 60 PUSH1 0x40 1152 51 MLOAD 1153 62 PUSH3 0x461bcd 1157 60 PUSH1 0xe5 1159 1B SHL 115A 81 DUP2 115B 52 MSTORE 115C 60 PUSH1 0x20 115E 60 PUSH1 0x04 1160 82 DUP3 1161 01 ADD 1162 81 DUP2 1163 90 SWAP1 1164 52 MSTORE 1165 60 PUSH1 0x24 1167 82 DUP3 1168 01 ADD 1169 52 MSTORE 116A 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 118B 60 PUSH1 0x44 118D 82 DUP3 118E 01 ADD 118F 52 MSTORE 1190 60 PUSH1 0x64 1192 01 ADD 1193 61 PUSH2 0x10a5 1196 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @115B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1164 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1169 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x20 // @118F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1192 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x10a5 label_1197: // Incoming call from 0x0778, returns to 0x0779 // Inputs[1] { @11A3 stack[-1] } 1197 5B JUMPDEST 1198 61 PUSH2 0x2710 119B 60 PUSH1 0x01 119D 60 PUSH1 0x01 119F 60 PUSH1 0x60 11A1 1B SHL 11A2 03 SUB 11A3 82 DUP3 11A4 16 AND 11A5 11 GT 11A6 15 ISZERO 11A7 61 PUSH2 0x1205 11AA 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1205, if !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) label_11AB: // Incoming jump from 0x11AA, if not !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) // Inputs[1] { @11AD memory[0x40:0x60] } 11AB 60 PUSH1 0x40 11AD 51 MLOAD 11AE 62 PUSH3 0x461bcd 11B2 60 PUSH1 0xe5 11B4 1B SHL 11B5 81 DUP2 11B6 52 MSTORE 11B7 60 PUSH1 0x20 11B9 60 PUSH1 0x04 11BB 82 DUP3 11BC 01 ADD 11BD 52 MSTORE 11BE 60 PUSH1 0x2a 11C0 60 PUSH1 0x24 11C2 82 DUP3 11C3 01 ADD 11C4 52 MSTORE 11C5 7F PUSH32 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 11E6 60 PUSH1 0x44 11E8 82 DUP3 11E9 01 ADD 11EA 52 MSTORE 11EB 69 PUSH10 0x2073616c655072696365 11F6 60 PUSH1 0xb0 11F8 1B SHL 11F9 60 PUSH1 0x64 11FB 82 DUP3 11FC 01 ADD 11FD 52 MSTORE 11FE 60 PUSH1 0x84 1200 01 ADD 1201 61 PUSH2 0x10a5 1204 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @11B6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11BD memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11C4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @11EA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20726f79616c7479206665652077696c6c20657863656564 // @11FD memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x2073616c655072696365 << 0xb0 // @1200 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x10a5 label_1205: // Incoming jump from 0x11AA, if !(stack[-1] & (0x01 << 0x60) - 0x01 > 0x2710) // Inputs[1] { @120E stack[-2] } 1205 5B JUMPDEST 1206 60 PUSH1 0x01 1208 60 PUSH1 0x01 120A 60 PUSH1 0xa0 120C 1B SHL 120D 03 SUB 120E 82 DUP3 120F 16 AND 1210 61 PUSH2 0x125b 1213 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x125b, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1214: // Incoming jump from 0x1213, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1216 memory[0x40:0x60] } 1214 60 PUSH1 0x40 1216 51 MLOAD 1217 62 PUSH3 0x461bcd 121B 60 PUSH1 0xe5 121D 1B SHL 121E 81 DUP2 121F 52 MSTORE 1220 60 PUSH1 0x20 1222 60 PUSH1 0x04 1224 82 DUP3 1225 01 ADD 1226 52 MSTORE 1227 60 PUSH1 0x19 1229 60 PUSH1 0x24 122B 82 DUP3 122C 01 ADD 122D 52 MSTORE 122E 7F PUSH32 0x455243323938313a20696e76616c696420726563656976657200000000000000 124F 60 PUSH1 0x44 1251 82 DUP3 1252 01 ADD 1253 52 MSTORE 1254 60 PUSH1 0x64 1256 01 ADD 1257 61 PUSH2 0x10a5 125A 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @121F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1226 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @122D memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @1253 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243323938313a20696e76616c696420726563656976657200000000000000 // @1256 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x10a5 label_125B: // Incoming jump from 0x1213, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @125F memory[0x40:0x60] // @126F stack[-2] // @127D stack[-1] // @1293 stack[-3] // } 125B 5B JUMPDEST 125C 60 PUSH1 0x40 125E 80 DUP1 125F 51 MLOAD 1260 80 DUP1 1261 82 DUP3 1262 01 ADD 1263 90 SWAP1 1264 91 SWAP2 1265 52 MSTORE 1266 60 PUSH1 0x01 1268 60 PUSH1 0x01 126A 60 PUSH1 0xa0 126C 1B SHL 126D 03 SUB 126E 90 SWAP1 126F 92 SWAP3 1270 16 AND 1271 80 DUP1 1272 83 DUP4 1273 52 MSTORE 1274 60 PUSH1 0x01 1276 60 PUSH1 0x01 1278 60 PUSH1 0x60 127A 1B SHL 127B 03 SUB 127C 90 SWAP1 127D 91 SWAP2 127E 16 AND 127F 60 PUSH1 0x20 1281 90 SWAP1 1282 92 SWAP3 1283 01 ADD 1284 82 DUP3 1285 90 SWAP1 1286 52 MSTORE 1287 60 PUSH1 0x01 1289 60 PUSH1 0xa0 128B 1B SHL 128C 90 SWAP1 128D 91 SWAP2 128E 02 MUL 128F 17 OR 1290 60 PUSH1 0x09 1292 55 SSTORE 1293 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @1265 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1273 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1286 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = stack[-1] & (0x01 << 0x60) - 0x01 // @1292 storage[0x09] = (stack[-1] & (0x01 << 0x60) - 0x01) * (0x01 << 0xa0) | (stack[-2] & (0x01 << 0xa0) - 0x01) // } // Block ends with unconditional jump to stack[-3] label_1294: // Incoming call from 0x0819, returns to 0x081A // Incoming call from 0x0F1D, returns to 0x0F1E // Incoming call from 0x18F7, returns to 0x18F8 // Inputs[1] { @1297 stack[-1] } 1294 5B JUMPDEST 1295 60 PUSH1 0x00 1297 81 DUP2 1298 61 PUSH2 0x059c 129B 11 GT 129C 61 PUSH2 0x0eb7 129F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1295 stack[0] = 0x00 } // Block ends with conditional jump to 0x0eb7, if 0x059c > stack[-1] label_12A0: // Incoming jump from 0x129F, if not 0x059c > stack[-1] // Inputs[2] // { // @12A2 storage[0x01] // @12A3 stack[-2] // } 12A0 60 PUSH1 0x01 12A2 54 SLOAD 12A3 82 DUP3 12A4 10 LT 12A5 15 ISZERO 12A6 61 PUSH2 0x0eb7 12A9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0eb7, if !(stack[-2] < storage[0x01]) label_12AA: // Incoming jump from 0x12A9, if not !(stack[-2] < storage[0x01]) // Inputs[3] // { // @12B0 stack[-2] // @12BB memory[0x00:0x40] // @12BC storage[keccak256(memory[0x00:0x40])] // } 12AA 60 PUSH1 0x00 12AC 5B JUMPDEST 12AD 50 POP 12AE 60 PUSH1 0x00 12B0 82 DUP3 12B1 81 DUP2 12B2 52 MSTORE 12B3 60 PUSH1 0x05 12B5 60 PUSH1 0x20 12B7 52 MSTORE 12B8 60 PUSH1 0x40 12BA 81 DUP2 12BB 20 SHA3 12BC 54 SLOAD 12BD 90 SWAP1 12BE 81 DUP2 12BF 90 SWAP1 12C0 03 SUB 12C1 61 PUSH2 0x12d4 12C4 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @12B2 memory[0x00:0x20] = stack[-2] // @12B7 memory[0x20:0x40] = 0x05 // @12BD stack[0] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x12d4, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_12C5: // Incoming jump from 0x12C4, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x12C4, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @12C8 stack[-3] } 12C5 61 PUSH2 0x12cd 12C8 83 DUP4 12C9 61 PUSH2 0x25e8 12CC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @12C5 stack[0] = 0x12cd // @12C8 stack[1] = stack[-3] // } // Block ends with call to 0x25e8, returns to 0x12CD label_12CD: // Incoming return from call to 0x25E8 at 0x12CC // Inputs[2] // { // @12CE stack[-1] // @12CE stack[-4] // } 12CD 5B JUMPDEST 12CE 92 SWAP3 12CF 50 POP 12D0 61 PUSH2 0x12ac 12D3 56 *JUMP // Stack delta = -1 // Outputs[1] { @12CE stack[-4] = stack[-1] } // Block ends with unconditional jump to 0x12ac label_12D4: // Incoming jump from 0x12C4, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x12C4, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[3] // { // @12DA stack[-1] // @12DC stack[-4] // @12DD stack[-3] // } 12D4 5B JUMPDEST 12D5 60 PUSH1 0x01 12D7 60 PUSH1 0xe0 12D9 1B SHL 12DA 16 AND 12DB 15 ISZERO 12DC 92 SWAP3 12DD 91 SWAP2 12DE 50 POP 12DF 50 POP 12E0 56 *JUMP // Stack delta = -3 // Outputs[1] { @12DC stack[-4] = !((0x01 << 0xe0) & stack[-1]) } // Block ends with unconditional jump to stack[-4] label_12E1: // Incoming jump from 0x190B // Incoming jump from 0x1606 // Incoming jump from 0x082D // Incoming jump from 0x13E0 // Incoming jump from 0x0CB6 // Incoming jump from 0x1539 // Incoming jump from 0x1597 // Incoming jump from 0x1424 // Incoming jump from 0x14F9 // Incoming jump from 0x1644 // Incoming jump from 0x166C // Incoming jump from 0x16D5 // Inputs[2] // { // @12E2 stack[-1] // @12EA memory[0x00:0x04] // } 12E1 5B JUMPDEST 12E2 80 DUP1 12E3 60 PUSH1 0x00 12E5 52 MSTORE 12E6 60 PUSH1 0x04 12E8 60 PUSH1 0x00 12EA FD *REVERT // Stack delta = +0 // Outputs[2] // { // @12E5 memory[0x00:0x20] = stack[-1] // @12EA revert(memory[0x00:0x04]); // } // Block terminates label_12EB: // Incoming call from 0x0B74, returns to 0x0B75 // Incoming call from 0x0D60, returns to 0x0D61 // Incoming call from 0x096B, returns to 0x096C // Inputs[1] { @12FB address(0xaaeb6d7670e522a718067333cd4e).code.length } 12EB 5B JUMPDEST 12EC 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 12FB 3B EXTCODESIZE 12FC 15 ISZERO 12FD 61 PUSH2 0x10b7 1300 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10b7, if !address(0xaaeb6d7670e522a718067333cd4e).code.length label_1301: // Incoming jump from 0x1300, if not !address(0xaaeb6d7670e522a718067333cd4e).code.length // Inputs[7] // { // @1303 memory[0x40:0x60] // @130E address(this) // @131C stack[-1] // @1340 memory[0x40:0x60] // @1346 msg.gas // @1347 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1347 address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // } 1301 60 PUSH1 0x40 1303 51 MLOAD 1304 63 PUSH4 0x3185c44d 1309 60 PUSH1 0xe2 130B 1B SHL 130C 81 DUP2 130D 52 MSTORE 130E 30 ADDRESS 130F 60 PUSH1 0x04 1311 82 DUP3 1312 01 ADD 1313 52 MSTORE 1314 60 PUSH1 0x01 1316 60 PUSH1 0x01 1318 60 PUSH1 0xa0 131A 1B SHL 131B 03 SUB 131C 82 DUP3 131D 16 AND 131E 60 PUSH1 0x24 1320 82 DUP3 1321 01 ADD 1322 52 MSTORE 1323 6D PUSH14 0xaaeb6d7670e522a718067333cd4e 1332 90 SWAP1 1333 63 PUSH4 0xc6171134 1338 90 SWAP1 1339 60 PUSH1 0x44 133B 01 ADD 133C 60 PUSH1 0x20 133E 60 PUSH1 0x40 1340 51 MLOAD 1341 80 DUP1 1342 83 DUP4 1343 03 SUB 1344 81 DUP2 1345 86 DUP7 1346 5A GAS 1347 FA STATICCALL 1348 15 ISZERO 1349 80 DUP1 134A 15 ISZERO 134B 61 PUSH2 0x1358 134E 57 *JUMPI // Stack delta = +4 // Outputs[8] // { // @130D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x3185c44d << 0xe2 // @1313 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = address(this) // @1322 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @1332 stack[0] = 0xaaeb6d7670e522a718067333cd4e // @1338 stack[1] = 0xc6171134 // @133B stack[2] = 0x44 + memory[0x40:0x60] // @1347 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]]) // @1348 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 0x1358, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) label_134F: // Incoming jump from 0x134E, if not !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[4] // { // @134F returndata.length // @1353 returndata[0x00:0x00 + returndata.length] // @1354 returndata.length // @1357 memory[0x00:0x00 + returndata.length] // } 134F 3D RETURNDATASIZE 1350 60 PUSH1 0x00 1352 80 DUP1 1353 3E RETURNDATACOPY 1354 3D RETURNDATASIZE 1355 60 PUSH1 0x00 1357 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1353 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1357 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1358: // Incoming jump from 0x134E, if !!address(0xaaeb6d7670e522a718067333cd4e).staticcall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x44 + memory[0x40:0x60]) - memory[0x40:0x60]]) // Inputs[2] // { // @135F memory[0x40:0x60] // @1360 returndata.length // } 1358 5B JUMPDEST 1359 50 POP 135A 50 POP 135B 50 POP 135C 50 POP 135D 60 PUSH1 0x40 135F 51 MLOAD 1360 3D RETURNDATASIZE 1361 60 PUSH1 0x1f 1363 19 NOT 1364 60 PUSH1 0x1f 1366 82 DUP3 1367 01 ADD 1368 16 AND 1369 82 DUP3 136A 01 ADD 136B 80 DUP1 136C 60 PUSH1 0x40 136E 52 MSTORE 136F 50 POP 1370 81 DUP2 1371 01 ADD 1372 90 SWAP1 1373 61 PUSH2 0x137c 1376 91 SWAP2 1377 90 SWAP1 1378 61 PUSH2 0x25ff 137B 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @136E memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @1376 stack[-4] = 0x137c // @1377 stack[-2] = memory[0x40:0x60] // @1377 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x25ff 137C 5B JUMPDEST 137D 61 PUSH2 0x10b7 1380 57 *JUMPI 1381 60 PUSH1 0x40 1383 51 MLOAD 1384 63 PUSH4 0x3b79c773 1389 60 PUSH1 0xe2 138B 1B SHL 138C 81 DUP2 138D 52 MSTORE 138E 60 PUSH1 0x01 1390 60 PUSH1 0x01 1392 60 PUSH1 0xa0 1394 1B SHL 1395 03 SUB 1396 82 DUP3 1397 16 AND 1398 60 PUSH1 0x04 139A 82 DUP3 139B 01 ADD 139C 52 MSTORE 139D 60 PUSH1 0x24 139F 01 ADD 13A0 61 PUSH2 0x10a5 13A3 56 *JUMP 13A4 5B JUMPDEST 13A5 61 PUSH2 0x0779 13A8 82 DUP3 13A9 82 DUP3 13AA 60 PUSH1 0x01 13AC 61 PUSH2 0x1ba3 13AF 56 *JUMP label_13B0: // Incoming call from 0x0976, returns to 0x0977 // Inputs[1] { @13B6 stack[-1] } 13B0 5B JUMPDEST 13B1 60 PUSH1 0x00 13B3 61 PUSH2 0x13bb 13B6 82 DUP3 13B7 61 PUSH2 0x15cb 13BA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @13B1 stack[0] = 0x00 // @13B3 stack[1] = 0x13bb // @13B6 stack[2] = stack[-1] // } // Block ends with call to 0x15cb, returns to 0x13BB label_13BB: // Incoming return from call to 0x15CB at 0x13BA // Inputs[3] // { // @13C4 stack[-5] // @13C8 stack[-1] // @13C9 stack[-2] // } 13BB 5B JUMPDEST 13BC 60 PUSH1 0x01 13BE 60 PUSH1 0x01 13C0 60 PUSH1 0xa0 13C2 1B SHL 13C3 03 SUB 13C4 94 SWAP5 13C5 85 DUP6 13C6 16 AND 13C7 94 SWAP5 13C8 90 SWAP1 13C9 91 SWAP2 13CA 50 POP 13CB 81 DUP2 13CC 16 AND 13CD 84 DUP5 13CE 14 EQ 13CF 61 PUSH2 0x13e1 13D2 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @13C7 stack[-5] = (0x01 << 0xa0) - 0x01 & stack[-5] // @13C9 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x13e1, if (0x01 << 0xa0) - 0x01 & stack[-5] == stack[-1] & (0x01 << 0xa0) - 0x01 label_13D3: // Incoming jump from 0x13D2, if not (0x01 << 0xa0) - 0x01 & stack[-5] == stack[-1] & (0x01 << 0xa0) - 0x01 13D3 61 PUSH2 0x13e1 13D6 62 PUSH3 0xa11481 13DA 60 PUSH1 0xe8 13DC 1B SHL 13DD 61 PUSH2 0x12e1 13E0 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13D3 stack[0] = 0x13e1 // @13DC stack[1] = 0xa11481 << 0xe8 // } // Block ends with unconditional jump to 0x12e1 label_13E1: // Incoming jump from 0x13D2, if (0x01 << 0xa0) - 0x01 & stack[-5] == stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[5] // { // @13E4 stack[-2] // @13EF memory[0x00:0x40] // @13F1 storage[keccak256(memory[0x00:0x40])] // @13F2 msg.sender // @13FE stack[-4] // } 13E1 5B JUMPDEST 13E2 60 PUSH1 0x00 13E4 82 DUP3 13E5 81 DUP2 13E6 52 MSTORE 13E7 60 PUSH1 0x07 13E9 60 PUSH1 0x20 13EB 52 MSTORE 13EC 60 PUSH1 0x40 13EE 90 SWAP1 13EF 20 SHA3 13F0 80 DUP1 13F1 54 SLOAD 13F2 33 CALLER 13F3 80 DUP1 13F4 82 DUP3 13F5 14 EQ 13F6 60 PUSH1 0x01 13F8 60 PUSH1 0x01 13FA 60 PUSH1 0xa0 13FC 1B SHL 13FD 03 SUB 13FE 88 DUP9 13FF 16 AND 1400 90 SWAP1 1401 91 SWAP2 1402 14 EQ 1403 17 OR 1404 61 PUSH2 0x1425 1407 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @13E6 memory[0x00:0x20] = stack[-2] // @13EB memory[0x20:0x40] = 0x07 // @13EF stack[0] = keccak256(memory[0x00:0x40]) // @13F1 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1425, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) label_1408: // Incoming jump from 0x1407, if not (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[2] // { // @140B stack[-6] // @140C msg.sender // } 1408 61 PUSH2 0x1411 140B 86 DUP7 140C 33 CALLER 140D 61 PUSH2 0x06f9 1410 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1408 stack[0] = 0x1411 // @140B stack[1] = stack[-6] // @140C stack[2] = msg.sender // } // Block ends with call to 0x06f9, returns to 0x1411 label_1411: // Incoming return from call to 0x06F9 at 0x1410 // Inputs[1] { @1415 stack[-1] } 1411 5B JUMPDEST 1412 61 PUSH2 0x1425 1415 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1425, if stack[-1] label_1416: // Incoming jump from 0x1415, if not stack[-1] 1416 61 PUSH2 0x1425 1419 63 PUSH4 0x2ce44b5f 141E 60 PUSH1 0xe1 1420 1B SHL 1421 61 PUSH2 0x12e1 1424 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1416 stack[0] = 0x1425 // @1420 stack[1] = 0x2ce44b5f << 0xe1 // } // Block ends with unconditional jump to 0x12e1 label_1425: // Incoming jump from 0x1415, if stack[-1] // Incoming jump from 0x1407, if (msg.sender == stack[-4] & (0x01 << 0xa0) - 0x01) | (storage[keccak256(memory[0x00:0x40])] == msg.sender) // Inputs[1] { @1426 stack[-1] } 1425 5B JUMPDEST 1426 80 DUP1 1427 15 ISZERO 1428 61 PUSH2 0x1430 142B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1430, if !stack[-1] label_142C: // Incoming jump from 0x142B, if not !stack[-1] // Inputs[11] // { // @142E stack[-2] // @1439 stack[-6] // @144A memory[0x00:0x40] // @144C storage[keccak256(memory[0x00:0x40])] // @1454 stack[-5] // @145B memory[0x00:0x40] // @145D storage[keccak256(memory[0x00:0x40])] // @1463 block.timestamp // @1470 stack[-4] // @147B memory[0x00:0x40] // @1485 stack[-3] // } 142C 60 PUSH1 0x00 142E 82 DUP3 142F 55 SSTORE 1430 5B JUMPDEST 1431 60 PUSH1 0x01 1433 60 PUSH1 0x01 1435 60 PUSH1 0xa0 1437 1B SHL 1438 03 SUB 1439 86 DUP7 143A 81 DUP2 143B 16 AND 143C 60 PUSH1 0x00 143E 90 SWAP1 143F 81 DUP2 1440 52 MSTORE 1441 60 PUSH1 0x06 1443 60 PUSH1 0x20 1445 52 MSTORE 1446 60 PUSH1 0x40 1448 80 DUP1 1449 82 DUP3 144A 20 SHA3 144B 80 DUP1 144C 54 SLOAD 144D 60 PUSH1 0x00 144F 19 NOT 1450 01 ADD 1451 90 SWAP1 1452 55 SSTORE 1453 91 SWAP2 1454 87 DUP8 1455 16 AND 1456 80 DUP1 1457 82 DUP3 1458 52 MSTORE 1459 91 SWAP2 145A 90 SWAP1 145B 20 SHA3 145C 80 DUP1 145D 54 SLOAD 145E 60 PUSH1 0x01 1460 01 ADD 1461 90 SWAP1 1462 55 SSTORE 1463 42 TIMESTAMP 1464 60 PUSH1 0xa0 1466 1B SHL 1467 17 OR 1468 60 PUSH1 0x01 146A 60 PUSH1 0xe1 146C 1B SHL 146D 17 OR 146E 60 PUSH1 0x00 1470 85 DUP6 1471 81 DUP2 1472 52 MSTORE 1473 60 PUSH1 0x05 1475 60 PUSH1 0x20 1477 52 MSTORE 1478 60 PUSH1 0x40 147A 81 DUP2 147B 20 SHA3 147C 91 SWAP2 147D 90 SWAP1 147E 91 SWAP2 147F 55 SSTORE 1480 60 PUSH1 0x01 1482 60 PUSH1 0xe1 1484 1B SHL 1485 84 DUP5 1486 16 AND 1487 90 SWAP1 1488 03 SUB 1489 61 PUSH2 0x14c2 148C 57 *JUMPI // Stack delta = +0 // Outputs[9] // { // @142F storage[stack[-2]] = 0x00 // @1440 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-6] // @1445 memory[0x20:0x40] = 0x06 // @1452 storage[keccak256(memory[0x00:0x40])] = ~0x00 + storage[keccak256(memory[0x00:0x40])] // @1458 memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @1462 storage[keccak256(memory[0x00:0x40])] = 0x01 + storage[keccak256(memory[0x00:0x40])] // @1472 memory[0x00:0x20] = stack[-4] // @1477 memory[0x20:0x40] = 0x05 // @147F storage[keccak256(memory[0x00:0x40])] = (0x01 << 0xe1) | (block.timestamp << 0xa0) | (stack[-5] & (0x01 << 0xa0) - 0x01) // } // Block ends with conditional jump to 0x14c2, if 0x00 - (stack[-3] & (0x01 << 0xe1)) label_148D: // Incoming jump from 0x148C, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x148C, if not 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[3] // { // @148F stack[-4] // @149E memory[0x00:0x40] // @149F storage[keccak256(memory[0x00:0x40])] // } 148D 60 PUSH1 0x01 148F 84 DUP5 1490 01 ADD 1491 60 PUSH1 0x00 1493 81 DUP2 1494 81 DUP2 1495 52 MSTORE 1496 60 PUSH1 0x05 1498 60 PUSH1 0x20 149A 52 MSTORE 149B 60 PUSH1 0x40 149D 81 DUP2 149E 20 SHA3 149F 54 SLOAD 14A0 90 SWAP1 14A1 03 SUB 14A2 61 PUSH2 0x14c0 14A5 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1490 stack[0] = stack[-4] + 0x01 // @1495 memory[0x00:0x20] = stack[-4] + 0x01 // @149A memory[0x20:0x40] = 0x05 // } // Block ends with conditional jump to 0x14c0, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_14A6: // Incoming jump from 0x14A5, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @14A8 storage[0x01] // @14A9 stack[-1] // } 14A6 60 PUSH1 0x01 14A8 54 SLOAD 14A9 81 DUP2 14AA 14 EQ 14AB 61 PUSH2 0x14c0 14AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x14c0, if stack[-1] == storage[0x01] label_14AF: // Incoming jump from 0x14AE, if not stack[-1] == storage[0x01] // Inputs[3] // { // @14B1 stack[-1] // @14BC memory[0x00:0x40] // @14BD stack[-4] // } 14AF 60 PUSH1 0x00 14B1 81 DUP2 14B2 81 DUP2 14B3 52 MSTORE 14B4 60 PUSH1 0x05 14B6 60 PUSH1 0x20 14B8 52 MSTORE 14B9 60 PUSH1 0x40 14BB 90 SWAP1 14BC 20 SHA3 14BD 84 DUP5 14BE 90 SWAP1 14BF 55 SSTORE // Stack delta = +0 // Outputs[3] // { // @14B3 memory[0x00:0x20] = stack[-1] // @14B8 memory[0x20:0x40] = 0x05 // @14BF storage[keccak256(memory[0x00:0x40])] = stack[-4] // } // Block continues label_14C0: // Incoming jump from 0x14AE, if stack[-1] == storage[0x01] // Incoming jump from 0x14BF // Incoming jump from 0x14A5, if 0x00 - storage[keccak256(memory[0x00:0x40])] 14C0 5B JUMPDEST 14C1 50 POP // Stack delta = -1 // Block continues label_14C2: // Incoming jump from 0x14C1 // Incoming jump from 0x148C, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Incoming jump from 0x148C, if 0x00 - (stack[-3] & (0x01 << 0xe1)) // Inputs[6] // { // @14CB stack[-5] // @14CD stack[-4] // @14CF stack[-6] // @14D3 memory[0x00:0x20] // @14DC memory[0x00:0x20] // @14E2 memory[0x00:0x00] // } 14C2 5B JUMPDEST 14C3 60 PUSH1 0x01 14C5 60 PUSH1 0x01 14C7 60 PUSH1 0xa0 14C9 1B SHL 14CA 03 SUB 14CB 85 DUP6 14CC 16 AND 14CD 84 DUP5 14CE 81 DUP2 14CF 88 DUP9 14D0 60 PUSH1 0x00 14D2 80 DUP1 14D3 51 MLOAD 14D4 60 PUSH1 0x20 14D6 61 PUSH2 0x26d5 14D9 83 DUP4 14DA 39 CODECOPY 14DB 81 DUP2 14DC 51 MLOAD 14DD 91 SWAP2 14DE 52 MSTORE 14DF 60 PUSH1 0x00 14E1 80 DUP1 14E2 A4 LOG4 14E3 80 DUP1 14E4 60 PUSH1 0x00 14E6 03 SUB 14E7 61 PUSH2 0x14fa 14EA 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @14CC stack[0] = stack[-5] & (0x01 << 0xa0) - 0x01 // @14DA memory[0x00:0x20] = code[0x26d5:0x26f5] // @14DE memory[0x00:0x20] = memory[0x00:0x20] // @14E2 log(memory[0x00:0x00], [memory[0x00:0x20], stack[-6], stack[-5] & (0x01 << 0xa0) - 0x01, stack[-4]]); // } // Block ends with conditional jump to 0x14fa, if 0x00 - (stack[-5] & (0x01 << 0xa0) - 0x01) label_14EB: // Incoming jump from 0x14EA, if not 0x00 - (stack[-5] & (0x01 << 0xa0) - 0x01) 14EB 61 PUSH2 0x14fa 14EE 63 PUSH4 0x3a954ecd 14F3 60 PUSH1 0xe2 14F5 1B SHL 14F6 61 PUSH2 0x12e1 14F9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @14EB stack[0] = 0x14fa // @14F5 stack[1] = 0x3a954ecd << 0xe2 // } // Block ends with unconditional jump to 0x12e1 label_14FA: // Incoming jump from 0x14EA, if 0x00 - (stack[-5] & (0x01 << 0xa0) - 0x01) // Inputs[1] { @1502 stack[-8] } 14FA 5B JUMPDEST 14FB 50 POP 14FC 50 POP 14FD 50 POP 14FE 50 POP 14FF 50 POP 1500 50 POP 1501 50 POP 1502 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_1503: // Incoming jump from 0x0B7F // Inputs[4] // { // @1507 stack[-3] // @1508 stack[-2] // @1509 stack[-1] // @150C memory[0x40:0x60] // } 1503 5B JUMPDEST 1504 61 PUSH2 0x085e 1507 83 DUP4 1508 83 DUP4 1509 83 DUP4 150A 60 PUSH1 0x40 150C 51 MLOAD 150D 80 DUP1 150E 60 PUSH1 0x20 1510 01 ADD 1511 60 PUSH1 0x40 1513 52 MSTORE 1514 80 DUP1 1515 60 PUSH1 0x00 1517 81 DUP2 1518 52 MSTORE 1519 50 POP 151A 61 PUSH2 0x0d47 151D 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1504 stack[0] = 0x085e // @1507 stack[1] = stack[-3] // @1508 stack[2] = stack[-2] // @1509 stack[3] = stack[-1] // @150C stack[4] = memory[0x40:0x60] // @1513 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1518 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0d47 label_151E: // Incoming call from 0x103B, returns to 0x0977 // Inputs[2] // { // @1521 storage[0x01] // @1524 stack[-1] // } 151E 5B JUMPDEST 151F 60 PUSH1 0x01 1521 54 SLOAD 1522 60 PUSH1 0x00 1524 82 DUP3 1525 90 SWAP1 1526 03 SUB 1527 61 PUSH2 0x153a 152A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1521 stack[0] = storage[0x01] } // Block ends with conditional jump to 0x153a, if 0x00 - stack[-1] label_152B: // Incoming jump from 0x152A, if not 0x00 - stack[-1] 152B 61 PUSH2 0x153a 152E 63 PUSH4 0xb562e8dd 1533 60 PUSH1 0xe0 1535 1B SHL 1536 61 PUSH2 0x12e1 1539 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @152B stack[0] = 0x153a // @1535 stack[1] = 0xb562e8dd << 0xe0 // } // Block ends with unconditional jump to 0x12e1 label_153A: // Incoming jump from 0x152A, if 0x00 - stack[-1] // Inputs[7] // { // @153D stack[-1] // @154B memory[0x00:0x40] // @1554 stack[-3] // @1556 block.timestamp // @155C stack[-2] // @1570 memory[0x00:0x40] // @1572 storage[keccak256(memory[0x00:0x40])] // } 153A 5B JUMPDEST 153B 60 PUSH1 0x00 153D 81 DUP2 153E 81 DUP2 153F 52 MSTORE 1540 60 PUSH1 0x05 1542 60 PUSH1 0x20 1544 90 SWAP1 1545 81 DUP2 1546 52 MSTORE 1547 60 PUSH1 0x40 1549 80 DUP1 154A 83 DUP4 154B 20 SHA3 154C 60 PUSH1 0x01 154E 60 PUSH1 0x01 1550 60 PUSH1 0xa0 1552 1B SHL 1553 03 SUB 1554 87 DUP8 1555 16 AND 1556 42 TIMESTAMP 1557 60 PUSH1 0xa0 1559 1B SHL 155A 60 PUSH1 0x01 155C 88 DUP9 155D 14 EQ 155E 60 PUSH1 0xe1 1560 1B SHL 1561 17 OR 1562 81 DUP2 1563 17 OR 1564 90 SWAP1 1565 91 SWAP2 1566 55 SSTORE 1567 80 DUP1 1568 84 DUP5 1569 52 MSTORE 156A 60 PUSH1 0x06 156C 90 SWAP1 156D 92 SWAP3 156E 52 MSTORE 156F 82 DUP3 1570 20 SHA3 1571 80 DUP1 1572 54 SLOAD 1573 68 PUSH9 0x010000000000000001 157D 86 DUP7 157E 02 MUL 157F 01 ADD 1580 90 SWAP1 1581 55 SSTORE 1582 90 SWAP1 1583 81 DUP2 1584 90 SWAP1 1585 03 SUB 1586 61 PUSH2 0x1598 1589 57 *JUMPI // Stack delta = +1 // Outputs[7] // { // @153F memory[0x00:0x20] = stack[-1] // @1546 memory[0x20:0x40] = 0x05 // @1566 storage[keccak256(memory[0x00:0x40])] = (stack[-3] & (0x01 << 0xa0) - 0x01) | ((stack[-2] == 0x01) << 0xe1) | (block.timestamp << 0xa0) // @1569 memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @156E memory[0x20:0x40] = 0x06 // @1581 storage[keccak256(memory[0x00:0x40])] = stack[-2] * 0x010000000000000001 + storage[keccak256(memory[0x00:0x40])] // @1582 stack[0] = stack[-3] & (0x01 << 0xa0) - 0x01 // } // Block ends with conditional jump to 0x1598, if 0x00 - (stack[-3] & (0x01 << 0xa0) - 0x01) label_158A: // Incoming jump from 0x1589, if not 0x00 - (stack[-3] & (0x01 << 0xa0) - 0x01) 158A 61 PUSH2 0x1598 158D 62 PUSH3 0x2e0763 1591 60 PUSH1 0xe8 1593 1B SHL 1594 61 PUSH2 0x12e1 1597 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @158A stack[0] = 0x1598 // @1593 stack[1] = 0x2e0763 << 0xe8 // } // Block ends with unconditional jump to 0x12e1 label_1598: // Incoming jump from 0x1589, if 0x00 - (stack[-3] & (0x01 << 0xa0) - 0x01) // Inputs[6] // { // @1599 stack[-2] // @159A stack[-3] // @159F stack[-1] // @15A5 memory[0x00:0x20] // @15AE memory[0x00:0x20] // @15B4 memory[0x00:0x00] // } 1598 5B JUMPDEST 1599 81 DUP2 159A 83 DUP4 159B 01 ADD 159C 82 DUP3 159D 5B JUMPDEST 159E 80 DUP1 159F 83 DUP4 15A0 60 PUSH1 0x00 15A2 60 PUSH1 0x00 15A4 80 DUP1 15A5 51 MLOAD 15A6 60 PUSH1 0x20 15A8 61 PUSH2 0x26d5 15AB 83 DUP4 15AC 39 CODECOPY 15AD 81 DUP2 15AE 51 MLOAD 15AF 91 SWAP2 15B0 52 MSTORE 15B1 60 PUSH1 0x00 15B3 80 DUP1 15B4 A4 LOG4 15B5 81 DUP2 15B6 81 DUP2 15B7 60 PUSH1 0x01 15B9 01 ADD 15BA 91 SWAP2 15BB 50 POP 15BC 81 DUP2 15BD 03 SUB 15BE 61 PUSH2 0x159d 15C1 57 *JUMPI // Stack delta = +2 // Outputs[5] // { // @159B stack[0] = stack[-3] + stack[-2] // @15AC memory[0x00:0x20] = code[0x26d5:0x26f5] // @15B0 memory[0x00:0x20] = memory[0x00:0x20] // @15B4 log(memory[0x00:0x00], [memory[0x00:0x20], 0x00, stack[-1], stack[-2]]); // @15BA stack[1] = 0x01 + stack[-2] // } // Block ends with conditional jump to 0x159d, if (0x01 + stack[-2]) - (stack[-3] + stack[-2]) label_15C2: // Incoming jump from 0x15C1, if not (0x01 + stack[-1]) - stack[-2] // Incoming jump from 0x15C1, if not (0x01 + stack[-2]) - (stack[-3] + stack[-2]) // Inputs[2] // { // @15C5 stack[-2] // @15CA stack[-7] // } 15C2 50 POP 15C3 60 PUSH1 0x01 15C5 55 SSTORE 15C6 50 POP 15C7 50 POP 15C8 50 POP 15C9 50 POP 15CA 56 *JUMP // Stack delta = -7 // Outputs[1] { @15C5 storage[0x01] = stack[-2] } // Block ends with unconditional jump to stack[-7] label_15CB: // Incoming call from 0x0C23, returns to 0x0761 // Incoming call from 0x13BA, returns to 0x13BB // Inputs[1] { @15CE stack[-1] } 15CB 5B JUMPDEST 15CC 60 PUSH1 0x00 15CE 81 DUP2 15CF 61 PUSH2 0x059c 15D2 11 GT 15D3 61 PUSH2 0x165d 15D6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @15CC stack[0] = 0x00 } // Block ends with conditional jump to 0x165d, if 0x059c > stack[-1] label_15D7: // Incoming jump from 0x15D6, if not 0x059c > stack[-1] // Inputs[3] // { // @15DA stack[-2] // @15E5 memory[0x00:0x40] // @15E6 storage[keccak256(memory[0x00:0x40])] // } 15D7 50 POP 15D8 60 PUSH1 0x00 15DA 81 DUP2 15DB 81 DUP2 15DC 52 MSTORE 15DD 60 PUSH1 0x05 15DF 60 PUSH1 0x20 15E1 52 MSTORE 15E2 60 PUSH1 0x40 15E4 81 DUP2 15E5 20 SHA3 15E6 54 SLOAD 15E7 90 SWAP1 15E8 81 DUP2 15E9 90 SWAP1 15EA 03 SUB 15EB 61 PUSH2 0x164a 15EE 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @15DC memory[0x00:0x20] = stack[-2] // @15E1 memory[0x20:0x40] = 0x05 // @15E7 stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x164a, if 0x00 - storage[keccak256(memory[0x00:0x40])] label_15EF: // Incoming jump from 0x15EE, if not 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @15F1 storage[0x01] // @15F2 stack[-2] // } 15EF 60 PUSH1 0x01 15F1 54 SLOAD 15F2 82 DUP3 15F3 10 LT 15F4 61 PUSH2 0x1607 15F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1607, if stack[-2] < storage[0x01] label_15F8: // Incoming jump from 0x15F7, if not stack[-2] < storage[0x01] 15F8 61 PUSH2 0x1607 15FB 63 PUSH4 0x6f96cda1 1600 60 PUSH1 0xe1 1602 1B SHL 1603 61 PUSH2 0x12e1 1606 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @15F8 stack[0] = 0x1607 // @1602 stack[1] = 0x6f96cda1 << 0xe1 // } // Block ends with unconditional jump to 0x12e1 label_1607: // Incoming jump from 0x15F7, if stack[-2] < storage[0x01] // Inputs[3] // { // @160D stack[-2] // @161B memory[0x00:0x40] // @161C storage[keccak256(memory[0x00:0x40])] // } 1607 5B JUMPDEST 1608 5B JUMPDEST 1609 50 POP 160A 60 PUSH1 0x00 160C 19 NOT 160D 01 ADD 160E 60 PUSH1 0x00 1610 81 DUP2 1611 81 DUP2 1612 52 MSTORE 1613 60 PUSH1 0x05 1615 60 PUSH1 0x20 1617 52 MSTORE 1618 60 PUSH1 0x40 161A 90 SWAP1 161B 20 SHA3 161C 54 SLOAD 161D 80 DUP1 161E 15 ISZERO 161F 61 PUSH2 0x1608 1622 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @160D stack[-2] = ~0x00 + stack[-2] // @1612 memory[0x00:0x20] = ~0x00 + stack[-2] // @1617 memory[0x20:0x40] = 0x05 // @161C stack[-1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x1608, if !storage[keccak256(memory[0x00:0x40])] label_1623: // Incoming jump from 0x1622, if not !storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x1622, if not !storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1628 stack[-1] } 1623 60 PUSH1 0x01 1625 60 PUSH1 0xe0 1627 1B SHL 1628 81 DUP2 1629 16 AND 162A 60 PUSH1 0x00 162C 03 SUB 162D 61 PUSH2 0x1635 1630 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1635, if 0x00 - (stack[-1] & (0x01 << 0xe0)) label_1631: // Incoming jump from 0x1630, if not 0x00 - (stack[-1] & (0x01 << 0xe0)) // Inputs[3] // { // @1631 stack[-1] // @1631 stack[-3] // @1632 stack[-2] // } 1631 91 SWAP2 1632 90 SWAP1 1633 50 POP 1634 56 *JUMP // Stack delta = -2 // Outputs[1] { @1631 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_1635: // Incoming jump from 0x1630, if 0x00 - (stack[-1] & (0x01 << 0xe0)) 1635 5B JUMPDEST 1636 61 PUSH2 0x1645 1639 63 PUSH4 0x6f96cda1 163E 60 PUSH1 0xe1 1640 1B SHL 1641 61 PUSH2 0x12e1 1644 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1636 stack[0] = 0x1645 // @1640 stack[1] = 0x6f96cda1 << 0xe1 // } // Block ends with unconditional jump to 0x12e1 1645 5B JUMPDEST 1646 61 PUSH2 0x1608 1649 56 *JUMP label_164A: // Incoming jump from 0x15EE, if 0x00 - storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1650 stack[-1] } 164A 5B JUMPDEST 164B 60 PUSH1 0x01 164D 60 PUSH1 0xe0 164F 1B SHL 1650 81 DUP2 1651 16 AND 1652 60 PUSH1 0x00 1654 03 SUB 1655 61 PUSH2 0x165d 1658 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x165d, if 0x00 - (stack[-1] & (0x01 << 0xe0)) label_1659: // Incoming jump from 0x1658, if not 0x00 - (stack[-1] & (0x01 << 0xe0)) // Inputs[3] // { // @1659 stack[-1] // @1659 stack[-3] // @165A stack[-2] // } 1659 91 SWAP2 165A 90 SWAP1 165B 50 POP 165C 56 *JUMP // Stack delta = -2 // Outputs[1] { @1659 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_165D: // Incoming jump from 0x15D6, if 0x059c > stack[-1] // Incoming jump from 0x1658, if 0x00 - (stack[-1] & (0x01 << 0xe0)) 165D 5B JUMPDEST 165E 61 PUSH2 0x0eb7 1661 63 PUSH4 0x6f96cda1 1666 60 PUSH1 0xe1 1668 1B SHL 1669 61 PUSH2 0x12e1 166C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @165E stack[0] = 0x0eb7 // @1668 stack[1] = 0x6f96cda1 << 0xe1 // } // Block ends with unconditional jump to 0x12e1 label_166D: // Incoming call from 0x0CED, returns to 0x0B59 // Incoming call from 0x10B6, returns to 0x10B7 // Inputs[5] // { // @1671 storage[0x00] // @167A stack[-1] // @168E memory[0x40:0x60] // @16B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @16BC stack[-2] // } 166D 5B JUMPDEST 166E 60 PUSH1 0x00 1670 80 DUP1 1671 54 SLOAD 1672 60 PUSH1 0x01 1674 60 PUSH1 0x01 1676 60 PUSH1 0xa0 1678 1B SHL 1679 03 SUB 167A 83 DUP4 167B 81 DUP2 167C 16 AND 167D 60 PUSH1 0x01 167F 60 PUSH1 0x01 1681 60 PUSH1 0xa0 1683 1B SHL 1684 03 SUB 1685 19 NOT 1686 83 DUP4 1687 16 AND 1688 81 DUP2 1689 17 OR 168A 84 DUP5 168B 55 SSTORE 168C 60 PUSH1 0x40 168E 51 MLOAD 168F 91 SWAP2 1690 90 SWAP1 1691 92 SWAP3 1692 16 AND 1693 92 SWAP3 1694 83 DUP4 1695 91 SWAP2 1696 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 16B7 91 SWAP2 16B8 90 SWAP1 16B9 A3 LOG3 16BA 50 POP 16BB 50 POP 16BC 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @168B storage[0x00] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x00] & ~((0x01 << 0xa0) - 0x01)) // @16B9 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x00] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_16BD: // Incoming call from 0x0D32, returns to 0x0D0F // Incoming call from 0x0D0B, returns to 0x0D0C // Inputs[2] // { // @16C0 stack[-1] // @16C1 stack[-2] // } 16BD 5B JUMPDEST 16BE 60 PUSH1 0x60 16C0 81 DUP2 16C1 83 DUP4 16C2 10 LT 16C3 61 PUSH2 0x16d6 16C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @16BE stack[0] = 0x60 } // Block ends with conditional jump to 0x16d6, if stack[-2] < stack[-1] label_16C7: // Incoming jump from 0x16C6, if not stack[-2] < stack[-1] 16C7 61 PUSH2 0x16d6 16CA 63 PUSH4 0x1960ccad 16CF 60 PUSH1 0xe1 16D1 1B SHL 16D2 61 PUSH2 0x12e1 16D5 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @16C7 stack[0] = 0x16d6 // @16D1 stack[1] = 0x1960ccad << 0xe1 // } // Block ends with unconditional jump to 0x12e1 label_16D6: // Incoming jump from 0x16C6, if stack[-2] < stack[-1] // Inputs[1] { @16DA stack[-3] } 16D6 5B JUMPDEST 16D7 61 PUSH2 0x059c 16DA 83 DUP4 16DB 10 LT 16DC 15 ISZERO 16DD 61 PUSH2 0x16e6 16E0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x16e6, if !(stack[-3] < 0x059c) label_16E1: // Incoming jump from 0x16E0, if not !(stack[-3] < 0x059c) // Inputs[2] // { // @16E4 stack[-3] // @16EE storage[0x01] // } 16E1 61 PUSH2 0x059c 16E4 92 SWAP3 16E5 50 POP 16E6 5B JUMPDEST 16E7 60 PUSH1 0x00 16E9 61 PUSH2 0x16f1 16EC 60 PUSH1 0x01 16EE 54 SLOAD 16EF 90 SWAP1 16F0 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @16E4 stack[-3] = 0x059c // @16E7 stack[0] = 0x00 // @16EF stack[1] = storage[0x01] // } // Block ends with unconditional jump to 0x16f1 label_16F1: // Incoming jump from 0x16F0 // Incoming jump from 0x16F0 // Inputs[3] // { // @16F2 stack[-1] // @16F2 stack[-2] // @16F5 stack[-4] // } 16F1 5B JUMPDEST 16F2 90 SWAP1 16F3 50 POP 16F4 80 DUP1 16F5 83 DUP4 16F6 10 LT 16F7 61 PUSH2 0x16fe 16FA 57 *JUMPI // Stack delta = -1 // Outputs[1] { @16F2 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x16fe, if stack[-4] < stack[-1] label_16FB: // Incoming jump from 0x16FA, if not stack[-4] < stack[-1] // Inputs[3] // { // @16FB stack[-1] // @16FC stack[-3] // @1706 stack[-5] // } 16FB 80 DUP1 16FC 92 SWAP3 16FD 50 POP 16FE 5B JUMPDEST 16FF 60 PUSH1 0x60 1701 60 PUSH1 0x00 1703 61 PUSH2 0x170b 1706 87 DUP8 1707 61 PUSH2 0x0c97 170A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @16FC stack[-3] = stack[-1] // @16FF stack[0] = 0x60 // @1701 stack[1] = 0x00 // @1703 stack[2] = 0x170b // @1706 stack[3] = stack[-5] // } // Block ends with call to 0x0c97, returns to 0x170B label_170B: // Incoming return from call to 0x0C97 at 0x170A // Incoming return from call to 0x0C97 at 0x170A // Inputs[4] // { // @170C stack[-6] // @170D stack[-7] // @170F stack[-1] // @1712 stack[-2] // } 170B 5B JUMPDEST 170C 85 DUP6 170D 87 DUP8 170E 10 LT 170F 90 SWAP1 1710 81 DUP2 1711 02 MUL 1712 91 SWAP2 1713 50 POP 1714 81 DUP2 1715 15 ISZERO 1716 61 PUSH2 0x17bc 1719 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @170F stack[-1] = stack[-7] < stack[-6] // @1712 stack[-2] = (stack[-7] < stack[-6]) * stack[-1] // } // Block ends with conditional jump to 0x17bc, if !((stack[-7] < stack[-6]) * stack[-1]) label_171A: // Incoming jump from 0x1719, if not !((stack[-7] < stack[-6]) * stack[-1]) // Inputs[3] // { // @171A stack[-2] // @171B stack[-7] // @171C stack[-6] // } 171A 81 DUP2 171B 87 DUP8 171C 87 DUP8 171D 03 SUB 171E 11 GT 171F 61 PUSH2 0x1728 1722 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1728, if stack[-6] - stack[-7] > stack[-2] label_1723: // Incoming jump from 0x1722, if not stack[-6] - stack[-7] > stack[-2] // Inputs[5] // { // @1723 stack[-7] // @1724 stack[-6] // @1726 stack[-2] // @172B memory[0x40:0x60] // @172C stack[-3] // } 1723 86 DUP7 1724 86 DUP7 1725 03 SUB 1726 91 SWAP2 1727 50 POP 1728 5B JUMPDEST 1729 60 PUSH1 0x40 172B 51 MLOAD 172C 92 SWAP3 172D 50 POP 172E 60 PUSH1 0x01 1730 82 DUP3 1731 01 ADD 1732 60 PUSH1 0x05 1734 1B SHL 1735 83 DUP4 1736 01 ADD 1737 60 PUSH1 0x40 1739 52 MSTORE 173A 60 PUSH1 0x00 173C 61 PUSH2 0x1744 173F 88 DUP9 1740 61 PUSH2 0x0e57 1743 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @1726 stack[-2] = stack[-6] - stack[-7] // @172C stack[-3] = memory[0x40:0x60] // @1739 memory[0x40:0x60] = memory[0x40:0x60] + (stack[-6] - stack[-7] + 0x01 << 0x05) // @173A stack[0] = 0x00 // @173C stack[1] = 0x1744 // @173F stack[2] = stack[-7] // } // Block ends with call to 0x0e57, returns to 0x1744 label_1744: // Incoming return from call to 0x0E57 at 0x1743 // Incoming return from call to 0x0E57 at 0x1743 // Inputs[3] // { // @1745 stack[-1] // @1745 stack[-2] // @174D memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 1744 5B JUMPDEST 1745 90 SWAP1 1746 50 POP 1747 60 PUSH1 0x00 1749 81 DUP2 174A 60 PUSH1 0x40 174C 01 ADD 174D 51 MLOAD 174E 61 PUSH2 0x1755 1751 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1745 stack[-2] = stack[-1] // @1747 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x1755, if memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] label_1752: // Incoming jump from 0x1751, if not memory[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // Inputs[3] // { // @1753 stack[-2] // @1754 memory[stack[-2]:stack[-2] + 0x20] // @175C stack[-9] // } 1752 50 POP 1753 80 DUP1 1754 51 MLOAD 1755 5B JUMPDEST 1756 60 PUSH1 0x00 1758 5B JUMPDEST 1759 61 PUSH2 0x1761 175C 8A DUP11 175D 61 PUSH2 0x186f 1760 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1754 stack[-1] = memory[stack[-2]:stack[-2] + 0x20] // @1756 stack[0] = 0x00 // @1759 stack[1] = 0x1761 // @175C stack[2] = stack[-9] // } // Block ends with call to 0x186f, returns to 0x1761 label_1761: // Incoming return from call to 0x186F at 0x1760 // Incoming return from call to 0x186F at 0x1760 // Incoming return from call to 0x186F at 0x1760 // Inputs[3] // { // @1762 stack[-1] // @1762 stack[-4] // @1768 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // } 1761 5B JUMPDEST 1762 92 SWAP3 1763 50 POP 1764 60 PUSH1 0x40 1766 83 DUP4 1767 01 ADD 1768 51 MLOAD 1769 60 PUSH1 0x00 176B 81 DUP2 176C 14 EQ 176D 61 PUSH2 0x1779 1770 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1762 stack[-4] = stack[-1] // @1768 stack[-1] = memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x1779, if memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] == 0x00 label_1771: // Incoming jump from 0x1770, if not memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] == 0x00 // Inputs[1] { @1773 stack[-3] } 1771 60 PUSH1 0x00 1773 92 SWAP3 1774 50 POP 1775 61 PUSH2 0x179e 1778 56 *JUMP // Stack delta = +0 // Outputs[1] { @1773 stack[-3] = 0x00 } // Block ends with unconditional jump to 0x179e label_1779: // Incoming jump from 0x1770, if memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] == 0x00 // Inputs[2] // { // @177A stack[-4] // @177B memory[stack[-4]:stack[-4] + 0x20] // } 1779 5B JUMPDEST 177A 83 DUP4 177B 51 MLOAD 177C 15 ISZERO 177D 61 PUSH2 0x1785 1780 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1785, if !memory[stack[-4]:stack[-4] + 0x20] label_1781: // Incoming jump from 0x1780, if not !memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @1781 stack[-4] // @1782 memory[stack[-4]:stack[-4] + 0x20] // @1783 stack[-3] // @1786 stack[-12] // } 1781 83 DUP4 1782 51 MLOAD 1783 92 SWAP3 1784 50 POP 1785 5B JUMPDEST 1786 8B DUP12 1787 83 DUP4 1788 18 XOR 1789 60 PUSH1 0x60 178B 1B SHL 178C 61 PUSH2 0x179e 178F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1783 stack[-3] = memory[stack[-4]:stack[-4] + 0x20] } // Block ends with conditional jump to 0x179e, if (memory[stack[-4]:stack[-4] + 0x20] ~ stack[-12]) << 0x60 label_1790: // Incoming jump from 0x178F, if not (memory[stack[-4]:stack[-4] + 0x20] ~ stack[-12]) << 0x60 // Incoming jump from 0x178F, if not (stack[-3] ~ stack[-12]) << 0x60 // Inputs[4] // { // @1792 stack[-2] // @1796 stack[-11] // @179B stack[-7] // @17A6 stack[-10] // } 1790 60 PUSH1 0x01 1792 82 DUP3 1793 01 ADD 1794 91 SWAP2 1795 50 POP 1796 8A DUP11 1797 82 DUP3 1798 60 PUSH1 0x05 179A 1B SHL 179B 88 DUP9 179C 01 ADD 179D 52 MSTORE 179E 5B JUMPDEST 179F 50 POP 17A0 60 PUSH1 0x01 17A2 8A DUP11 17A3 01 ADD 17A4 99 SWAP10 17A5 50 POP 17A6 88 DUP9 17A7 8A DUP11 17A8 14 EQ 17A9 80 DUP1 17AA 61 PUSH2 0x17b2 17AD 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1794 stack[-2] = stack[-2] + 0x01 // @179D memory[stack[-7] + (stack[-2] + 0x01 << 0x05):stack[-7] + (stack[-2] + 0x01 << 0x05) + 0x20] = stack[-11] // @17A4 stack[-11] = stack[-11] + 0x01 // @17A8 stack[-1] = stack[-11] + 0x01 == stack[-10] // } // Block ends with conditional jump to 0x17b2, if stack[-11] + 0x01 == stack[-10] label_17AE: // Incoming jump from 0x17AD, if not stack[-11] + 0x01 == stack[-10] // Incoming jump from 0x17AD, if not stack[-11] + 0x01 == stack[-10] // Inputs[2] // { // @17AF stack[-6] // @17B0 stack[-2] // } 17AE 50 POP 17AF 84 DUP5 17B0 81 DUP2 17B1 14 EQ 17B2 5B JUMPDEST 17B3 15 ISZERO 17B4 61 PUSH2 0x1758 17B7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1758, if !(stack[-2] == stack[-6]) label_17B8: // Incoming jump from 0x17B7, if not !(stack[-2] == stack[-6]) // Incoming jump from 0x17B7, if not !stack[-1] // Inputs[2] // { // @17B8 stack[-6] // @17B9 stack[-1] // } 17B8 85 DUP6 17B9 52 MSTORE 17BA 50 POP 17BB 50 POP // Stack delta = -3 // Outputs[1] { @17B9 memory[stack[-6]:stack[-6] + 0x20] = stack[-1] } // Block continues label_17BC: // Incoming jump from 0x2181, if !(stack[-1] < stack[-2]) // Incoming jump from 0x1719, if !((stack[-7] < stack[-6]) * stack[-1]) // Incoming jump from 0x2181, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x21DE, if !(stack[-1] < stack[-2]) // Incoming jump from 0x17BB // Incoming jump from 0x21DE, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[4] // { // @17BE stack[-3] // @17BE stack[-2] // @17BF stack[-9] // @17C0 stack[-8] // } 17BC 5B JUMPDEST 17BD 50 POP 17BE 90 SWAP1 17BF 96 SWAP7 17C0 95 SWAP6 17C1 50 POP 17C2 50 POP 17C3 50 POP 17C4 50 POP 17C5 50 POP 17C6 50 POP 17C7 56 *JUMP // Stack delta = -8 // Outputs[1] { @17BF stack[-9] = stack[-3] } // Block ends with unconditional jump to stack[-9] 17C8 5B JUMPDEST 17C9 33 CALLER 17CA 60 PUSH1 0x00 17CC 81 DUP2 17CD 81 DUP2 17CE 52 MSTORE 17CF 60 PUSH1 0x08 17D1 60 PUSH1 0x20 17D3 90 SWAP1 17D4 81 DUP2 17D5 52 MSTORE 17D6 60 PUSH1 0x40 17D8 80 DUP1 17D9 83 DUP4 17DA 20 SHA3 17DB 60 PUSH1 0x01 17DD 60 PUSH1 0x01 17DF 60 PUSH1 0xa0 17E1 1B SHL 17E2 03 SUB 17E3 87 DUP8 17E4 16 AND 17E5 80 DUP1 17E6 85 DUP6 17E7 52 MSTORE 17E8 90 SWAP1 17E9 83 DUP4 17EA 52 MSTORE 17EB 92 SWAP3 17EC 81 DUP2 17ED 90 SWAP1 17EE 20 SHA3 17EF 80 DUP1 17F0 54 SLOAD 17F1 60 PUSH1 0xff 17F3 19 NOT 17F4 16 AND 17F5 86 DUP7 17F6 15 ISZERO 17F7 15 ISZERO 17F8 90 SWAP1 17F9 81 DUP2 17FA 17 OR 17FB 90 SWAP1 17FC 91 SWAP2 17FD 55 SSTORE 17FE 90 SWAP1 17FF 51 MLOAD 1800 90 SWAP1 1801 81 DUP2 1802 52 MSTORE 1803 91 SWAP2 1804 92 SWAP3 1805 91 SWAP2 1806 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1827 91 SWAP2 1828 01 ADD 1829 60 PUSH1 0x40 182B 51 MLOAD 182C 80 DUP1 182D 91 SWAP2 182E 03 SUB 182F 90 SWAP1 1830 A3 LOG3 1831 50 POP 1832 50 POP 1833 56 *JUMP label_1834: // Incoming jump from 0x0D6C // Inputs[3] // { // @1838 stack[-4] // @1839 stack[-3] // @183A stack[-2] // } 1834 5B JUMPDEST 1835 61 PUSH2 0x183f 1838 84 DUP5 1839 84 DUP5 183A 84 DUP5 183B 61 PUSH2 0x0952 183E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1835 stack[0] = 0x183f // @1838 stack[1] = stack[-4] // @1839 stack[2] = stack[-3] // @183A stack[3] = stack[-2] // } // Block ends with unconditional jump to 0x0952 183F 5B JUMPDEST 1840 60 PUSH1 0x01 1842 60 PUSH1 0x01 1844 60 PUSH1 0xa0 1846 1B SHL 1847 03 SUB 1848 83 DUP4 1849 16 AND 184A 3B EXTCODESIZE 184B 15 ISZERO 184C 61 PUSH2 0x0977 184F 57 *JUMPI 1850 61 PUSH2 0x185b 1853 84 DUP5 1854 84 DUP5 1855 84 DUP5 1856 84 DUP5 1857 61 PUSH2 0x1c46 185A 56 *JUMP 185B 5B JUMPDEST 185C 61 PUSH2 0x0977 185F 57 *JUMPI 1860 61 PUSH2 0x0977 1863 63 PUSH4 0x68d2bf6b 1868 60 PUSH1 0xe1 186A 1B SHL 186B 61 PUSH2 0x12e1 186E 56 *JUMP label_186F: // Incoming call from 0x0EB6, returns to 0x0761 // Incoming call from 0x1760, returns to 0x1761 // Incoming call from 0x1760, returns to 0x1761 // Incoming call from 0x1760, returns to 0x1761 // Inputs[5] // { // @1873 memory[0x40:0x60] // @1896 stack[-1] // @18A1 memory[0x00:0x40] // @18A2 storage[keccak256(memory[0x00:0x40])] // @18AA memory[0x40:0x60] // } 186F 5B JUMPDEST 1870 60 PUSH1 0x40 1872 80 DUP1 1873 51 MLOAD 1874 60 PUSH1 0x80 1876 81 DUP2 1877 01 ADD 1878 82 DUP3 1879 52 MSTORE 187A 60 PUSH1 0x00 187C 80 DUP1 187D 82 DUP3 187E 52 MSTORE 187F 60 PUSH1 0x20 1881 82 DUP3 1882 01 ADD 1883 81 DUP2 1884 90 SWAP1 1885 52 MSTORE 1886 91 SWAP2 1887 81 DUP2 1888 01 ADD 1889 82 DUP3 188A 90 SWAP1 188B 52 MSTORE 188C 60 PUSH1 0x60 188E 81 DUP2 188F 01 ADD 1890 91 SWAP2 1891 90 SWAP1 1892 91 SWAP2 1893 52 MSTORE 1894 60 PUSH1 0x00 1896 82 DUP3 1897 81 DUP2 1898 52 MSTORE 1899 60 PUSH1 0x05 189B 60 PUSH1 0x20 189D 52 MSTORE 189E 60 PUSH1 0x40 18A0 90 SWAP1 18A1 20 SHA3 18A2 54 SLOAD 18A3 61 PUSH2 0x0761 18A6 90 SWAP1 18A7 60 PUSH1 0x40 18A9 80 DUP1 18AA 51 MLOAD 18AB 60 PUSH1 0x80 18AD 81 DUP2 18AE 01 ADD 18AF 82 DUP3 18B0 52 MSTORE 18B1 60 PUSH1 0x01 18B3 60 PUSH1 0x01 18B5 60 PUSH1 0xa0 18B7 1B SHL 18B8 03 SUB 18B9 83 DUP4 18BA 16 AND 18BB 81 DUP2 18BC 52 MSTORE 18BD 60 PUSH1 0xa0 18BF 83 DUP4 18C0 90 SWAP1 18C1 1C SHR 18C2 60 PUSH1 0x01 18C4 60 PUSH1 0x01 18C6 60 PUSH1 0x40 18C8 1B SHL 18C9 03 SUB 18CA 16 AND 18CB 60 PUSH1 0x20 18CD 82 DUP3 18CE 01 ADD 18CF 52 MSTORE 18D0 60 PUSH1 0x01 18D2 60 PUSH1 0xe0 18D4 1B SHL 18D5 83 DUP4 18D6 16 AND 18D7 15 ISZERO 18D8 15 ISZERO 18D9 91 SWAP2 18DA 81 DUP2 18DB 01 ADD 18DC 91 SWAP2 18DD 90 SWAP1 18DE 91 SWAP2 18DF 52 MSTORE 18E0 60 PUSH1 0xe8 18E2 91 SWAP2 18E3 90 SWAP1 18E4 91 SWAP2 18E5 1C SHR 18E6 60 PUSH1 0x60 18E8 82 DUP3 18E9 01 ADD 18EA 52 MSTORE 18EB 90 SWAP1 18EC 56 *JUMP // Stack delta = +2 // Outputs[14] // { // @1879 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @187E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1885 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @188B memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @1892 stack[0] = memory[0x40:0x60] // @1893 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0x00 // @1898 memory[0x00:0x20] = stack[-1] // @189D memory[0x20:0x40] = 0x05 // @18B0 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @18BC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xa0) - 0x01 // @18CF memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & (storage[keccak256(memory[0x00:0x40])] >> 0xa0) // @18DF memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = !!(storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xe0)) // @18EA memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = storage[keccak256(memory[0x00:0x40])] >> 0xe8 // @18EB stack[1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0761 label_18ED: // Incoming jump from 0x0F43 // Inputs[1] { @18F3 stack[-1] } 18ED 5B JUMPDEST 18EE 60 PUSH1 0x60 18F0 61 PUSH2 0x18f8 18F3 82 DUP3 18F4 61 PUSH2 0x1294 18F7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @18EE stack[0] = 0x60 // @18F0 stack[1] = 0x18f8 // @18F3 stack[2] = stack[-1] // } // Block ends with call to 0x1294, returns to 0x18F8 label_18F8: // Incoming return from call to 0x1294 at 0x18F7 // Inputs[1] { @18FC stack[-1] } 18F8 5B JUMPDEST 18F9 61 PUSH2 0x190c 18FC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x190c, if stack[-1] label_18FD: // Incoming jump from 0x18FC, if not stack[-1] 18FD 61 PUSH2 0x190c 1900 63 PUSH4 0x0a14c4b5 1905 60 PUSH1 0xe4 1907 1B SHL 1908 61 PUSH2 0x12e1 190B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @18FD stack[0] = 0x190c // @1907 stack[1] = 0x0a14c4b5 << 0xe4 // } // Block ends with unconditional jump to 0x12e1 label_190C: // Incoming jump from 0x18FC, if stack[-1] 190C 5B JUMPDEST 190D 60 PUSH1 0x00 190F 61 PUSH2 0x1916 1912 61 PUSH2 0x1d28 1915 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @190D stack[0] = 0x00 // @190F stack[1] = 0x1916 // } // Block ends with unconditional jump to 0x1d28 1916 5B JUMPDEST 1917 90 SWAP1 1918 50 POP 1919 80 DUP1 191A 51 MLOAD 191B 60 PUSH1 0x00 191D 03 SUB 191E 61 PUSH2 0x1936 1921 57 *JUMPI 1922 60 PUSH1 0x40 1924 51 MLOAD 1925 80 DUP1 1926 60 PUSH1 0x20 1928 01 ADD 1929 60 PUSH1 0x40 192B 52 MSTORE 192C 80 DUP1 192D 60 PUSH1 0x00 192F 81 DUP2 1930 52 MSTORE 1931 50 POP 1932 61 PUSH2 0x1961 1935 56 *JUMP 1936 5B JUMPDEST 1937 80 DUP1 1938 61 PUSH2 0x1940 193B 84 DUP5 193C 61 PUSH2 0x1d37 193F 56 *JUMP 1940 5B JUMPDEST 1941 60 PUSH1 0x40 1943 51 MLOAD 1944 60 PUSH1 0x20 1946 01 ADD 1947 61 PUSH2 0x1951 194A 92 SWAP3 194B 91 SWAP2 194C 90 SWAP1 194D 61 PUSH2 0x261c 1950 56 *JUMP 1951 5B JUMPDEST 1952 60 PUSH1 0x40 1954 51 MLOAD 1955 60 PUSH1 0x20 1957 81 DUP2 1958 83 DUP4 1959 03 SUB 195A 03 SUB 195B 81 DUP2 195C 52 MSTORE 195D 90 SWAP1 195E 60 PUSH1 0x40 1960 52 MSTORE label_1961: // Incoming return from call to 0x2225 at 0x261B // Incoming return from call to 0x1FB1 at 0x2045 // Incoming return from call to 0x1EB3 at 0x1EF1 // Incoming return from call to 0x1E35 at 0x21B9 // Incoming jump from 0x1DF1 // Incoming return from call to 0x1E02 at 0x1E34 // Inputs[3] // { // @1962 stack[-1] // @1962 stack[-5] // @1963 stack[-4] // } 1961 5B JUMPDEST 1962 93 SWAP4 1963 92 SWAP3 1964 50 POP 1965 50 POP 1966 50 POP 1967 56 *JUMP // Stack delta = -4 // Outputs[1] { @1962 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1968: // Incoming call from 0x101E, returns to 0x101F // Inputs[11] // { // @196B memory[0x40:0x60] // @197A msg.sender // @1988 stack[-3] // @1993 memory[0x40:0x60] // @19A1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @19A6 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @19AC stack[-2] // @19AD stack[-1] // @19B8 memory[0x40:0x60] // @19D2 msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @19DF storage[0x0e] // } 1968 5B JUMPDEST 1969 60 PUSH1 0x40 196B 51 MLOAD 196C 6B PUSH12 0xffffffffffffffffffffffff 1979 19 NOT 197A 33 CALLER 197B 60 PUSH1 0x60 197D 1B SHL 197E 16 AND 197F 60 PUSH1 0x20 1981 82 DUP3 1982 01 ADD 1983 52 MSTORE 1984 60 PUSH1 0x34 1986 81 DUP2 1987 01 ADD 1988 84 DUP5 1989 90 SWAP1 198A 52 MSTORE 198B 60 PUSH1 0x00 198D 90 SWAP1 198E 60 PUSH1 0x54 1990 01 ADD 1991 60 PUSH1 0x40 1993 51 MLOAD 1994 60 PUSH1 0x20 1996 81 DUP2 1997 83 DUP4 1998 03 SUB 1999 03 SUB 199A 81 DUP2 199B 52 MSTORE 199C 90 SWAP1 199D 60 PUSH1 0x40 199F 52 MSTORE 19A0 80 DUP1 19A1 51 MLOAD 19A2 90 SWAP1 19A3 60 PUSH1 0x20 19A5 01 ADD 19A6 20 SHA3 19A7 90 SWAP1 19A8 50 POP 19A9 61 PUSH2 0x19e9 19AC 83 DUP4 19AD 83 DUP4 19AE 80 DUP1 19AF 80 DUP1 19B0 60 PUSH1 0x20 19B2 02 MUL 19B3 60 PUSH1 0x20 19B5 01 ADD 19B6 60 PUSH1 0x40 19B8 51 MLOAD 19B9 90 SWAP1 19BA 81 DUP2 19BB 01 ADD 19BC 60 PUSH1 0x40 19BE 52 MSTORE 19BF 80 DUP1 19C0 93 SWAP4 19C1 92 SWAP3 19C2 91 SWAP2 19C3 90 SWAP1 19C4 81 DUP2 19C5 81 DUP2 19C6 52 MSTORE 19C7 60 PUSH1 0x20 19C9 01 ADD 19CA 83 DUP4 19CB 83 DUP4 19CC 60 PUSH1 0x20 19CE 02 MUL 19CF 80 DUP1 19D0 82 DUP3 19D1 84 DUP5 19D2 37 CALLDATACOPY 19D3 60 PUSH1 0x00 19D5 92 SWAP3 19D6 01 ADD 19D7 91 SWAP2 19D8 90 SWAP1 19D9 91 SWAP2 19DA 52 MSTORE 19DB 50 POP 19DC 50 POP 19DD 60 PUSH1 0x0e 19DF 54 SLOAD 19E0 91 SWAP2 19E1 50 POP 19E2 84 DUP5 19E3 90 SWAP1 19E4 50 POP 19E5 61 PUSH2 0x1d7b 19E8 56 *JUMP // Stack delta = +5 // Outputs[13] // { // @1983 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (msg.sender << 0x60) & ~0xffffffffffffffffffffffff // @198A memory[memory[0x40:0x60] + 0x34:memory[0x40:0x60] + 0x34 + 0x20] = stack[-3] // @199B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x54 + memory[0x40:0x60]) - memory[0x40:0x60] - 0x20 // @199F memory[0x40:0x60] = 0x54 + memory[0x40:0x60] // @19A7 stack[0] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @19A9 stack[1] = 0x19e9 // @19BE memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-1] // @19C0 stack[2] = memory[0x40:0x60] // @19C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @19D2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1]] = msg.data[stack[-2]:stack[-2] + 0x20 * stack[-1]] // @19DA memory[0x20 + memory[0x40:0x60] + 0x20 * stack[-1]:0x20 + memory[0x40:0x60] + 0x20 * stack[-1] + 0x20] = 0x00 // @19E0 stack[3] = storage[0x0e] // @19E3 stack[4] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with call to 0x1d7b, returns to 0x19E9 label_19E9: // Incoming return from call to 0x1D7B at 0x19E8 // Inputs[1] { @19EA stack[-1] } 19E9 5B JUMPDEST 19EA 15 ISZERO 19EB 15 ISZERO 19EC 60 PUSH1 0x00 19EE 03 SUB 19EF 61 PUSH2 0x0977 19F2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0977, if 0x00 - !!stack[-1] label_19F3: // Incoming jump from 0x19F2, if not 0x00 - !!stack[-1] // Inputs[3] // { // @19F5 memory[0x40:0x60] // @1A05 memory[0x40:0x60] // @1A0A memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19F3 60 PUSH1 0x40 19F5 51 MLOAD 19F6 63 PUSH4 0x582f497d 19FB 60 PUSH1 0xe1 19FD 1B SHL 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] = 0x582f497d << 0xe1 // @1A0A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A0B: // Incoming jump from 0x1028 // Inputs[4] // { // @1A0C msg.sender // @1A1A memory[0x00:0x40] // @1A1B storage[keccak256(memory[0x00:0x40])] // @1A21 storage[0x0f] // } 1A0B 5B JUMPDEST 1A0C 33 CALLER 1A0D 60 PUSH1 0x00 1A0F 90 SWAP1 1A10 81 DUP2 1A11 52 MSTORE 1A12 60 PUSH1 0x06 1A14 60 PUSH1 0x20 1A16 52 MSTORE 1A17 60 PUSH1 0x40 1A19 81 DUP2 1A1A 20 SHA3 1A1B 54 SLOAD 1A1C 60 PUSH1 0xc0 1A1E 1C SHR 1A1F 60 PUSH1 0x0f 1A21 54 SLOAD 1A22 60 PUSH1 0x01 1A24 60 PUSH1 0x01 1A26 60 PUSH1 0x40 1A28 1B SHL 1A29 03 SUB 1A2A 82 DUP3 1A2B 16 AND 1A2C 92 SWAP3 1A2D 50 POP 1A2E 61 PUSH2 0xffff 1A31 82 DUP3 1A32 16 AND 1A33 91 SWAP2 1A34 60 PUSH1 0x10 1A36 1C SHR 1A37 60 PUSH1 0xff 1A39 90 SWAP1 1A3A 81 DUP2 1A3B 16 AND 1A3C 60 PUSH1 0x01 1A3E 60 PUSH1 0x40 1A40 1B SHL 1A41 90 SWAP1 1A42 92 SWAP3 1A43 04 DIV 1A44 16 AND 1A45 14 EQ 1A46 61 PUSH2 0x1a4d 1A49 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @1A11 memory[0x00:0x20] = msg.sender // @1A16 memory[0x20:0x40] = 0x06 // @1A2C stack[0] = (storage[keccak256(memory[0x00:0x40])] >> 0xc0) & (0x01 << 0x40) - 0x01 // @1A33 stack[1] = (storage[keccak256(memory[0x00:0x40])] >> 0xc0) & 0xffff // } // Block ends with conditional jump to 0x1a4d, if storage[0x0f] / (0x01 << 0x40) & 0xff == 0xff & ((storage[keccak256(memory[0x00:0x40])] >> 0xc0) >> 0x10) label_1A4A: // Incoming jump from 0x1A49, if not storage[0x0f] / (0x01 << 0x40) & 0xff == 0xff & ((storage[keccak256(memory[0x00:0x40])] >> 0xc0) >> 0x10) // Inputs[1] { @1A53 stack[-4] } 1A4A 50 POP 1A4B 60 PUSH1 0x00 1A4D 5B JUMPDEST 1A4E 60 PUSH1 0x00 1A50 61 PUSH2 0x1a59 1A53 85 DUP6 1A54 83 DUP4 1A55 61 PUSH2 0x2443 1A58 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1A4B stack[-1] = 0x00 // @1A4E stack[0] = 0x00 // @1A50 stack[1] = 0x1a59 // @1A53 stack[2] = stack[-4] // @1A54 stack[3] = 0x00 // } // Block ends with call to 0x2443, returns to 0x1A59 label_1A59: // Incoming return from call to 0x2443 at 0x1A58 // Incoming return from call to 0x2443 at 0x1A58 // Inputs[3] // { // @1A5A stack[-2] // @1A5A stack[-1] // @1A5C stack[-5] // } 1A59 5B JUMPDEST 1A5A 90 SWAP1 1A5B 50 POP 1A5C 83 DUP4 1A5D 81 DUP2 1A5E 11 GT 1A5F 15 ISZERO 1A60 61 PUSH2 0x1a7c 1A63 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1A5A stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1a7c, if !(stack[-1] > stack[-5]) label_1A64: // Incoming jump from 0x1A63, if not !(stack[-1] > stack[-5]) // Inputs[3] // { // @1A66 memory[0x40:0x60] // @1A76 memory[0x40:0x60] // @1A7B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1A64 60 PUSH1 0x40 1A66 51 MLOAD 1A67 63 PUSH4 0x10f46ced 1A6C 60 PUSH1 0xe1 1A6E 1B SHL 1A6F 81 DUP2 1A70 52 MSTORE 1A71 60 PUSH1 0x04 1A73 01 ADD 1A74 60 PUSH1 0x40 1A76 51 MLOAD 1A77 80 DUP1 1A78 91 SWAP2 1A79 03 SUB 1A7A 90 SWAP1 1A7B FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1A70 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x10f46ced << 0xe1 // @1A7B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A7C: // Incoming jump from 0x1A63, if !(stack[-1] > stack[-5]) // Inputs[5] // { // @1A7F storage[0x0f] // @1A80 msg.sender // @1A8E memory[0x00:0x40] // @1A90 storage[keccak256(memory[0x00:0x40])] // @1AA1 stack[-1] // } 1A7C 5B JUMPDEST 1A7D 60 PUSH1 0x0f 1A7F 54 SLOAD 1A80 33 CALLER 1A81 60 PUSH1 0x00 1A83 90 SWAP1 1A84 81 DUP2 1A85 52 MSTORE 1A86 60 PUSH1 0x06 1A88 60 PUSH1 0x20 1A8A 52 MSTORE 1A8B 60 PUSH1 0x40 1A8D 90 SWAP1 1A8E 20 SHA3 1A8F 80 DUP1 1A90 54 SLOAD 1A91 60 PUSH1 0x01 1A93 60 PUSH1 0x40 1A95 1B SHL 1A96 90 SWAP1 1A97 92 SWAP3 1A98 04 DIV 1A99 60 PUSH1 0x10 1A9B 1B SHL 1A9C 62 PUSH3 0xff0000 1AA0 16 AND 1AA1 83 DUP4 1AA2 17 OR 1AA3 60 PUSH1 0xc0 1AA5 81 DUP2 1AA6 90 SWAP1 1AA7 1B SHL 1AA8 60 PUSH1 0x01 1AAA 60 PUSH1 0x01 1AAC 60 PUSH1 0xc0 1AAE 1B SHL 1AAF 03 SUB 1AB0 90 SWAP1 1AB1 93 SWAP4 1AB2 16 AND 1AB3 92 SWAP3 1AB4 90 SWAP1 1AB5 92 SWAP3 1AB6 17 OR 1AB7 90 SWAP1 1AB8 55 SSTORE // Stack delta = +1 // Outputs[4] // { // @1A85 memory[0x00:0x20] = msg.sender // @1A8A memory[0x20:0x40] = 0x06 // @1AB5 stack[0] = stack[-1] | (0xff0000 & (storage[0x0f] / (0x01 << 0x40) << 0x10)) // @1AB8 storage[keccak256(memory[0x00:0x40])] = (storage[keccak256(memory[0x00:0x40])] & (0x01 << 0xc0) - 0x01) | ((stack[-1] | (0xff0000 & (storage[0x0f] / (0x01 << 0x40) << 0x10))) << 0xc0) // } // Block continues label_1AB9: // Incoming jump from 0x24FD // Incoming jump from 0x2491, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x2491, if !(stack[-1] < stack[-2]) // Incoming jump from 0x2491, if !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x24FD // Incoming jump from 0x1AB8 // Inputs[1] { @1AC0 stack[-7] } 1AB9 5B JUMPDEST 1ABA 50 POP 1ABB 50 POP 1ABC 50 POP 1ABD 50 POP 1ABE 50 POP 1ABF 50 POP 1AC0 56 *JUMP // Stack delta = -7 // Block ends with unconditional jump to stack[-7] label_1AC1: // Incoming call from 0x1031, returns to 0x1032 // Inputs[1] { @1AC4 storage[0x0f] } 1AC1 5B JUMPDEST 1AC2 60 PUSH1 0x0f 1AC4 54 SLOAD 1AC5 60 PUSH1 0x01 1AC7 60 PUSH1 0x40 1AC9 1B SHL 1ACA 90 SWAP1 1ACB 04 DIV 1ACC 60 PUSH1 0xff 1ACE 16 AND 1ACF 60 PUSH1 0x00 1AD1 03 SUB 1AD2 61 PUSH2 0x1aee 1AD5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1aee, if 0x00 - (0xff & storage[0x0f] / (0x01 << 0x40)) label_1AD6: // Incoming jump from 0x1AD5, if not 0x00 - (0xff & storage[0x0f] / (0x01 << 0x40)) // Inputs[3] // { // @1AD8 memory[0x40:0x60] // @1AE8 memory[0x40:0x60] // @1AED memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AD6 60 PUSH1 0x40 1AD8 51 MLOAD 1AD9 63 PUSH4 0xc6b0e90b 1ADE 60 PUSH1 0xe0 1AE0 1B SHL 1AE1 81 DUP2 1AE2 52 MSTORE 1AE3 60 PUSH1 0x04 1AE5 01 ADD 1AE6 60 PUSH1 0x40 1AE8 51 MLOAD 1AE9 80 DUP1 1AEA 91 SWAP2 1AEB 03 SUB 1AEC 90 SWAP1 1AED FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1AE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xc6b0e90b << 0xe0 // @1AED revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1AEE: // Incoming jump from 0x1AD5, if 0x00 - (0xff & storage[0x0f] / (0x01 << 0x40)) // Inputs[1] { @1AEF stack[-1] } 1AEE 5B JUMPDEST 1AEF 80 DUP1 1AF0 60 PUSH1 0x00 1AF2 03 SUB 1AF3 61 PUSH2 0x1b0f 1AF6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b0f, if 0x00 - stack[-1] label_1AF7: // Incoming jump from 0x1AF6, if not 0x00 - stack[-1] // Inputs[3] // { // @1AF9 memory[0x40:0x60] // @1B09 memory[0x40:0x60] // @1B0E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1AF7 60 PUSH1 0x40 1AF9 51 MLOAD 1AFA 63 PUSH4 0x03b8bfd3 1AFF 60 PUSH1 0xe6 1B01 1B SHL 1B02 81 DUP2 1B03 52 MSTORE 1B04 60 PUSH1 0x04 1B06 01 ADD 1B07 60 PUSH1 0x40 1B09 51 MLOAD 1B0A 80 DUP1 1B0B 91 SWAP2 1B0C 03 SUB 1B0D 90 SWAP1 1B0E FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B03 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x03b8bfd3 << 0xe6 // @1B0E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B0F: // Incoming jump from 0x1AF6, if 0x00 - stack[-1] // Inputs[2] // { // @1B12 storage[0x0f] // @1B17 stack[-1] // } 1B0F 5B JUMPDEST 1B10 60 PUSH1 0x0f 1B12 54 SLOAD 1B13 61 PUSH2 0x1b26 1B16 90 SWAP1 1B17 82 DUP3 1B18 90 SWAP1 1B19 60 PUSH1 0x01 1B1B 60 PUSH1 0x01 1B1D 60 PUSH1 0x40 1B1F 1B SHL 1B20 03 SUB 1B21 16 AND 1B22 61 PUSH2 0x240a 1B25 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1B16 stack[0] = 0x1b26 // @1B18 stack[1] = stack[-1] // @1B21 stack[2] = (0x01 << 0x40) - 0x01 & storage[0x0f] // } // Block ends with call to 0x240a, returns to 0x1B26 label_1B26: // Incoming return from call to 0x240A at 0x1B25 // Inputs[2] // { // @1B27 msg.value // @1B28 stack[-1] // } 1B26 5B JUMPDEST 1B27 34 CALLVALUE 1B28 10 LT 1B29 15 ISZERO 1B2A 61 PUSH2 0x1b46 1B2D 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1b46, if !(msg.value < stack[-1]) label_1B2E: // Incoming jump from 0x1B2D, if not !(msg.value < stack[-1]) // Inputs[3] // { // @1B30 memory[0x40:0x60] // @1B40 memory[0x40:0x60] // @1B45 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B2E 60 PUSH1 0x40 1B30 51 MLOAD 1B31 63 PUSH4 0x356680b7 1B36 60 PUSH1 0xe0 1B38 1B SHL 1B39 81 DUP2 1B3A 52 MSTORE 1B3B 60 PUSH1 0x04 1B3D 01 ADD 1B3E 60 PUSH1 0x40 1B40 51 MLOAD 1B41 80 DUP1 1B42 91 SWAP2 1B43 03 SUB 1B44 90 SWAP1 1B45 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B3A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x356680b7 << 0xe0 // @1B45 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B46: // Incoming jump from 0x1B2D, if !(msg.value < stack[-1]) // Inputs[1] { @1B49 stack[-1] } 1B46 5B JUMPDEST 1B47 60 PUSH1 0x0a 1B49 81 DUP2 1B4A 11 GT 1B4B 15 ISZERO 1B4C 61 PUSH2 0x1b68 1B4F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1b68, if !(stack[-1] > 0x0a) label_1B50: // Incoming jump from 0x1B4F, if not !(stack[-1] > 0x0a) // Inputs[3] // { // @1B52 memory[0x40:0x60] // @1B62 memory[0x40:0x60] // @1B67 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B50 60 PUSH1 0x40 1B52 51 MLOAD 1B53 63 PUSH4 0x5da067e7 1B58 60 PUSH1 0xe0 1B5A 1B SHL 1B5B 81 DUP2 1B5C 52 MSTORE 1B5D 60 PUSH1 0x04 1B5F 01 ADD 1B60 60 PUSH1 0x40 1B62 51 MLOAD 1B63 80 DUP1 1B64 91 SWAP2 1B65 03 SUB 1B66 90 SWAP1 1B67 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B5C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5da067e7 << 0xe0 // @1B67 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1B68: // Incoming jump from 0x1B4F, if !(stack[-1] > 0x0a) // Inputs[4] // { // @1B6B storage[0x0b] // @1B6E storage[0x02] // @1B71 storage[0x01] // @1B72 stack[-1] // } 1B68 5B JUMPDEST 1B69 60 PUSH1 0x0b 1B6B 54 SLOAD 1B6C 60 PUSH1 0x02 1B6E 54 SLOAD 1B6F 60 PUSH1 0x01 1B71 54 SLOAD 1B72 83 DUP4 1B73 91 SWAP2 1B74 90 SWAP1 1B75 03 SUB 1B76 61 PUSH2 0x059b 1B79 19 NOT 1B7A 01 ADD 1B7B 61 PUSH2 0x1b84 1B7E 91 SWAP2 1B7F 90 SWAP1 1B80 61 PUSH2 0x2443 1B83 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1B6B stack[0] = storage[0x0b] // @1B7E stack[1] = 0x1b84 // @1B7F stack[2] = stack[-1] // @1B7F stack[3] = ~0x059b + (storage[0x01] - storage[0x02]) // } // Block ends with call to 0x2443, returns to 0x1B84 label_1B84: // Incoming return from call to 0x2443 at 0x1B83 // Inputs[2] // { // @1B85 stack[-2] // @1B85 stack[-1] // } 1B84 5B JUMPDEST 1B85 11 GT 1B86 15 ISZERO 1B87 61 PUSH2 0x10b7 1B8A 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x10b7, if !(stack[-1] > stack[-2]) label_1B8B: // Incoming jump from 0x1B8A, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @1B8D memory[0x40:0x60] // @1B9D memory[0x40:0x60] // @1BA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B8B 60 PUSH1 0x40 1B8D 51 MLOAD 1B8E 63 PUSH4 0x5c9a0abb 1B93 60 PUSH1 0xe0 1B95 1B SHL 1B96 81 DUP2 1B97 52 MSTORE 1B98 60 PUSH1 0x04 1B9A 01 ADD 1B9B 60 PUSH1 0x40 1B9D 51 MLOAD 1B9E 80 DUP1 1B9F 91 SWAP2 1BA0 03 SUB 1BA1 90 SWAP1 1BA2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1B97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x5c9a0abb << 0xe0 // @1BA2 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates 1BA3 5B JUMPDEST 1BA4 60 PUSH1 0x00 1BA6 61 PUSH2 0x1bae 1BA9 83 DUP4 1BAA 61 PUSH2 0x0c19 1BAD 56 *JUMP 1BAE 5B JUMPDEST 1BAF 90 SWAP1 1BB0 50 POP 1BB1 81 DUP2 1BB2 80 DUP1 1BB3 15 ISZERO 1BB4 61 PUSH2 0x1bc6 1BB7 57 *JUMPI 1BB8 50 POP 1BB9 33 CALLER 1BBA 60 PUSH1 0x01 1BBC 60 PUSH1 0x01 1BBE 60 PUSH1 0xa0 1BC0 1B SHL 1BC1 03 SUB 1BC2 82 DUP3 1BC3 16 AND 1BC4 14 EQ 1BC5 15 ISZERO 1BC6 5B JUMPDEST 1BC7 15 ISZERO 1BC8 61 PUSH2 0x1be9 1BCB 57 *JUMPI 1BCC 61 PUSH2 0x1bd5 1BCF 81 DUP2 1BD0 33 CALLER 1BD1 61 PUSH2 0x06f9 1BD4 56 *JUMP 1BD5 5B JUMPDEST 1BD6 61 PUSH2 0x1be9 1BD9 57 *JUMPI 1BDA 61 PUSH2 0x1be9 1BDD 63 PUSH4 0x67d9dca1 1BE2 60 PUSH1 0xe1 1BE4 1B SHL 1BE5 61 PUSH2 0x12e1 1BE8 56 *JUMP 1BE9 5B JUMPDEST 1BEA 60 PUSH1 0x00 1BEC 83 DUP4 1BED 81 DUP2 1BEE 52 MSTORE 1BEF 60 PUSH1 0x07 1BF1 60 PUSH1 0x20 1BF3 52 MSTORE 1BF4 60 PUSH1 0x40 1BF6 80 DUP1 1BF7 82 DUP3 1BF8 20 SHA3 1BF9 80 DUP1 1BFA 54 SLOAD 1BFB 60 PUSH1 0x01 1BFD 60 PUSH1 0x01 1BFF 60 PUSH1 0xa0 1C01 1B SHL 1C02 03 SUB 1C03 19 NOT 1C04 16 AND 1C05 60 PUSH1 0x01 1C07 60 PUSH1 0x01 1C09 60 PUSH1 0xa0 1C0B 1B SHL 1C0C 03 SUB 1C0D 88 DUP9 1C0E 81 DUP2 1C0F 16 AND 1C10 91 SWAP2 1C11 82 DUP3 1C12 17 OR 1C13 90 SWAP1 1C14 92 SWAP3 1C15 55 SSTORE 1C16 91 SWAP2 1C17 51 MLOAD 1C18 86 DUP7 1C19 93 SWAP4 1C1A 91 SWAP2 1C1B 85 DUP6 1C1C 16 AND 1C1D 91 SWAP2 1C1E 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1C3F 91 SWAP2 1C40 A4 LOG4 1C41 50 POP 1C42 50 POP 1C43 50 POP 1C44 50 POP 1C45 56 *JUMP 1C46 5B JUMPDEST 1C47 60 PUSH1 0x40 1C49 51 MLOAD 1C4A 63 PUSH4 0x0a85bd01 1C4F 60 PUSH1 0xe1 1C51 1B SHL 1C52 81 DUP2 1C53 52 MSTORE 1C54 60 PUSH1 0x00 1C56 90 SWAP1 1C57 60 PUSH1 0x01 1C59 60 PUSH1 0x01 1C5B 60 PUSH1 0xa0 1C5D 1B SHL 1C5E 03 SUB 1C5F 85 DUP6 1C60 16 AND 1C61 90 SWAP1 1C62 63 PUSH4 0x150b7a02 1C67 90 SWAP1 1C68 61 PUSH2 0x1c7b 1C6B 90 SWAP1 1C6C 33 CALLER 1C6D 90 SWAP1 1C6E 89 DUP10 1C6F 90 SWAP1 1C70 88 DUP9 1C71 90 SWAP1 1C72 88 DUP9 1C73 90 SWAP1 1C74 60 PUSH1 0x04 1C76 01 ADD 1C77 61 PUSH2 0x264b 1C7A 56 *JUMP 1C7B 5B JUMPDEST 1C7C 60 PUSH1 0x20 1C7E 60 PUSH1 0x40 1C80 51 MLOAD 1C81 80 DUP1 1C82 83 DUP4 1C83 03 SUB 1C84 81 DUP2 1C85 60 PUSH1 0x00 1C87 87 DUP8 1C88 5A GAS 1C89 F1 CALL 1C8A 92 SWAP3 1C8B 50 POP 1C8C 50 POP 1C8D 50 POP 1C8E 80 DUP1 1C8F 15 ISZERO 1C90 61 PUSH2 0x1cb6 1C93 57 *JUMPI 1C94 50 POP 1C95 60 PUSH1 0x40 1C97 80 DUP1 1C98 51 MLOAD 1C99 60 PUSH1 0x1f 1C9B 3D RETURNDATASIZE 1C9C 90 SWAP1 1C9D 81 DUP2 1C9E 01 ADD 1C9F 60 PUSH1 0x1f 1CA1 19 NOT 1CA2 16 AND 1CA3 82 DUP3 1CA4 01 ADD 1CA5 90 SWAP1 1CA6 92 SWAP3 1CA7 52 MSTORE 1CA8 61 PUSH2 0x1cb3 1CAB 91 SWAP2 1CAC 81 DUP2 1CAD 01 ADD 1CAE 90 SWAP1 1CAF 61 PUSH2 0x2688 1CB2 56 *JUMP 1CB3 5B JUMPDEST 1CB4 60 PUSH1 0x01 1CB6 5B JUMPDEST 1CB7 61 PUSH2 0x1d0b 1CBA 57 *JUMPI 1CBB 3D RETURNDATASIZE 1CBC 80 DUP1 1CBD 80 DUP1 1CBE 15 ISZERO 1CBF 61 PUSH2 0x1ce4 1CC2 57 *JUMPI 1CC3 60 PUSH1 0x40 1CC5 51 MLOAD 1CC6 91 SWAP2 1CC7 50 POP 1CC8 60 PUSH1 0x1f 1CCA 19 NOT 1CCB 60 PUSH1 0x3f 1CCD 3D RETURNDATASIZE 1CCE 01 ADD 1CCF 16 AND 1CD0 82 DUP3 1CD1 01 ADD 1CD2 60 PUSH1 0x40 1CD4 52 MSTORE 1CD5 3D RETURNDATASIZE 1CD6 82 DUP3 1CD7 52 MSTORE 1CD8 3D RETURNDATASIZE 1CD9 60 PUSH1 0x00 1CDB 60 PUSH1 0x20 1CDD 84 DUP5 1CDE 01 ADD 1CDF 3E RETURNDATACOPY 1CE0 61 PUSH2 0x1ce9 1CE3 56 *JUMP 1CE4 5B JUMPDEST 1CE5 60 PUSH1 0x60 1CE7 91 SWAP2 1CE8 50 POP 1CE9 5B JUMPDEST 1CEA 50 POP 1CEB 80 DUP1 1CEC 51 MLOAD 1CED 60 PUSH1 0x00 1CEF 03 SUB 1CF0 61 PUSH2 0x1d03 1CF3 57 *JUMPI 1CF4 61 PUSH2 0x1d03 1CF7 63 PUSH4 0x68d2bf6b 1CFC 60 PUSH1 0xe1 1CFE 1B SHL 1CFF 61 PUSH2 0x12e1 1D02 56 *JUMP 1D03 5B JUMPDEST 1D04 80 DUP1 1D05 51 MLOAD 1D06 81 DUP2 1D07 60 PUSH1 0x20 1D09 01 ADD 1D0A FD *REVERT 1D0B 5B JUMPDEST 1D0C 60 PUSH1 0x01 1D0E 60 PUSH1 0x01 1D10 60 PUSH1 0xe0 1D12 1B SHL 1D13 03 SUB 1D14 19 NOT 1D15 16 AND 1D16 63 PUSH4 0x0a85bd01 1D1B 60 PUSH1 0xe1 1D1D 1B SHL 1D1E 14 EQ 1D1F 90 SWAP1 1D20 50 POP 1D21 94 SWAP5 1D22 93 SWAP4 1D23 50 POP 1D24 50 POP 1D25 50 POP 1D26 50 POP 1D27 56 *JUMP label_1D28: // Incoming jump from 0x1915 // Inputs[1] { @1D2E storage[0x0c] } 1D28 5B JUMPDEST 1D29 60 PUSH1 0x60 1D2B 60 PUSH1 0x0c 1D2D 80 DUP1 1D2E 54 SLOAD 1D2F 61 PUSH2 0x078c 1D32 90 SWAP1 1D33 61 PUSH2 0x23a1 1D36 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1D29 stack[0] = 0x60 // @1D2B stack[1] = 0x0c // @1D32 stack[2] = 0x078c // @1D32 stack[3] = storage[0x0c] // } // Block ends with call to 0x23a1, returns to 0x078C 1D37 5B JUMPDEST 1D38 60 PUSH1 0x60 1D3A 60 PUSH1 0xa0 1D3C 60 PUSH1 0x40 1D3E 51 MLOAD 1D3F 01 ADD 1D40 80 DUP1 1D41 60 PUSH1 0x40 1D43 52 MSTORE 1D44 60 PUSH1 0x20 1D46 81 DUP2 1D47 03 SUB 1D48 91 SWAP2 1D49 50 POP 1D4A 50 POP 1D4B 60 PUSH1 0x00 1D4D 81 DUP2 1D4E 52 MSTORE 1D4F 80 DUP1 1D50 82 DUP3 1D51 5B JUMPDEST 1D52 60 PUSH1 0x01 1D54 83 DUP4 1D55 03 SUB 1D56 92 SWAP3 1D57 50 POP 1D58 60 PUSH1 0x0a 1D5A 81 DUP2 1D5B 06 MOD 1D5C 60 PUSH1 0x30 1D5E 01 ADD 1D5F 83 DUP4 1D60 53 MSTORE8 1D61 60 PUSH1 0x0a 1D63 90 SWAP1 1D64 04 DIV 1D65 80 DUP1 1D66 61 PUSH2 0x1d51 1D69 57 *JUMPI 1D6A 50 POP 1D6B 81 DUP2 1D6C 90 SWAP1 1D6D 03 SUB 1D6E 60 PUSH1 0x1f 1D70 19 NOT 1D71 90 SWAP1 1D72 91 SWAP2 1D73 01 ADD 1D74 90 SWAP1 1D75 81 DUP2 1D76 52 MSTORE 1D77 91 SWAP2 1D78 90 SWAP1 1D79 50 POP 1D7A 56 *JUMP label_1D7B: // Incoming call from 0x19E8, returns to 0x19E9 // Inputs[3] // { // @1D7E stack[-2] // @1D82 stack[-3] // @1D83 stack[-1] // } 1D7B 5B JUMPDEST 1D7C 60 PUSH1 0x00 1D7E 82 DUP3 1D7F 61 PUSH2 0x1d88 1D82 85 DUP6 1D83 84 DUP5 1D84 61 PUSH2 0x1d91 1D87 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1D7C stack[0] = 0x00 // @1D7E stack[1] = stack[-2] // @1D7F stack[2] = 0x1d88 // @1D82 stack[3] = stack[-3] // @1D83 stack[4] = stack[-1] // } // Block ends with call to 0x1d91, returns to 0x1D88 label_1D88: // Incoming return from call to 0x1D91 at 0x1D87 // Inputs[4] // { // @1D89 stack[-1] // @1D89 stack[-2] // @1D8A stack[-7] // @1D8B stack[-6] // } 1D88 5B JUMPDEST 1D89 14 EQ 1D8A 94 SWAP5 1D8B 93 SWAP4 1D8C 50 POP 1D8D 50 POP 1D8E 50 POP 1D8F 50 POP 1D90 56 *JUMP // Stack delta = -6 // Outputs[1] { @1D8A stack[-7] = stack[-1] == stack[-2] } // Block ends with unconditional jump to stack[-7] label_1D91: // Incoming call from 0x1D87, returns to 0x1D88 // Inputs[3] // { // @1D94 stack[-1] // @1D97 stack[-2] // @1D98 memory[stack[-2]:stack[-2] + 0x20] // } 1D91 5B JUMPDEST 1D92 60 PUSH1 0x00 1D94 81 DUP2 1D95 81 DUP2 1D96 5B JUMPDEST 1D97 84 DUP5 1D98 51 MLOAD 1D99 81 DUP2 1D9A 10 LT 1D9B 15 ISZERO 1D9C 61 PUSH2 0x0c11 1D9F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1D92 stack[0] = 0x00 // @1D94 stack[1] = stack[-1] // @1D95 stack[2] = 0x00 // } // Block ends with conditional jump to 0x0c11, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_1DA0: // Incoming jump from 0x1D9F, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x1D9F, if not !(stack[-1] < memory[stack[-5]:stack[-5] + 0x20]) // Inputs[4] // { // @1DA3 stack[-2] // @1DA4 stack[-5] // @1DA5 stack[-1] // @1DA7 memory[stack[-5]:stack[-5] + 0x20] // } 1DA0 61 PUSH2 0x1dc2 1DA3 82 DUP3 1DA4 86 DUP7 1DA5 83 DUP4 1DA6 81 DUP2 1DA7 51 MLOAD 1DA8 81 DUP2 1DA9 10 LT 1DAA 61 PUSH2 0x1db5 1DAD 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @1DA0 stack[0] = 0x1dc2 // @1DA3 stack[1] = stack[-2] // @1DA4 stack[2] = stack[-5] // @1DA5 stack[3] = stack[-1] // } // Block ends with conditional call to 0x1db5, returns to 0x1DC2, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] label_1DAE: // Incoming jump from 0x1DAD, if not stack[-1] < memory[stack[-5]:stack[-5] + 0x20] 1DAE 61 PUSH2 0x1db5 1DB1 61 PUSH2 0x26a5 1DB4 56 *JUMP // Stack delta = +1 // Outputs[1] { @1DAE stack[0] = 0x1db5 } // Block ends with unconditional jump to 0x26a5 label_1DB5: // Incoming call from 0x1DAD, returns to 0x1DC2, if stack[-1] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[3] // { // @1DB8 stack[-1] // @1DBC stack[-2] // @1DBD memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 1DB5 5B JUMPDEST 1DB6 60 PUSH1 0x20 1DB8 02 MUL 1DB9 60 PUSH1 0x20 1DBB 01 ADD 1DBC 01 ADD 1DBD 51 MLOAD 1DBE 61 PUSH2 0x1dd6 1DC1 56 *JUMP // Stack delta = -1 // Outputs[1] { @1DBD stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1dd6 label_1DC2: // Incoming return from call to 0x1DB5 at 0x1DAD // Inputs[3] // { // @1DC3 stack[-1] // @1DC3 stack[-3] // @1DC5 stack[-2] // } 1DC2 5B JUMPDEST 1DC3 91 SWAP2 1DC4 50 POP 1DC5 80 DUP1 1DC6 61 PUSH2 0x1dce 1DC9 81 DUP2 1DCA 61 PUSH2 0x26bb 1DCD 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1DC3 stack[-3] = stack[-1] // @1DC5 stack[-1] = stack[-2] // @1DC6 stack[0] = 0x1dce // @1DC9 stack[1] = stack[-2] // } // Block ends with call to 0x26bb, returns to 0x1DCE label_1DCE: // Incoming return from call to 0x26BB at 0x1DCD // Inputs[2] // { // @1DCF stack[-3] // @1DCF stack[-1] // } 1DCE 5B JUMPDEST 1DCF 91 SWAP2 1DD0 50 POP 1DD1 50 POP 1DD2 61 PUSH2 0x1d96 1DD5 56 *JUMP // Stack delta = -2 // Outputs[1] { @1DCF stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1d96 label_1DD6: // Incoming jump from 0x1DC1 // Inputs[2] // { // @1DD9 stack[-1] // @1DDA stack[-2] // } 1DD6 5B JUMPDEST 1DD7 60 PUSH1 0x00 1DD9 81 DUP2 1DDA 83 DUP4 1DDB 10 LT 1DDC 61 PUSH2 0x1df2 1DDF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1DD7 stack[0] = 0x00 } // Block ends with conditional jump to 0x1df2, if stack[-2] < stack[-1] label_1DE0: // Incoming jump from 0x1DDF, if not stack[-2] < stack[-1] // Inputs[3] // { // @1DE2 stack[-2] // @1DE7 stack[-3] // @1DED memory[0x00:0x40] // } 1DE0 60 PUSH1 0x00 1DE2 82 DUP3 1DE3 81 DUP2 1DE4 52 MSTORE 1DE5 60 PUSH1 0x20 1DE7 84 DUP5 1DE8 90 SWAP1 1DE9 52 MSTORE 1DEA 60 PUSH1 0x40 1DEC 90 SWAP1 1DED 20 SHA3 1DEE 61 PUSH2 0x1961 1DF1 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1DE4 memory[0x00:0x20] = stack[-2] // @1DE9 memory[0x20:0x40] = stack[-3] // @1DED stack[0] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to 0x1961 label_1DF2: // Incoming jump from 0x1DDF, if stack[-2] < stack[-1] // Inputs[4] // { // @1DF6 stack[-3] // @1DFB stack[-2] // @1DFF memory[0x00:0x40] // @1E00 stack[-4] // } 1DF2 5B JUMPDEST 1DF3 50 POP 1DF4 60 PUSH1 0x00 1DF6 91 SWAP2 1DF7 82 DUP3 1DF8 52 MSTORE 1DF9 60 PUSH1 0x20 1DFB 52 MSTORE 1DFC 60 PUSH1 0x40 1DFE 90 SWAP1 1DFF 20 SHA3 1E00 90 SWAP1 1E01 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @1DF8 memory[0x00:0x20] = stack[-3] // @1DFB memory[0x20:0x40] = stack[-2] // @1E00 stack[-4] = keccak256(memory[0x00:0x40]) // } // Block ends with unconditional jump to stack[-4] label_1E02: // Incoming call from 0x1E34, returns to 0x1961 // Inputs[1] { @1E0C stack[-1] } 1E02 5B JUMPDEST 1E03 60 PUSH1 0x01 1E05 60 PUSH1 0x01 1E07 60 PUSH1 0xe0 1E09 1B SHL 1E0A 03 SUB 1E0B 19 NOT 1E0C 81 DUP2 1E0D 16 AND 1E0E 81 DUP2 1E0F 14 EQ 1E10 61 PUSH2 0x10b7 1E13 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10b7, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_1E14: // Incoming jump from 0x1E13, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @1E17 memory[0x00:0x00] } 1E14 60 PUSH1 0x00 1E16 80 DUP1 1E17 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E17 revert(memory[0x00:0x00]); } // Block terminates label_1E18: // Incoming call from 0x0244, returns to 0x0245 // Inputs[2] // { // @1E1D stack[-1] // @1E1E stack[-2] // } 1E18 5B JUMPDEST 1E19 60 PUSH1 0x00 1E1B 60 PUSH1 0x20 1E1D 82 DUP3 1E1E 84 DUP5 1E1F 03 SUB 1E20 12 SLT 1E21 15 ISZERO 1E22 61 PUSH2 0x1e2a 1E25 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E19 stack[0] = 0x00 } // Block ends with conditional jump to 0x1e2a, if !(stack[-2] - stack[-1] i< 0x20) label_1E26: // Incoming jump from 0x1E25, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1E29 memory[0x00:0x00] } 1E26 60 PUSH1 0x00 1E28 80 DUP1 1E29 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E29 revert(memory[0x00:0x00]); } // Block terminates label_1E2A: // Incoming jump from 0x1E25, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @1E2B stack[-2] // @1E2C msg.data[stack[-2]:stack[-2] + 0x20] // } 1E2A 5B JUMPDEST 1E2B 81 DUP2 1E2C 35 CALLDATALOAD 1E2D 61 PUSH2 0x1961 1E30 81 DUP2 1E31 61 PUSH2 0x1e02 1E34 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E2C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @1E2D stack[1] = 0x1961 // @1E30 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x1e02, returns to 0x1961 label_1E35: // Incoming call from 0x1F7C, returns to 0x1F7D // Incoming call from 0x1F26, returns to 0x1F27 // Incoming call from 0x1F8A, returns to 0x1F8B // Incoming call from 0x228B, returns to 0x228C // Incoming call from 0x2397, returns to 0x2398 // Incoming call from 0x1E67, returns to 0x1E68 // Incoming call from 0x220F, returns to 0x2210 // Incoming call from 0x227D, returns to 0x227E // Incoming call from 0x21B9, returns to 0x1961 // Incoming call from 0x2389, returns to 0x238A // Incoming call from 0x224E, returns to 0x224F // Inputs[2] // { // @1E36 stack[-1] // @1E37 msg.data[stack[-1]:stack[-1] + 0x20] // } 1E35 5B JUMPDEST 1E36 80 DUP1 1E37 35 CALLDATALOAD 1E38 60 PUSH1 0x01 1E3A 60 PUSH1 0x01 1E3C 60 PUSH1 0xa0 1E3E 1B SHL 1E3F 03 SUB 1E40 81 DUP2 1E41 16 AND 1E42 81 DUP2 1E43 14 EQ 1E44 61 PUSH2 0x0eb7 1E47 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E37 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0eb7, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_1E48: // Incoming jump from 0x1E47, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E4B memory[0x00:0x00] } 1E48 60 PUSH1 0x00 1E4A 80 DUP1 1E4B FD *REVERT // Stack delta = +0 // Outputs[1] { @1E4B revert(memory[0x00:0x00]); } // Block terminates label_1E4C: // Incoming call from 0x0279, returns to 0x027A // Inputs[2] // { // @1E52 stack[-1] // @1E53 stack[-2] // } 1E4C 5B JUMPDEST 1E4D 60 PUSH1 0x00 1E4F 80 DUP1 1E50 60 PUSH1 0x40 1E52 83 DUP4 1E53 85 DUP6 1E54 03 SUB 1E55 12 SLT 1E56 15 ISZERO 1E57 61 PUSH2 0x1e5f 1E5A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1E4D stack[0] = 0x00 // @1E4F stack[1] = 0x00 // } // Block ends with conditional jump to 0x1e5f, if !(stack[-2] - stack[-1] i< 0x40) label_1E5B: // Incoming jump from 0x1E5A, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E5E memory[0x00:0x00] } 1E5B 60 PUSH1 0x00 1E5D 80 DUP1 1E5E FD *REVERT // Stack delta = +0 // Outputs[1] { @1E5E revert(memory[0x00:0x00]); } // Block terminates label_1E5F: // Incoming jump from 0x1E5A, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1E63 stack[-3] } 1E5F 5B JUMPDEST 1E60 61 PUSH2 0x1e68 1E63 83 DUP4 1E64 61 PUSH2 0x1e35 1E67 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E60 stack[0] = 0x1e68 // @1E63 stack[1] = stack[-3] // } // Block ends with call to 0x1e35, returns to 0x1E68 label_1E68: // Incoming return from call to 0x1E35 at 0x1E67 // Inputs[4] // { // @1E69 stack[-1] // @1E69 stack[-3] // @1E6D stack[-4] // @1E6F msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 1E68 5B JUMPDEST 1E69 91 SWAP2 1E6A 50 POP 1E6B 60 PUSH1 0x20 1E6D 83 DUP4 1E6E 01 ADD 1E6F 35 CALLDATALOAD 1E70 60 PUSH1 0x01 1E72 60 PUSH1 0x01 1E74 60 PUSH1 0x60 1E76 1B SHL 1E77 03 SUB 1E78 81 DUP2 1E79 16 AND 1E7A 81 DUP2 1E7B 14 EQ 1E7C 61 PUSH2 0x1e84 1E7F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1E69 stack[-3] = stack[-1] // @1E6F stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x1e84, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 label_1E80: // Incoming jump from 0x1E7F, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 // Inputs[1] { @1E83 memory[0x00:0x00] } 1E80 60 PUSH1 0x00 1E82 80 DUP1 1E83 FD *REVERT // Stack delta = +0 // Outputs[1] { @1E83 revert(memory[0x00:0x00]); } // Block terminates label_1E84: // Incoming return from call to 0x2225 at 0x225E // Incoming jump from 0x1E7F, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] & (0x01 << 0x60) - 0x01 // Inputs[6] // { // @1E85 stack[-1] // @1E86 stack[-2] // @1E89 stack[-5] // @1E8B stack[-6] // @1E8B stack[-3] // @1E8C stack[-4] // } 1E84 5B JUMPDEST 1E85 80 DUP1 1E86 91 SWAP2 1E87 50 POP 1E88 50 POP 1E89 92 SWAP3 1E8A 50 POP 1E8B 92 SWAP3 1E8C 90 SWAP1 1E8D 50 POP 1E8E 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1E89 stack[-5] = stack[-1] // @1E8B stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_1E8F: // Incoming call from 0x1ECA, returns to 0x1ECB // Inputs[1] { @1E93 stack[-3] } 1E8F 5B JUMPDEST 1E90 60 PUSH1 0x00 1E92 5B JUMPDEST 1E93 83 DUP4 1E94 81 DUP2 1E95 10 LT 1E96 15 ISZERO 1E97 61 PUSH2 0x1eaa 1E9A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E90 stack[0] = 0x00 } // Block ends with conditional jump to 0x1eaa, if !(0x00 < stack[-3]) label_1E9B: // Incoming jump from 0x1E9A, if not !(0x00 < stack[-3]) // Incoming jump from 0x1E9A, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @1E9B stack[-2] // @1E9C stack[-1] // @1E9E memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1E9F stack[-3] // } 1E9B 81 DUP2 1E9C 81 DUP2 1E9D 01 ADD 1E9E 51 MLOAD 1E9F 83 DUP4 1EA0 82 DUP3 1EA1 01 ADD 1EA2 52 MSTORE 1EA3 60 PUSH1 0x20 1EA5 01 ADD 1EA6 61 PUSH2 0x1e92 1EA9 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1EA2 memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @1EA5 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1e92 label_1EAA: // Incoming jump from 0x1E9A, if !(0x00 < stack[-3]) // Incoming jump from 0x1E9A, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @1EAF stack[-4] // @1EB0 stack[-3] // @1EB2 stack[-5] // } 1EAA 5B JUMPDEST 1EAB 50 POP 1EAC 50 POP 1EAD 60 PUSH1 0x00 1EAF 91 SWAP2 1EB0 01 ADD 1EB1 52 MSTORE 1EB2 56 *JUMP // Stack delta = -5 // Outputs[1] { @1EB1 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_1EB3: // Incoming call from 0x1EF1, returns to 0x1961 // Inputs[3] // { // @1EB6 stack[-1] // @1EB7 memory[stack[-1]:stack[-1] + 0x20] // @1EB9 stack[-2] // } 1EB3 5B JUMPDEST 1EB4 60 PUSH1 0x00 1EB6 81 DUP2 1EB7 51 MLOAD 1EB8 80 DUP1 1EB9 84 DUP5 1EBA 52 MSTORE 1EBB 61 PUSH2 0x1ecb 1EBE 81 DUP2 1EBF 60 PUSH1 0x20 1EC1 86 DUP7 1EC2 01 ADD 1EC3 60 PUSH1 0x20 1EC5 86 DUP7 1EC6 01 ADD 1EC7 61 PUSH2 0x1e8f 1ECA 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @1EB4 stack[0] = 0x00 // @1EB7 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @1EBA memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1EBB stack[2] = 0x1ecb // @1EBE stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @1EC2 stack[4] = stack[-2] + 0x20 // @1EC6 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x1e8f, returns to 0x1ECB label_1ECB: // Incoming return from call to 0x1E8F at 0x1ECA // Inputs[4] // { // @1ECE stack[-1] // @1ED3 stack[-4] // @1ED4 stack[-2] // @1EDA stack[-5] // } 1ECB 5B JUMPDEST 1ECC 60 PUSH1 0x1f 1ECE 01 ADD 1ECF 60 PUSH1 0x1f 1ED1 19 NOT 1ED2 16 AND 1ED3 92 SWAP3 1ED4 90 SWAP1 1ED5 92 SWAP3 1ED6 01 ADD 1ED7 60 PUSH1 0x20 1ED9 01 ADD 1EDA 92 SWAP3 1EDB 91 SWAP2 1EDC 50 POP 1EDD 50 POP 1EDE 56 *JUMP // Stack delta = -4 // Outputs[1] { @1EDA stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_1EDF: // Incoming jump from 0x02A2 // Inputs[2] // { // @1EE2 stack[-1] // @1EED stack[-2] // } 1EDF 5B JUMPDEST 1EE0 60 PUSH1 0x20 1EE2 81 DUP2 1EE3 52 MSTORE 1EE4 60 PUSH1 0x00 1EE6 61 PUSH2 0x1961 1EE9 60 PUSH1 0x20 1EEB 83 DUP4 1EEC 01 ADD 1EED 84 DUP5 1EEE 61 PUSH2 0x1eb3 1EF1 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @1EE3 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @1EE4 stack[0] = 0x00 // @1EE6 stack[1] = 0x1961 // @1EEC stack[2] = stack[-1] + 0x20 // @1EED stack[3] = stack[-2] // } // Block ends with call to 0x1eb3, returns to 0x1961 label_1EF2: // Incoming call from 0x0679, returns to 0x067A // Incoming call from 0x02BD, returns to 0x02BE // Incoming call from 0x04B1, returns to 0x04B2 // Incoming call from 0x062C, returns to 0x062D // Incoming call from 0x0491, returns to 0x0492 // Inputs[2] // { // @1EF7 stack[-1] // @1EF8 stack[-2] // } 1EF2 5B JUMPDEST 1EF3 60 PUSH1 0x00 1EF5 60 PUSH1 0x20 1EF7 82 DUP3 1EF8 84 DUP5 1EF9 03 SUB 1EFA 12 SLT 1EFB 15 ISZERO 1EFC 61 PUSH2 0x1f04 1EFF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1EF3 stack[0] = 0x00 } // Block ends with conditional jump to 0x1f04, if !(stack[-2] - stack[-1] i< 0x20) label_1F00: // Incoming jump from 0x1EFF, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @1F03 memory[0x00:0x00] } 1F00 60 PUSH1 0x00 1F02 80 DUP1 1F03 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F03 revert(memory[0x00:0x00]); } // Block terminates label_1F04: // Incoming jump from 0x1EFF, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @1F06 msg.data[stack[-2]:stack[-2] + 0x20] // @1F06 stack[-2] // @1F07 stack[-4] // @1F08 stack[-3] // } 1F04 5B JUMPDEST 1F05 50 POP 1F06 35 CALLDATALOAD 1F07 91 SWAP2 1F08 90 SWAP1 1F09 50 POP 1F0A 56 *JUMP // Stack delta = -3 // Outputs[1] { @1F07 stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_1F0B: // Incoming jump from 0x02E8 // Incoming jump from 0x0444 // Inputs[2] // { // @1F11 stack[-1] // @1F12 stack[-2] // } 1F0B 5B JUMPDEST 1F0C 60 PUSH1 0x00 1F0E 80 DUP1 1F0F 60 PUSH1 0x40 1F11 83 DUP4 1F12 85 DUP6 1F13 03 SUB 1F14 12 SLT 1F15 15 ISZERO 1F16 61 PUSH2 0x1f1e 1F19 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F0C stack[0] = 0x00 // @1F0E stack[1] = 0x00 // } // Block ends with conditional jump to 0x1f1e, if !(stack[-2] - stack[-1] i< 0x40) label_1F1A: // Incoming jump from 0x1F19, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1F1D memory[0x00:0x00] } 1F1A 60 PUSH1 0x00 1F1C 80 DUP1 1F1D FD *REVERT // Stack delta = +0 // Outputs[1] { @1F1D revert(memory[0x00:0x00]); } // Block terminates label_1F1E: // Incoming jump from 0x1F19, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1F22 stack[-3] } 1F1E 5B JUMPDEST 1F1F 61 PUSH2 0x1f27 1F22 83 DUP4 1F23 61 PUSH2 0x1e35 1F26 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F1F stack[0] = 0x1f27 // @1F22 stack[1] = stack[-3] // } // Block ends with call to 0x1e35, returns to 0x1F27 label_1F27: // Incoming return from call to 0x1E35 at 0x1F26 // Incoming jump from 0x1F5A, if msg.data[stack[-3]:stack[-3] + 0x20] == msg.data[stack[-3]:stack[-3] + 0x20] & (0x01 << 0x40) - 0x01 // Inputs[5] // { // @1F28 stack[-6] // @1F28 stack[-1] // @1F2B stack[-4] // @1F2F msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @1F30 stack[-5] // } 1F27 5B JUMPDEST 1F28 94 SWAP5 1F29 60 PUSH1 0x20 1F2B 93 SWAP4 1F2C 90 SWAP1 1F2D 93 SWAP4 1F2E 01 ADD 1F2F 35 CALLDATALOAD 1F30 93 SWAP4 1F31 50 POP 1F32 50 POP 1F33 50 POP 1F34 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @1F28 stack[-6] = stack[-1] // @1F30 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_1F35: // Incoming call from 0x0368, returns to 0x0369 // Inputs[2] // { // @1F3B stack[-1] // @1F3C stack[-2] // } 1F35 5B JUMPDEST 1F36 60 PUSH1 0x00 1F38 80 DUP1 1F39 60 PUSH1 0x40 1F3B 83 DUP4 1F3C 85 DUP6 1F3D 03 SUB 1F3E 12 SLT 1F3F 15 ISZERO 1F40 61 PUSH2 0x1f48 1F43 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1F36 stack[0] = 0x00 // @1F38 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1f48, if !(stack[-2] - stack[-1] i< 0x40) label_1F44: // Incoming jump from 0x1F43, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @1F47 memory[0x00:0x00] } 1F44 60 PUSH1 0x00 1F46 80 DUP1 1F47 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F47 revert(memory[0x00:0x00]); } // Block terminates label_1F48: // Incoming jump from 0x1F43, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @1F49 stack[-3] // @1F4A msg.data[stack[-3]:stack[-3] + 0x20] // } 1F48 5B JUMPDEST 1F49 82 DUP3 1F4A 35 CALLDATALOAD 1F4B 60 PUSH1 0x01 1F4D 60 PUSH1 0x01 1F4F 60 PUSH1 0x40 1F51 1B SHL 1F52 03 SUB 1F53 81 DUP2 1F54 16 AND 1F55 81 DUP2 1F56 14 EQ 1F57 61 PUSH2 0x1f27 1F5A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1F4A stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x1f27, if msg.data[stack[-3]:stack[-3] + 0x20] == msg.data[stack[-3]:stack[-3] + 0x20] & (0x01 << 0x40) - 0x01 label_1F5B: // Incoming jump from 0x1F5A, if not msg.data[stack[-3]:stack[-3] + 0x20] == msg.data[stack[-3]:stack[-3] + 0x20] & (0x01 << 0x40) - 0x01 // Inputs[1] { @1F5E memory[0x00:0x00] } 1F5B 60 PUSH1 0x00 1F5D 80 DUP1 1F5E FD *REVERT // Stack delta = +0 // Outputs[1] { @1F5E revert(memory[0x00:0x00]); } // Block terminates label_1F5F: // Incoming call from 0x037B, returns to 0x037C // Incoming call from 0x0424, returns to 0x0425 // Inputs[2] // { // @1F67 stack[-1] // @1F68 stack[-2] // } 1F5F 5B JUMPDEST 1F60 60 PUSH1 0x00 1F62 80 DUP1 1F63 60 PUSH1 0x00 1F65 60 PUSH1 0x60 1F67 84 DUP5 1F68 86 DUP7 1F69 03 SUB 1F6A 12 SLT 1F6B 15 ISZERO 1F6C 61 PUSH2 0x1f74 1F6F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @1F60 stack[0] = 0x00 // @1F62 stack[1] = 0x00 // @1F63 stack[2] = 0x00 // } // Block ends with conditional jump to 0x1f74, if !(stack[-2] - stack[-1] i< 0x60) label_1F70: // Incoming jump from 0x1F6F, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1F73 memory[0x00:0x00] } 1F70 60 PUSH1 0x00 1F72 80 DUP1 1F73 FD *REVERT // Stack delta = +0 // Outputs[1] { @1F73 revert(memory[0x00:0x00]); } // Block terminates label_1F74: // Incoming jump from 0x1F6F, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @1F78 stack[-4] } 1F74 5B JUMPDEST 1F75 61 PUSH2 0x1f7d 1F78 84 DUP5 1F79 61 PUSH2 0x1e35 1F7C 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1F75 stack[0] = 0x1f7d // @1F78 stack[1] = stack[-4] // } // Block ends with call to 0x1e35, returns to 0x1F7D label_1F7D: // Incoming return from call to 0x1E35 at 0x1F7C // Inputs[3] // { // @1F7E stack[-1] // @1F7E stack[-4] // @1F85 stack[-5] // } 1F7D 5B JUMPDEST 1F7E 92 SWAP3 1F7F 50 POP 1F80 61 PUSH2 0x1f8b 1F83 60 PUSH1 0x20 1F85 85 DUP6 1F86 01 ADD 1F87 61 PUSH2 0x1e35 1F8A 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F7E stack[-4] = stack[-1] // @1F80 stack[-1] = 0x1f8b // @1F86 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x1e35, returns to 0x1F8B label_1F8B: // Incoming return from call to 0x1E35 at 0x1F8A // Inputs[8] // { // @1F8C stack[-1] // @1F8C stack[-3] // @1F90 stack[-5] // @1F92 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1F93 stack[-2] // @1F97 stack[-6] // @1F99 stack[-7] // @1F99 stack[-4] // } 1F8B 5B JUMPDEST 1F8C 91 SWAP2 1F8D 50 POP 1F8E 60 PUSH1 0x40 1F90 84 DUP5 1F91 01 ADD 1F92 35 CALLDATALOAD 1F93 90 SWAP1 1F94 50 POP 1F95 92 SWAP3 1F96 50 POP 1F97 92 SWAP3 1F98 50 POP 1F99 92 SWAP3 1F9A 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @1F95 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @1F97 stack[-6] = stack[-1] // @1F99 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_1F9B: // Incoming jump from 0x24B4 // Incoming jump from 0x1FCA // Incoming jump from 0x1FF2 // Inputs[1] { @1FB0 memory[0x00:0x24] } 1F9B 5B JUMPDEST 1F9C 63 PUSH4 0x4e487b71 1FA1 60 PUSH1 0xe0 1FA3 1B SHL 1FA4 60 PUSH1 0x00 1FA6 52 MSTORE 1FA7 60 PUSH1 0x41 1FA9 60 PUSH1 0x04 1FAB 52 MSTORE 1FAC 60 PUSH1 0x24 1FAE 60 PUSH1 0x00 1FB0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1FA6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1FAB memory[0x04:0x24] = 0x41 // @1FB0 revert(memory[0x00:0x24]); // } // Block terminates label_1FB1: // Incoming call from 0x2045, returns to 0x1961 // Incoming call from 0x230D, returns to 0x0D0F // Inputs[1] { @1FBD stack[-2] } 1FB1 5B JUMPDEST 1FB2 60 PUSH1 0x00 1FB4 60 PUSH1 0x01 1FB6 60 PUSH1 0x01 1FB8 60 PUSH1 0x40 1FBA 1B SHL 1FBB 03 SUB 1FBC 80 DUP1 1FBD 84 DUP5 1FBE 11 GT 1FBF 15 ISZERO 1FC0 61 PUSH2 0x1fcb 1FC3 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FB2 stack[0] = 0x00 // @1FBB stack[1] = (0x01 << 0x40) - 0x01 // } // Block ends with conditional jump to 0x1fcb, if !(stack[-2] > (0x01 << 0x40) - 0x01) label_1FC4: // Incoming jump from 0x1FC3, if not !(stack[-2] > (0x01 << 0x40) - 0x01) 1FC4 61 PUSH2 0x1fcb 1FC7 61 PUSH2 0x1f9b 1FCA 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FC4 stack[0] = 0x1fcb } // Block ends with unconditional jump to 0x1f9b label_1FCB: // Incoming jump from 0x1FC3, if !(stack[-2] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @1FCE memory[0x40:0x60] // @1FD1 stack[-4] // @1FE0 stack[-1] // } 1FCB 5B JUMPDEST 1FCC 60 PUSH1 0x40 1FCE 51 MLOAD 1FCF 60 PUSH1 0x1f 1FD1 85 DUP6 1FD2 01 ADD 1FD3 60 PUSH1 0x1f 1FD5 19 NOT 1FD6 90 SWAP1 1FD7 81 DUP2 1FD8 16 AND 1FD9 60 PUSH1 0x3f 1FDB 01 ADD 1FDC 16 AND 1FDD 81 DUP2 1FDE 01 ADD 1FDF 90 SWAP1 1FE0 82 DUP3 1FE1 82 DUP3 1FE2 11 GT 1FE3 81 DUP2 1FE4 83 DUP4 1FE5 10 LT 1FE6 17 OR 1FE7 15 ISZERO 1FE8 61 PUSH2 0x1ff3 1FEB 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1FDF stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @1FDF stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x1ff3, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_1FEC: // Incoming jump from 0x1FEB, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 1FEC 61 PUSH2 0x1ff3 1FEF 61 PUSH2 0x1f9b 1FF2 56 *JUMP // Stack delta = +1 // Outputs[1] { @1FEC stack[0] = 0x1ff3 } // Block ends with unconditional jump to 0x1f9b label_1FF3: // Incoming jump from 0x1FEB, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @1FF4 stack[-2] // @1FF8 stack[-1] // @1FF9 stack[-4] // @1FFB stack[-6] // @1FFE stack[-7] // @2000 stack[-5] // } 1FF3 5B JUMPDEST 1FF4 81 DUP2 1FF5 60 PUSH1 0x40 1FF7 52 MSTORE 1FF8 80 DUP1 1FF9 93 SWAP4 1FFA 50 POP 1FFB 85 DUP6 1FFC 81 DUP2 1FFD 52 MSTORE 1FFE 86 DUP7 1FFF 86 DUP7 2000 86 DUP7 2001 01 ADD 2002 11 GT 2003 15 ISZERO 2004 61 PUSH2 0x200c 2007 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @1FF7 memory[0x40:0x60] = stack[-2] // @1FF9 stack[-4] = stack[-1] // @1FFD memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x200c, if !(stack[-5] + stack[-6] > stack[-7]) label_2008: // Incoming jump from 0x2007, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @200B memory[0x00:0x00] } 2008 60 PUSH1 0x00 200A 80 DUP1 200B FD *REVERT // Stack delta = +0 // Outputs[1] { @200B revert(memory[0x00:0x00]); } // Block terminates label_200C: // Incoming jump from 0x2007, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @200D stack[-6] // @200E stack[-5] // @2011 stack[-1] // @2013 msg.data[stack[-5]:stack[-5] + stack[-6]] // @2020 stack[-4] // @2020 stack[-8] // @2021 stack[-7] // } 200C 5B JUMPDEST 200D 85 DUP6 200E 85 DUP6 200F 60 PUSH1 0x20 2011 83 DUP4 2012 01 ADD 2013 37 CALLDATACOPY 2014 60 PUSH1 0x00 2016 60 PUSH1 0x20 2018 87 DUP8 2019 83 DUP4 201A 01 ADD 201B 01 ADD 201C 52 MSTORE 201D 50 POP 201E 50 POP 201F 50 POP 2020 93 SWAP4 2021 92 SWAP3 2022 50 POP 2023 50 POP 2024 50 POP 2025 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @2013 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @201C memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @2020 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_2026: // Incoming call from 0x2079, returns to 0x0D0F // Incoming call from 0x22B9, returns to 0x22BA // Inputs[2] // { // @2029 stack[-2] // @202C stack[-1] // } 2026 5B JUMPDEST 2027 60 PUSH1 0x00 2029 82 DUP3 202A 60 PUSH1 0x1f 202C 83 DUP4 202D 01 ADD 202E 12 SLT 202F 61 PUSH2 0x2037 2032 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2027 stack[0] = 0x00 } // Block ends with conditional jump to 0x2037, if stack[-1] + 0x1f i< stack[-2] label_2033: // Incoming jump from 0x2032, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @2036 memory[0x00:0x00] } 2033 60 PUSH1 0x00 2035 80 DUP1 2036 FD *REVERT // Stack delta = +0 // Outputs[1] { @2036 revert(memory[0x00:0x00]); } // Block terminates label_2037: // Incoming jump from 0x2032, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @203B stack[-3] // @203C stack[-2] // @203D msg.data[stack[-2]:stack[-2] + 0x20] // } 2037 5B JUMPDEST 2038 61 PUSH2 0x1961 203B 83 DUP4 203C 83 DUP4 203D 35 CALLDATALOAD 203E 60 PUSH1 0x20 2040 85 DUP6 2041 01 ADD 2042 61 PUSH2 0x1fb1 2045 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2038 stack[0] = 0x1961 // @203B stack[1] = stack[-3] // @203D stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @2041 stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x1fb1, returns to 0x1961 label_2046: // Incoming call from 0x039B, returns to 0x039C // Inputs[2] // { // @204B stack[-1] // @204C stack[-2] // } 2046 5B JUMPDEST 2047 60 PUSH1 0x00 2049 60 PUSH1 0x20 204B 82 DUP3 204C 84 DUP5 204D 03 SUB 204E 12 SLT 204F 15 ISZERO 2050 61 PUSH2 0x2058 2053 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2047 stack[0] = 0x00 } // Block ends with conditional jump to 0x2058, if !(stack[-2] - stack[-1] i< 0x20) label_2054: // Incoming jump from 0x2053, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2057 memory[0x00:0x00] } 2054 60 PUSH1 0x00 2056 80 DUP1 2057 FD *REVERT // Stack delta = +0 // Outputs[1] { @2057 revert(memory[0x00:0x00]); } // Block terminates label_2058: // Incoming jump from 0x2053, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2059 stack[-2] // @205A msg.data[stack[-2]:stack[-2] + 0x20] // } 2058 5B JUMPDEST 2059 81 DUP2 205A 35 CALLDATALOAD 205B 60 PUSH1 0x01 205D 60 PUSH1 0x01 205F 60 PUSH1 0x40 2061 1B SHL 2062 03 SUB 2063 81 DUP2 2064 11 GT 2065 15 ISZERO 2066 61 PUSH2 0x206e 2069 57 *JUMPI // Stack delta = +1 // Outputs[1] { @205A stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x206e, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_206A: // Incoming jump from 0x2069, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @206D memory[0x00:0x00] } 206A 60 PUSH1 0x00 206C 80 DUP1 206D FD *REVERT // Stack delta = +0 // Outputs[1] { @206D revert(memory[0x00:0x00]); } // Block terminates label_206E: // Incoming jump from 0x2069, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @2072 stack[-4] // @2073 stack[-1] // @2074 stack[-3] // } 206E 5B JUMPDEST 206F 61 PUSH2 0x0d0f 2072 84 DUP5 2073 82 DUP3 2074 85 DUP6 2075 01 ADD 2076 61 PUSH2 0x2026 2079 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @206F stack[0] = 0x0d0f // @2072 stack[1] = stack[-4] // @2075 stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x2026, returns to 0x0D0F label_207A: // Incoming call from 0x03BB, returns to 0x03BC // Inputs[2] // { // @2080 stack[-1] // @2081 stack[-2] // } 207A 5B JUMPDEST 207B 60 PUSH1 0x00 207D 80 DUP1 207E 60 PUSH1 0x40 2080 83 DUP4 2081 85 DUP6 2082 03 SUB 2083 12 SLT 2084 15 ISZERO 2085 61 PUSH2 0x208d 2088 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @207B stack[0] = 0x00 // @207D stack[1] = 0x00 // } // Block ends with conditional jump to 0x208d, if !(stack[-2] - stack[-1] i< 0x40) label_2089: // Incoming jump from 0x2088, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @208C memory[0x00:0x00] } 2089 60 PUSH1 0x00 208B 80 DUP1 208C FD *REVERT // Stack delta = +0 // Outputs[1] { @208C revert(memory[0x00:0x00]); } // Block terminates label_208D: // Incoming jump from 0x2088, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[5] // { // @2090 stack[-3] // @2091 msg.data[stack[-3]:stack[-3] + 0x20] // @2092 stack[-5] // @2098 msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @2099 stack[-4] // } 208D 5B JUMPDEST 208E 50 POP 208F 50 POP 2090 80 DUP1 2091 35 CALLDATALOAD 2092 92 SWAP3 2093 60 PUSH1 0x20 2095 90 SWAP1 2096 91 SWAP2 2097 01 ADD 2098 35 CALLDATALOAD 2099 91 SWAP2 209A 50 POP 209B 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @2092 stack[-5] = msg.data[stack[-3]:stack[-3] + 0x20] // @2099 stack[-4] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with unconditional jump to stack[-5] label_209C: // Incoming call from 0x2114, returns to 0x2115 // Incoming call from 0x2361, returns to 0x2362 // Inputs[2] // { // @20A0 stack[-2] // @20A3 stack[-1] // } 209C 5B JUMPDEST 209D 60 PUSH1 0x00 209F 80 DUP1 20A0 83 DUP4 20A1 60 PUSH1 0x1f 20A3 84 DUP5 20A4 01 ADD 20A5 12 SLT 20A6 61 PUSH2 0x20ae 20A9 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @209D stack[0] = 0x00 // @209F stack[1] = 0x00 // } // Block ends with conditional jump to 0x20ae, if stack[-1] + 0x1f i< stack[-2] label_20AA: // Incoming jump from 0x20A9, if not stack[-1] + 0x1f i< stack[-2] // Inputs[1] { @20AD memory[0x00:0x00] } 20AA 60 PUSH1 0x00 20AC 80 DUP1 20AD FD *REVERT // Stack delta = +0 // Outputs[1] { @20AD revert(memory[0x00:0x00]); } // Block terminates label_20AE: // Incoming jump from 0x20A9, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @20B0 stack[-3] // @20B1 msg.data[stack[-3]:stack[-3] + 0x20] // } 20AE 5B JUMPDEST 20AF 50 POP 20B0 81 DUP2 20B1 35 CALLDATALOAD 20B2 60 PUSH1 0x01 20B4 60 PUSH1 0x01 20B6 60 PUSH1 0x40 20B8 1B SHL 20B9 03 SUB 20BA 81 DUP2 20BB 11 GT 20BC 15 ISZERO 20BD 61 PUSH2 0x20c5 20C0 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20B1 stack[-1] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x20c5, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_20C1: // Incoming jump from 0x20C0, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @20C4 memory[0x00:0x00] } 20C1 60 PUSH1 0x00 20C3 80 DUP1 20C4 FD *REVERT // Stack delta = +0 // Outputs[1] { @20C4 revert(memory[0x00:0x00]); } // Block terminates label_20C5: // Incoming jump from 0x20C0, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[4] // { // @20C8 stack[-3] // @20CA stack[-2] // @20CC stack[-4] // @20CF stack[-1] // } 20C5 5B JUMPDEST 20C6 60 PUSH1 0x20 20C8 83 DUP4 20C9 01 ADD 20CA 91 SWAP2 20CB 50 POP 20CC 83 DUP4 20CD 60 PUSH1 0x20 20CF 82 DUP3 20D0 60 PUSH1 0x05 20D2 1B SHL 20D3 85 DUP6 20D4 01 ADD 20D5 01 ADD 20D6 11 GT 20D7 15 ISZERO 20D8 61 PUSH2 0x0b26 20DB 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20CA stack[-2] = stack[-3] + 0x20 } // Block ends with conditional jump to 0x0b26, if !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) label_20DC: // Incoming jump from 0x20DB, if not !(stack[-3] + (stack[-1] << 0x05) + 0x20 > stack[-4]) // Inputs[1] { @20DF memory[0x00:0x00] } 20DC 60 PUSH1 0x00 20DE 80 DUP1 20DF FD *REVERT // Stack delta = +0 // Outputs[1] { @20DF revert(memory[0x00:0x00]); } // Block terminates label_20E0: // Incoming call from 0x0464, returns to 0x0465 // Inputs[2] // { // @20E6 stack[-1] // @20E7 stack[-2] // } 20E0 5B JUMPDEST 20E1 60 PUSH1 0x00 20E3 80 DUP1 20E4 60 PUSH1 0x20 20E6 83 DUP4 20E7 85 DUP6 20E8 03 SUB 20E9 12 SLT 20EA 15 ISZERO 20EB 61 PUSH2 0x20f3 20EE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @20E1 stack[0] = 0x00 // @20E3 stack[1] = 0x00 // } // Block ends with conditional jump to 0x20f3, if !(stack[-2] - stack[-1] i< 0x20) label_20EF: // Incoming jump from 0x20EE, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @20F2 memory[0x00:0x00] } 20EF 60 PUSH1 0x00 20F1 80 DUP1 20F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @20F2 revert(memory[0x00:0x00]); } // Block terminates label_20F3: // Incoming jump from 0x20EE, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @20F4 stack[-3] // @20F5 msg.data[stack[-3]:stack[-3] + 0x20] // } 20F3 5B JUMPDEST 20F4 82 DUP3 20F5 35 CALLDATALOAD 20F6 60 PUSH1 0x01 20F8 60 PUSH1 0x01 20FA 60 PUSH1 0x40 20FC 1B SHL 20FD 03 SUB 20FE 81 DUP2 20FF 11 GT 2100 15 ISZERO 2101 61 PUSH2 0x2109 2104 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20F5 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] } // Block ends with conditional jump to 0x2109, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) label_2105: // Incoming jump from 0x2104, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2108 memory[0x00:0x00] } 2105 60 PUSH1 0x00 2107 80 DUP1 2108 FD *REVERT // Stack delta = +0 // Outputs[1] { @2108 revert(memory[0x00:0x00]); } // Block terminates label_2109: // Incoming jump from 0x2104, if !(msg.data[stack[-3]:stack[-3] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @210D stack[-5] // @210E stack[-1] // @210F stack[-4] // } 2109 5B JUMPDEST 210A 61 PUSH2 0x2115 210D 85 DUP6 210E 82 DUP3 210F 86 DUP7 2110 01 ADD 2111 61 PUSH2 0x209c 2114 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @210A stack[0] = 0x2115 // @210D stack[1] = stack[-5] // @2110 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x209c, returns to 0x2115 label_2115: // Incoming return from call to 0x209C at 0x2114 // Inputs[5] // { // @2116 stack[-2] // @2116 stack[-1] // @2117 stack[-8] // @2119 stack[-7] // @211B stack[-6] // } 2115 5B JUMPDEST 2116 90 SWAP1 2117 96 SWAP7 2118 90 SWAP1 2119 95 SWAP6 211A 50 POP 211B 93 SWAP4 211C 50 POP 211D 50 POP 211E 50 POP 211F 50 POP 2120 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @2117 stack[-8] = stack[-2] // @2119 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] label_2121: // Incoming call from 0x218B, returns to 0x218C // Incoming call from 0x231B, returns to 0x0761 // Inputs[7] // { // @2122 stack[-1] // @2123 memory[stack[-1]:stack[-1] + 0x20] // @212D stack[-2] // @2134 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @2147 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @2153 memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // @215C stack[-3] // } 2121 5B JUMPDEST 2122 80 DUP1 2123 51 MLOAD 2124 60 PUSH1 0x01 2126 60 PUSH1 0x01 2128 60 PUSH1 0xa0 212A 1B SHL 212B 03 SUB 212C 16 AND 212D 82 DUP3 212E 52 MSTORE 212F 60 PUSH1 0x20 2131 80 DUP1 2132 82 DUP3 2133 01 ADD 2134 51 MLOAD 2135 60 PUSH1 0x01 2137 60 PUSH1 0x01 2139 60 PUSH1 0x40 213B 1B SHL 213C 03 SUB 213D 16 AND 213E 90 SWAP1 213F 83 DUP4 2140 01 ADD 2141 52 MSTORE 2142 60 PUSH1 0x40 2144 80 DUP1 2145 82 DUP3 2146 01 ADD 2147 51 MLOAD 2148 15 ISZERO 2149 15 ISZERO 214A 90 SWAP1 214B 83 DUP4 214C 01 ADD 214D 52 MSTORE 214E 60 PUSH1 0x60 2150 90 SWAP1 2151 81 DUP2 2152 01 ADD 2153 51 MLOAD 2154 62 PUSH3 0xffffff 2158 16 AND 2159 91 SWAP2 215A 01 ADD 215B 52 MSTORE 215C 56 *JUMP // Stack delta = -3 // Outputs[4] // { // @212E memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & memory[stack[-1]:stack[-1] + 0x20] // @2141 memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = (0x01 << 0x40) - 0x01 & memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] // @214D memory[stack[-2] + 0x40:stack[-2] + 0x40 + 0x20] = !!memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] // @215B memory[stack[-2] + 0x60:stack[-2] + 0x60 + 0x20] = 0xffffff & memory[0x60 + stack[-1]:0x60 + stack[-1] + 0x20] // } // Block ends with unconditional jump to stack[-3] label_215D: // Incoming call from 0x0476, returns to 0x0256 // Inputs[3] // { // @2161 stack[-1] // @2163 stack[-2] // @2164 memory[stack[-2]:stack[-2] + 0x20] // } 215D 5B JUMPDEST 215E 60 PUSH1 0x20 2160 80 DUP1 2161 82 DUP3 2162 52 MSTORE 2163 82 DUP3 2164 51 MLOAD 2165 82 DUP3 2166 82 DUP3 2167 01 ADD 2168 81 DUP2 2169 90 SWAP1 216A 52 MSTORE 216B 60 PUSH1 0x00 216D 91 SWAP2 216E 90 SWAP1 216F 84 DUP5 2170 82 DUP3 2171 01 ADD 2172 90 SWAP1 2173 60 PUSH1 0x40 2175 85 DUP6 2176 01 ADD 2177 90 SWAP1 2178 84 DUP5 2179 5B JUMPDEST 217A 81 DUP2 217B 81 DUP2 217C 10 LT 217D 15 ISZERO 217E 61 PUSH2 0x17bc 2181 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @2162 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @216A memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @216D stack[0] = 0x00 // @216E stack[1] = 0x20 // @2172 stack[2] = 0x20 + stack[-2] // @2177 stack[3] = stack[-1] + 0x40 // @2177 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @2178 stack[5] = 0x00 // } // Block ends with conditional jump to 0x17bc, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_2182: // Incoming jump from 0x2181, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x2181, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @2185 stack[-3] // @2186 stack[-4] // @2187 memory[stack[-4]:stack[-4] + 0x20] // } 2182 61 PUSH2 0x218c 2185 83 DUP4 2186 85 DUP6 2187 51 MLOAD 2188 61 PUSH2 0x2121 218B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2182 stack[0] = 0x218c // @2185 stack[1] = stack[-3] // @2187 stack[2] = memory[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x2121, returns to 0x218C label_218C: // Incoming return from call to 0x2121 at 0x218B // Inputs[4] // { // @218D stack[-1] // @218D stack[-4] // @218E stack[-5] // @2193 stack[-3] // } 218C 5B JUMPDEST 218D 92 SWAP3 218E 84 DUP5 218F 01 ADD 2190 92 SWAP3 2191 60 PUSH1 0x80 2193 92 SWAP3 2194 90 SWAP1 2195 92 SWAP3 2196 01 ADD 2197 91 SWAP2 2198 60 PUSH1 0x01 219A 01 ADD 219B 61 PUSH2 0x2179 219E 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @2190 stack[-4] = stack[-5] + stack[-4] // @2197 stack[-3] = 0x80 + stack[-3] // @219A stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2179 label_219F: // Incoming call from 0x0741, returns to 0x0742 // Incoming call from 0x0506, returns to 0x0507 // Incoming call from 0x060C, returns to 0x060D // Incoming call from 0x04D1, returns to 0x04D2 // Inputs[2] // { // @21A4 stack[-1] // @21A5 stack[-2] // } 219F 5B JUMPDEST 21A0 60 PUSH1 0x00 21A2 60 PUSH1 0x20 21A4 82 DUP3 21A5 84 DUP5 21A6 03 SUB 21A7 12 SLT 21A8 15 ISZERO 21A9 61 PUSH2 0x21b1 21AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @21A0 stack[0] = 0x00 } // Block ends with conditional jump to 0x21b1, if !(stack[-2] - stack[-1] i< 0x20) label_21AD: // Incoming jump from 0x21AC, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @21B0 memory[0x00:0x00] } 21AD 60 PUSH1 0x00 21AF 80 DUP1 21B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @21B0 revert(memory[0x00:0x00]); } // Block terminates label_21B1: // Incoming jump from 0x21AC, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @21B5 stack[-2] } 21B1 5B JUMPDEST 21B2 61 PUSH2 0x1961 21B5 82 DUP3 21B6 61 PUSH2 0x1e35 21B9 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21B2 stack[0] = 0x1961 // @21B5 stack[1] = stack[-2] // } // Block ends with call to 0x1e35, returns to 0x1961 label_21BA: // Incoming call from 0x0518, returns to 0x0256 // Inputs[3] // { // @21BE stack[-1] // @21C0 stack[-2] // @21C1 memory[stack[-2]:stack[-2] + 0x20] // } 21BA 5B JUMPDEST 21BB 60 PUSH1 0x20 21BD 80 DUP1 21BE 82 DUP3 21BF 52 MSTORE 21C0 82 DUP3 21C1 51 MLOAD 21C2 82 DUP3 21C3 82 DUP3 21C4 01 ADD 21C5 81 DUP2 21C6 90 SWAP1 21C7 52 MSTORE 21C8 60 PUSH1 0x00 21CA 91 SWAP2 21CB 90 SWAP1 21CC 84 DUP5 21CD 82 DUP3 21CE 01 ADD 21CF 90 SWAP1 21D0 60 PUSH1 0x40 21D2 85 DUP6 21D3 01 ADD 21D4 90 SWAP1 21D5 84 DUP5 21D6 5B JUMPDEST 21D7 81 DUP2 21D8 81 DUP2 21D9 10 LT 21DA 15 ISZERO 21DB 61 PUSH2 0x17bc 21DE 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @21BF memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @21C7 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @21CA stack[0] = 0x00 // @21CB stack[1] = 0x20 // @21CF stack[2] = 0x20 + stack[-2] // @21D4 stack[3] = stack[-1] + 0x40 // @21D4 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @21D5 stack[5] = 0x00 // } // Block ends with conditional jump to 0x17bc, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_21DF: // Incoming jump from 0x21DE, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x21DE, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[5] // { // @21DF stack[-4] // @21E0 memory[stack[-4]:stack[-4] + 0x20] // @21E1 stack[-3] // @21E3 stack[-1] // @21E4 stack[-5] // } 21DF 83 DUP4 21E0 51 MLOAD 21E1 83 DUP4 21E2 52 MSTORE 21E3 92 SWAP3 21E4 84 DUP5 21E5 01 ADD 21E6 92 SWAP3 21E7 91 SWAP2 21E8 84 DUP5 21E9 01 ADD 21EA 91 SWAP2 21EB 60 PUSH1 0x01 21ED 01 ADD 21EE 61 PUSH2 0x21d6 21F1 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @21E2 memory[stack[-3]:stack[-3] + 0x20] = memory[stack[-4]:stack[-4] + 0x20] // @21E6 stack[-4] = stack[-5] + stack[-4] // @21EA stack[-3] = stack[-5] + stack[-3] // @21ED stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x21d6 label_21F2: // Incoming call from 0x0566, returns to 0x0567 // Inputs[2] // { // @21FA stack[-1] // @21FB stack[-2] // } 21F2 5B JUMPDEST 21F3 60 PUSH1 0x00 21F5 80 DUP1 21F6 60 PUSH1 0x00 21F8 60 PUSH1 0x60 21FA 84 DUP5 21FB 86 DUP7 21FC 03 SUB 21FD 12 SLT 21FE 15 ISZERO 21FF 61 PUSH2 0x2207 2202 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @21F3 stack[0] = 0x00 // @21F5 stack[1] = 0x00 // @21F6 stack[2] = 0x00 // } // Block ends with conditional jump to 0x2207, if !(stack[-2] - stack[-1] i< 0x60) label_2203: // Incoming jump from 0x2202, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2206 memory[0x00:0x00] } 2203 60 PUSH1 0x00 2205 80 DUP1 2206 FD *REVERT // Stack delta = +0 // Outputs[1] { @2206 revert(memory[0x00:0x00]); } // Block terminates label_2207: // Incoming jump from 0x2202, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @220B stack[-4] } 2207 5B JUMPDEST 2208 61 PUSH2 0x2210 220B 84 DUP5 220C 61 PUSH2 0x1e35 220F 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2208 stack[0] = 0x2210 // @220B stack[1] = stack[-4] // } // Block ends with call to 0x1e35, returns to 0x2210 label_2210: // Incoming return from call to 0x1E35 at 0x220F // Inputs[7] // { // @2211 stack[-1] // @2211 stack[-7] // @2214 stack[-5] // @2216 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2217 stack[-6] // @221E msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @2220 stack[-4] // } 2210 5B JUMPDEST 2211 95 SWAP6 2212 60 PUSH1 0x20 2214 85 DUP6 2215 01 ADD 2216 35 CALLDATALOAD 2217 95 SWAP6 2218 50 POP 2219 60 PUSH1 0x40 221B 90 SWAP1 221C 94 SWAP5 221D 01 ADD 221E 35 CALLDATALOAD 221F 93 SWAP4 2220 92 SWAP3 2221 50 POP 2222 50 POP 2223 50 POP 2224 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2211 stack[-7] = stack[-1] // @2217 stack[-6] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @221F stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with unconditional jump to stack[-7] label_2225: // Incoming call from 0x261B, returns to 0x1961 // Incoming call from 0x225E, returns to 0x1E84 // Inputs[1] { @2226 stack[-1] } 2225 5B JUMPDEST 2226 80 DUP1 2227 15 ISZERO 2228 15 ISZERO 2229 81 DUP2 222A 14 EQ 222B 61 PUSH2 0x10b7 222E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10b7, if stack[-1] == !!stack[-1] label_222F: // Incoming jump from 0x222E, if not stack[-1] == !!stack[-1] // 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 0x0586 // Inputs[2] // { // @2239 stack[-1] // @223A stack[-2] // } 2233 5B JUMPDEST 2234 60 PUSH1 0x00 2236 80 DUP1 2237 60 PUSH1 0x40 2239 83 DUP4 223A 85 DUP6 223B 03 SUB 223C 12 SLT 223D 15 ISZERO 223E 61 PUSH2 0x2246 2241 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2234 stack[0] = 0x00 // @2236 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2246, if !(stack[-2] - stack[-1] i< 0x40) label_2242: // Incoming jump from 0x2241, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2245 memory[0x00:0x00] } 2242 60 PUSH1 0x00 2244 80 DUP1 2245 FD *REVERT // Stack delta = +0 // Outputs[1] { @2245 revert(memory[0x00:0x00]); } // Block terminates label_2246: // Incoming jump from 0x2241, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @224A stack[-3] } 2246 5B JUMPDEST 2247 61 PUSH2 0x224f 224A 83 DUP4 224B 61 PUSH2 0x1e35 224E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2247 stack[0] = 0x224f // @224A stack[1] = stack[-3] // } // Block ends with call to 0x1e35, returns to 0x224F label_224F: // Incoming return from call to 0x1E35 at 0x224E // Inputs[4] // { // @2250 stack[-3] // @2250 stack[-1] // @2254 stack[-4] // @2256 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 224F 5B JUMPDEST 2250 91 SWAP2 2251 50 POP 2252 60 PUSH1 0x20 2254 83 DUP4 2255 01 ADD 2256 35 CALLDATALOAD 2257 61 PUSH2 0x1e84 225A 81 DUP2 225B 61 PUSH2 0x2225 225E 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2250 stack[-3] = stack[-1] // @2256 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // @2257 stack[0] = 0x1e84 // @225A stack[1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with call to 0x2225, returns to 0x1E84 label_225F: // Incoming call from 0x05CC, returns to 0x05CD // Inputs[2] // { // @2268 stack[-1] // @2269 stack[-2] // } 225F 5B JUMPDEST 2260 60 PUSH1 0x00 2262 80 DUP1 2263 60 PUSH1 0x00 2265 80 DUP1 2266 60 PUSH1 0x80 2268 85 DUP6 2269 87 DUP8 226A 03 SUB 226B 12 SLT 226C 15 ISZERO 226D 61 PUSH2 0x2275 2270 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2260 stack[0] = 0x00 // @2262 stack[1] = 0x00 // @2263 stack[2] = 0x00 // @2265 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2275, if !(stack[-2] - stack[-1] i< 0x80) label_2271: // Incoming jump from 0x2270, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2274 memory[0x00:0x00] } 2271 60 PUSH1 0x00 2273 80 DUP1 2274 FD *REVERT // Stack delta = +0 // Outputs[1] { @2274 revert(memory[0x00:0x00]); } // Block terminates label_2275: // Incoming jump from 0x2270, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2279 stack[-5] } 2275 5B JUMPDEST 2276 61 PUSH2 0x227e 2279 85 DUP6 227A 61 PUSH2 0x1e35 227D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2276 stack[0] = 0x227e // @2279 stack[1] = stack[-5] // } // Block ends with call to 0x1e35, returns to 0x227E label_227E: // Incoming return from call to 0x1E35 at 0x227D // Inputs[3] // { // @227F stack[-5] // @227F stack[-1] // @2286 stack[-6] // } 227E 5B JUMPDEST 227F 93 SWAP4 2280 50 POP 2281 61 PUSH2 0x228c 2284 60 PUSH1 0x20 2286 86 DUP7 2287 01 ADD 2288 61 PUSH2 0x1e35 228B 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @227F stack[-5] = stack[-1] // @2281 stack[-1] = 0x228c // @2287 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x1e35, returns to 0x228C label_228C: // Incoming return from call to 0x1E35 at 0x228B // Inputs[6] // { // @228D stack[-1] // @228D stack[-4] // @2291 stack[-6] // @2293 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2294 stack[-3] // @229A msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 228C 5B JUMPDEST 228D 92 SWAP3 228E 50 POP 228F 60 PUSH1 0x40 2291 85 DUP6 2292 01 ADD 2293 35 CALLDATALOAD 2294 91 SWAP2 2295 50 POP 2296 60 PUSH1 0x60 2298 85 DUP6 2299 01 ADD 229A 35 CALLDATALOAD 229B 60 PUSH1 0x01 229D 60 PUSH1 0x01 229F 60 PUSH1 0x40 22A1 1B SHL 22A2 03 SUB 22A3 81 DUP2 22A4 11 GT 22A5 15 ISZERO 22A6 61 PUSH2 0x22ae 22A9 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @228D stack[-4] = stack[-1] // @2294 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @229A stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x22ae, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) label_22AA: // Incoming jump from 0x22A9, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @22AD memory[0x00:0x00] } 22AA 60 PUSH1 0x00 22AC 80 DUP1 22AD FD *REVERT // Stack delta = +0 // Outputs[1] { @22AD revert(memory[0x00:0x00]); } // Block terminates label_22AE: // Incoming jump from 0x22A9, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @22B2 stack[-7] // @22B3 stack[-1] // @22B4 stack[-6] // } 22AE 5B JUMPDEST 22AF 61 PUSH2 0x22ba 22B2 87 DUP8 22B3 82 DUP3 22B4 88 DUP9 22B5 01 ADD 22B6 61 PUSH2 0x2026 22B9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @22AF stack[0] = 0x22ba // @22B2 stack[1] = stack[-7] // @22B5 stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x2026, returns to 0x22BA label_22BA: // Incoming return from call to 0x2026 at 0x22B9 // Inputs[8] // { // @22BB stack[-1] // @22BB stack[-3] // @22BE stack[-6] // @22BF stack[-9] // @22C0 stack[-5] // @22C1 stack[-8] // @22C3 stack[-4] // @22C3 stack[-7] // } 22BA 5B JUMPDEST 22BB 91 SWAP2 22BC 50 POP 22BD 50 POP 22BE 92 SWAP3 22BF 95 SWAP6 22C0 91 SWAP2 22C1 94 SWAP5 22C2 50 POP 22C3 92 SWAP3 22C4 50 POP 22C5 56 *JUMP // Stack delta = -5 // Outputs[4] // { // @22BE stack[-6] = stack[-1] // @22BF stack[-9] = stack[-6] // @22C1 stack[-8] = stack[-5] // @22C3 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_22C6: // Incoming call from 0x0659, returns to 0x065A // Incoming call from 0x05EC, returns to 0x05ED // Inputs[2] // { // @22CB stack[-1] // @22CC stack[-2] // } 22C6 5B JUMPDEST 22C7 60 PUSH1 0x00 22C9 60 PUSH1 0x20 22CB 82 DUP3 22CC 84 DUP5 22CD 03 SUB 22CE 12 SLT 22CF 15 ISZERO 22D0 61 PUSH2 0x22d8 22D3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22C7 stack[0] = 0x00 } // Block ends with conditional jump to 0x22d8, if !(stack[-2] - stack[-1] i< 0x20) label_22D4: // Incoming jump from 0x22D3, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @22D7 memory[0x00:0x00] } 22D4 60 PUSH1 0x00 22D6 80 DUP1 22D7 FD *REVERT // Stack delta = +0 // Outputs[1] { @22D7 revert(memory[0x00:0x00]); } // Block terminates label_22D8: // Incoming jump from 0x22D3, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @22D9 stack[-2] // @22DA msg.data[stack[-2]:stack[-2] + 0x20] // } 22D8 5B JUMPDEST 22D9 81 DUP2 22DA 35 CALLDATALOAD 22DB 60 PUSH1 0x01 22DD 60 PUSH1 0x01 22DF 60 PUSH1 0x40 22E1 1B SHL 22E2 03 SUB 22E3 81 DUP2 22E4 11 GT 22E5 15 ISZERO 22E6 61 PUSH2 0x22ee 22E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @22DA stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x22ee, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_22EA: // Incoming jump from 0x22E9, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @22ED memory[0x00:0x00] } 22EA 60 PUSH1 0x00 22EC 80 DUP1 22ED FD *REVERT // Stack delta = +0 // Outputs[1] { @22ED revert(memory[0x00:0x00]); } // Block terminates label_22EE: // Incoming jump from 0x22E9, if !(msg.data[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @22EF stack[-3] // @22F0 stack[-1] // @22F5 stack[-4] // } 22EE 5B JUMPDEST 22EF 82 DUP3 22F0 01 ADD 22F1 60 PUSH1 0x1f 22F3 81 DUP2 22F4 01 ADD 22F5 84 DUP5 22F6 13 SGT 22F7 61 PUSH2 0x22ff 22FA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @22F0 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x22ff, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_22FB: // Incoming jump from 0x22FA, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[1] { @22FE memory[0x00:0x00] } 22FB 60 PUSH1 0x00 22FD 80 DUP1 22FE FD *REVERT // Stack delta = +0 // Outputs[1] { @22FE revert(memory[0x00:0x00]); } // Block terminates label_22FF: // Incoming jump from 0x22FA, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @2303 stack[-4] // @2304 stack[-1] // @2305 msg.data[stack[-1]:stack[-1] + 0x20] // } 22FF 5B JUMPDEST 2300 61 PUSH2 0x0d0f 2303 84 DUP5 2304 82 DUP3 2305 35 CALLDATALOAD 2306 60 PUSH1 0x20 2308 84 DUP5 2309 01 ADD 230A 61 PUSH2 0x1fb1 230D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2300 stack[0] = 0x0d0f // @2303 stack[1] = stack[-4] // @2305 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @2309 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x1fb1, returns to 0x0D0F label_230E: // Incoming call from 0x063E, returns to 0x0256 // Inputs[2] // { // @2311 stack[-1] // @2317 stack[-2] // } 230E 5B JUMPDEST 230F 60 PUSH1 0x80 2311 81 DUP2 2312 01 ADD 2313 61 PUSH2 0x0761 2316 82 DUP3 2317 84 DUP5 2318 61 PUSH2 0x2121 231B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2312 stack[0] = stack[-1] + 0x80 // @2313 stack[1] = 0x0761 // @2316 stack[2] = stack[-1] // @2317 stack[3] = stack[-2] // } // Block ends with call to 0x2121, returns to 0x0761 label_231C: // Incoming call from 0x06D8, returns to 0x06D9 // Inputs[2] // { // @2325 stack[-1] // @2326 stack[-2] // } 231C 5B JUMPDEST 231D 60 PUSH1 0x00 231F 80 DUP1 2320 60 PUSH1 0x00 2322 80 DUP1 2323 60 PUSH1 0x60 2325 85 DUP6 2326 87 DUP8 2327 03 SUB 2328 12 SLT 2329 15 ISZERO 232A 61 PUSH2 0x2332 232D 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @231D stack[0] = 0x00 // @231F stack[1] = 0x00 // @2320 stack[2] = 0x00 // @2322 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2332, if !(stack[-2] - stack[-1] i< 0x60) label_232E: // Incoming jump from 0x232D, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @2331 memory[0x00:0x00] } 232E 60 PUSH1 0x00 2330 80 DUP1 2331 FD *REVERT // Stack delta = +0 // Outputs[1] { @2331 revert(memory[0x00:0x00]); } // Block terminates label_2332: // Incoming jump from 0x232D, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[6] // { // @2333 stack[-5] // @2334 msg.data[stack[-5]:stack[-5] + 0x20] // @2335 stack[-4] // @233B msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @233C stack[-3] // @2342 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 2332 5B JUMPDEST 2333 84 DUP5 2334 35 CALLDATALOAD 2335 93 SWAP4 2336 50 POP 2337 60 PUSH1 0x20 2339 85 DUP6 233A 01 ADD 233B 35 CALLDATALOAD 233C 92 SWAP3 233D 50 POP 233E 60 PUSH1 0x40 2340 85 DUP6 2341 01 ADD 2342 35 CALLDATALOAD 2343 60 PUSH1 0x01 2345 60 PUSH1 0x01 2347 60 PUSH1 0x40 2349 1B SHL 234A 03 SUB 234B 81 DUP2 234C 11 GT 234D 15 ISZERO 234E 61 PUSH2 0x2356 2351 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @2335 stack[-4] = msg.data[stack[-5]:stack[-5] + 0x20] // @233C stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @2342 stack[0] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with conditional jump to 0x2356, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) label_2352: // Incoming jump from 0x2351, if not !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[1] { @2355 memory[0x00:0x00] } 2352 60 PUSH1 0x00 2354 80 DUP1 2355 FD *REVERT // Stack delta = +0 // Outputs[1] { @2355 revert(memory[0x00:0x00]); } // Block terminates label_2356: // Incoming jump from 0x2351, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @235A stack[-7] // @235B stack[-1] // @235C stack[-6] // } 2356 5B JUMPDEST 2357 61 PUSH2 0x2362 235A 87 DUP8 235B 82 DUP3 235C 88 DUP9 235D 01 ADD 235E 61 PUSH2 0x209c 2361 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2357 stack[0] = 0x2362 // @235A stack[1] = stack[-7] // @235D stack[2] = stack[-6] + stack[-1] // } // Block ends with call to 0x209c, returns to 0x2362 label_2362: // Incoming return from call to 0x209C at 0x2361 // Inputs[7] // { // @2363 stack[-1] // @2363 stack[-7] // @2364 stack[-10] // @2365 stack[-6] // @2366 stack[-9] // @2368 stack[-8] // @2368 stack[-2] // } 2362 5B JUMPDEST 2363 95 SWAP6 2364 98 SWAP9 2365 94 SWAP5 2366 97 SWAP8 2367 50 POP 2368 95 SWAP6 2369 50 POP 236A 50 POP 236B 50 POP 236C 50 POP 236D 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @2363 stack[-7] = stack[-1] // @2364 stack[-10] = stack[-7] // @2366 stack[-9] = stack[-6] // @2368 stack[-8] = stack[-2] // } // Block ends with unconditional jump to stack[-10] label_236E: // Incoming call from 0x06F8, returns to 0x06F9 // Inputs[2] // { // @2374 stack[-1] // @2375 stack[-2] // } 236E 5B JUMPDEST 236F 60 PUSH1 0x00 2371 80 DUP1 2372 60 PUSH1 0x40 2374 83 DUP4 2375 85 DUP6 2376 03 SUB 2377 12 SLT 2378 15 ISZERO 2379 61 PUSH2 0x2381 237C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @236F stack[0] = 0x00 // @2371 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2381, if !(stack[-2] - stack[-1] i< 0x40) label_237D: // Incoming jump from 0x237C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2380 memory[0x00:0x00] } 237D 60 PUSH1 0x00 237F 80 DUP1 2380 FD *REVERT // Stack delta = +0 // Outputs[1] { @2380 revert(memory[0x00:0x00]); } // Block terminates label_2381: // Incoming jump from 0x237C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2385 stack[-3] } 2381 5B JUMPDEST 2382 61 PUSH2 0x238a 2385 83 DUP4 2386 61 PUSH2 0x1e35 2389 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2382 stack[0] = 0x238a // @2385 stack[1] = stack[-3] // } // Block ends with call to 0x1e35, returns to 0x238A label_238A: // Incoming return from call to 0x1E35 at 0x2389 // Inputs[3] // { // @238B stack[-3] // @238B stack[-1] // @2392 stack[-4] // } 238A 5B JUMPDEST 238B 91 SWAP2 238C 50 POP 238D 61 PUSH2 0x2398 2390 60 PUSH1 0x20 2392 84 DUP5 2393 01 ADD 2394 61 PUSH2 0x1e35 2397 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @238B stack[-3] = stack[-1] // @238D stack[-1] = 0x2398 // @2393 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x1e35, returns to 0x2398 label_2398: // Incoming return from call to 0x1E35 at 0x2397 // Inputs[6] // { // @2399 stack[-1] // @2399 stack[-2] // @239B stack[-5] // @239D stack[-3] // @239D stack[-6] // @239E stack[-4] // } 2398 5B JUMPDEST 2399 90 SWAP1 239A 50 POP 239B 92 SWAP3 239C 50 POP 239D 92 SWAP3 239E 90 SWAP1 239F 50 POP 23A0 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @239B stack[-5] = stack[-1] // @239D stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_23A1: // Incoming call from 0x1D36, returns to 0x078C // Incoming call from 0x0D25, returns to 0x078C // Incoming call from 0x078B, returns to 0x078C // Incoming call from 0x07B7, returns to 0x07B8 // Incoming call from 0x24C2, returns to 0x24C3 // Inputs[1] { @23A4 stack[-1] } 23A1 5B JUMPDEST 23A2 60 PUSH1 0x01 23A4 81 DUP2 23A5 81 DUP2 23A6 1C SHR 23A7 90 SWAP1 23A8 82 DUP3 23A9 16 AND 23AA 80 DUP1 23AB 61 PUSH2 0x23b5 23AE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23A7 stack[0] = stack[-1] >> 0x01 // @23A9 stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x23b5, if stack[-1] & 0x01 label_23AF: // Incoming jump from 0x23AE, if not stack[-1] & 0x01 // Inputs[2] // { // @23B1 stack[-2] // @23BA stack[-1] // } 23AF 60 PUSH1 0x7f 23B1 82 DUP3 23B2 16 AND 23B3 91 SWAP2 23B4 50 POP 23B5 5B JUMPDEST 23B6 60 PUSH1 0x20 23B8 82 DUP3 23B9 10 LT 23BA 81 DUP2 23BB 03 SUB 23BC 61 PUSH2 0x23d5 23BF 57 *JUMPI // Stack delta = +0 // Outputs[1] { @23B3 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x23d5, if stack[-1] - (stack[-2] & 0x7f < 0x20) label_23C0: // Incoming jump from 0x23BF, if not stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x23BF, if not stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[1] { @23D4 memory[0x00:0x24] } 23C0 63 PUSH4 0x4e487b71 23C5 60 PUSH1 0xe0 23C7 1B SHL 23C8 60 PUSH1 0x00 23CA 52 MSTORE 23CB 60 PUSH1 0x22 23CD 60 PUSH1 0x04 23CF 52 MSTORE 23D0 60 PUSH1 0x24 23D2 60 PUSH1 0x00 23D4 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @23CA memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @23CF memory[0x04:0x24] = 0x22 // @23D4 revert(memory[0x00:0x24]); // } // Block terminates label_23D5: // Incoming jump from 0x23BF, if stack[-1] - (stack[-2] < 0x20) // Incoming jump from 0x23BF, if stack[-1] - (stack[-2] & 0x7f < 0x20) // Inputs[3] // { // @23D7 stack[-4] // @23D7 stack[-2] // @23D8 stack[-3] // } 23D5 5B JUMPDEST 23D6 50 POP 23D7 91 SWAP2 23D8 90 SWAP1 23D9 50 POP 23DA 56 *JUMP // Stack delta = -3 // Outputs[1] { @23D7 stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_23DB: // Incoming jump from 0x2455 // Incoming jump from 0x26CC // Incoming jump from 0x2420 // Incoming jump from 0x25F6 // Incoming jump from 0x2409 // Inputs[1] { @23F0 memory[0x00:0x24] } 23DB 5B JUMPDEST 23DC 63 PUSH4 0x4e487b71 23E1 60 PUSH1 0xe0 23E3 1B SHL 23E4 60 PUSH1 0x00 23E6 52 MSTORE 23E7 60 PUSH1 0x11 23E9 60 PUSH1 0x04 23EB 52 MSTORE 23EC 60 PUSH1 0x24 23EE 60 PUSH1 0x00 23F0 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @23E6 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @23EB memory[0x04:0x24] = 0x11 // @23F0 revert(memory[0x00:0x24]); // } // Block terminates label_23F1: // Incoming call from 0x08D9, returns to 0x08DA // Incoming call from 0x0910, returns to 0x0911 // Inputs[2] // { // @23F4 stack[-1] // @23F7 stack[-2] // } 23F1 5B JUMPDEST 23F2 60 PUSH1 0xff 23F4 81 DUP2 23F5 81 DUP2 23F6 16 AND 23F7 83 DUP4 23F8 82 DUP3 23F9 16 AND 23FA 01 ADD 23FB 90 SWAP1 23FC 81 DUP2 23FD 11 GT 23FE 15 ISZERO 23FF 61 PUSH2 0x0761 2402 57 *JUMPI // Stack delta = +1 // Outputs[1] { @23FB stack[0] = (0xff & stack[-2]) + (0xff & stack[-1]) } // Block ends with conditional jump to 0x0761, if !((0xff & stack[-2]) + (0xff & stack[-1]) > 0xff) label_2403: // Incoming jump from 0x2402, if not !((0xff & stack[-2]) + (0xff & stack[-1]) > 0xff) 2403 61 PUSH2 0x0761 2406 61 PUSH2 0x23db 2409 56 *JUMP // Stack delta = +1 // Outputs[1] { @2403 stack[0] = 0x0761 } // Block ends with unconditional jump to 0x23db label_240A: // Incoming call from 0x1B25, returns to 0x1B26 // Incoming call from 0x0B12, returns to 0x0B13 // Incoming call from 0x0B12, returns to 0x0B13 // Inputs[2] // { // @240B stack[-1] // @240C stack[-2] // } 240A 5B JUMPDEST 240B 80 DUP1 240C 82 DUP3 240D 02 MUL 240E 81 DUP2 240F 15 ISZERO 2410 82 DUP3 2411 82 DUP3 2412 04 DIV 2413 84 DUP5 2414 14 EQ 2415 17 OR 2416 61 PUSH2 0x0761 2419 57 *JUMPI // Stack delta = +1 // Outputs[1] { @240D stack[0] = stack[-2] * stack[-1] } // Block ends with conditional jump to 0x0761, if (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] label_241A: // Incoming jump from 0x2419, if not (stack[-2] == (stack[-2] * stack[-1]) / stack[-1]) | !stack[-1] 241A 61 PUSH2 0x0761 241D 61 PUSH2 0x23db 2420 56 *JUMP // Stack delta = +1 // Outputs[1] { @241A stack[0] = 0x0761 } // Block ends with unconditional jump to 0x23db label_2421: // Incoming call from 0x0B1C, returns to 0x0B1D // Inputs[1] { @2424 stack[-2] } 2421 5B JUMPDEST 2422 60 PUSH1 0x00 2424 82 DUP3 2425 61 PUSH2 0x243e 2428 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2422 stack[0] = 0x00 } // Block ends with conditional jump to 0x243e, if stack[-2] label_2429: // Incoming jump from 0x2428, if not stack[-2] // Inputs[1] { @243D memory[0x00:0x24] } 2429 63 PUSH4 0x4e487b71 242E 60 PUSH1 0xe0 2430 1B SHL 2431 60 PUSH1 0x00 2433 52 MSTORE 2434 60 PUSH1 0x12 2436 60 PUSH1 0x04 2438 52 MSTORE 2439 60 PUSH1 0x24 243B 60 PUSH1 0x00 243D FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2433 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2438 memory[0x04:0x24] = 0x12 // @243D revert(memory[0x00:0x24]); // } // Block terminates label_243E: // Incoming jump from 0x2428, if stack[-2] // Inputs[3] // { // @2440 stack[-3] // @2440 stack[-2] // @2441 stack[-4] // } 243E 5B JUMPDEST 243F 50 POP 2440 04 DIV 2441 90 SWAP1 2442 56 *JUMP // Stack delta = -3 // Outputs[1] { @2441 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2443: // Incoming call from 0x1A58, returns to 0x1A59 // Incoming call from 0x1A58, returns to 0x1A59 // Incoming call from 0x1B83, returns to 0x1B84 // Inputs[2] // { // @2444 stack[-1] // @2445 stack[-2] // } 2443 5B JUMPDEST 2444 80 DUP1 2445 82 DUP3 2446 01 ADD 2447 80 DUP1 2448 82 DUP3 2449 11 GT 244A 15 ISZERO 244B 61 PUSH2 0x0761 244E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2446 stack[0] = stack[-2] + stack[-1] } // Block ends with conditional jump to 0x0761, if !(stack[-1] > stack[-2] + stack[-1]) label_244F: // Incoming jump from 0x244E, if not !(stack[-1] > stack[-2] + stack[-1]) 244F 61 PUSH2 0x0761 2452 61 PUSH2 0x23db 2455 56 *JUMP // Stack delta = +1 // Outputs[1] { @244F stack[0] = 0x0761 } // Block ends with unconditional jump to 0x23db label_2456: // Incoming jump from 0x24C8 // Inputs[1] { @2459 stack[-2] } 2456 5B JUMPDEST 2457 60 PUSH1 0x1f 2459 82 DUP3 245A 11 GT 245B 15 ISZERO 245C 61 PUSH2 0x085e 245F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x085e, if !(stack[-2] > 0x1f) label_2460: // Incoming jump from 0x245F, if not !(stack[-2] > 0x1f) // Inputs[3] // { // @2462 stack[-1] // @2468 memory[0x00:0x20] // @246B stack[-3] // } 2460 60 PUSH1 0x00 2462 81 DUP2 2463 81 DUP2 2464 52 MSTORE 2465 60 PUSH1 0x20 2467 81 DUP2 2468 20 SHA3 2469 60 PUSH1 0x1f 246B 85 DUP6 246C 01 ADD 246D 60 PUSH1 0x05 246F 1C SHR 2470 81 DUP2 2471 01 ADD 2472 60 PUSH1 0x20 2474 86 DUP7 2475 10 LT 2476 15 ISZERO 2477 61 PUSH2 0x247d 247A 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @2460 stack[0] = 0x00 // @2464 memory[0x00:0x20] = stack[-1] // @2468 stack[1] = keccak256(memory[0x00:0x20]) // @2471 stack[2] = keccak256(memory[0x00:0x20]) + (stack[-3] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x247d, if !(stack[-3] < 0x20) label_247B: // Incoming jump from 0x247A, if not !(stack[-3] < 0x20) // Inputs[2] // { // @247C stack[-2] // @2480 stack[-5] // } 247B 50 POP 247C 80 DUP1 247D 5B JUMPDEST 247E 60 PUSH1 0x1f 2480 85 DUP6 2481 01 ADD 2482 60 PUSH1 0x05 2484 1C SHR 2485 82 DUP3 2486 01 ADD 2487 91 SWAP2 2488 50 POP 2489 5B JUMPDEST 248A 81 DUP2 248B 81 DUP2 248C 10 LT 248D 15 ISZERO 248E 61 PUSH2 0x1ab9 2491 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @247C stack[-1] = stack[-2] // @2487 stack[-2] = stack[-2] + (stack[-5] + 0x1f >> 0x05) // } // Block ends with conditional jump to 0x1ab9, if !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) label_2492: // Incoming jump from 0x2491, if not !(stack[-1] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x2491, if not !(stack[-2] < stack[-2] + (stack[-5] + 0x1f >> 0x05)) // Incoming jump from 0x2491, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @2492 stack[-3] // @2493 stack[-1] // } 2492 82 DUP3 2493 81 DUP2 2494 55 SSTORE 2495 60 PUSH1 0x01 2497 01 ADD 2498 61 PUSH2 0x2489 249B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @2494 storage[stack[-1]] = stack[-3] // @2497 stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x2489 label_249C: // Incoming call from 0x0DCA, returns to 0x0779 // Incoming call from 0x0F12, returns to 0x0779 // Inputs[2] // { // @249D stack[-2] // @249E memory[stack[-2]:stack[-2] + 0x20] // } 249C 5B JUMPDEST 249D 81 DUP2 249E 51 MLOAD 249F 60 PUSH1 0x01 24A1 60 PUSH1 0x01 24A3 60 PUSH1 0x40 24A5 1B SHL 24A6 03 SUB 24A7 81 DUP2 24A8 11 GT 24A9 15 ISZERO 24AA 61 PUSH2 0x24b5 24AD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @249E stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x24b5, if !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) label_24AE: // Incoming jump from 0x24AD, if not !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) 24AE 61 PUSH2 0x24b5 24B1 61 PUSH2 0x1f9b 24B4 56 *JUMP // Stack delta = +1 // Outputs[1] { @24AE stack[0] = 0x24b5 } // Block ends with unconditional jump to 0x1f9b label_24B5: // Incoming jump from 0x24AD, if !(memory[stack[-2]:stack[-2] + 0x20] > (0x01 << 0x40) - 0x01) // Inputs[3] // { // @24B9 stack[-1] // @24BD stack[-2] // @24BE storage[stack[-2]] // } 24B5 5B JUMPDEST 24B6 61 PUSH2 0x24c9 24B9 81 DUP2 24BA 61 PUSH2 0x24c3 24BD 84 DUP5 24BE 54 SLOAD 24BF 61 PUSH2 0x23a1 24C2 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @24B6 stack[0] = 0x24c9 // @24B9 stack[1] = stack[-1] // @24BA stack[2] = 0x24c3 // @24BE stack[3] = storage[stack[-2]] // } // Block ends with call to 0x23a1, returns to 0x24C3 label_24C3: // Incoming return from call to 0x23A1 at 0x24C2 // Inputs[1] { @24C4 stack[-5] } 24C3 5B JUMPDEST 24C4 84 DUP5 24C5 61 PUSH2 0x2456 24C8 56 *JUMP // Stack delta = +1 // Outputs[1] { @24C4 stack[0] = stack[-5] } // Block ends with unconditional jump to 0x2456 label_24C9: // Incoming return from call to 0x24C3 at 0x24C2 // Inputs[1] { @24CF stack[-1] } 24C9 5B JUMPDEST 24CA 60 PUSH1 0x20 24CC 80 DUP1 24CD 60 PUSH1 0x1f 24CF 83 DUP4 24D0 11 GT 24D1 60 PUSH1 0x01 24D3 81 DUP2 24D4 14 EQ 24D5 61 PUSH2 0x24fe 24D8 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @24CA stack[0] = 0x20 // @24CC stack[1] = 0x20 // @24D0 stack[2] = stack[-1] > 0x1f // } // Block ends with conditional jump to 0x24fe, if (stack[-1] > 0x1f) == 0x01 label_24D9: // Incoming jump from 0x24D8, if not (stack[-1] > 0x1f) == 0x01 // Inputs[1] { @24DB stack[-4] } 24D9 60 PUSH1 0x00 24DB 84 DUP5 24DC 15 ISZERO 24DD 61 PUSH2 0x24e6 24E0 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24D9 stack[0] = 0x00 } // Block ends with conditional jump to 0x24e6, if !stack[-4] label_24E1: // Incoming jump from 0x24E0, if not !stack[-4] // Inputs[5] // { // @24E2 stack[-7] // @24E3 stack[-4] // @24E5 memory[stack[-4] + stack[-7]:stack[-4] + stack[-7] + 0x20] // @24EC stack[-5] // @24F8 stack[-6] // } 24E1 50 POP 24E2 85 DUP6 24E3 83 DUP4 24E4 01 ADD 24E5 51 MLOAD 24E6 5B JUMPDEST 24E7 60 PUSH1 0x00 24E9 19 NOT 24EA 60 PUSH1 0x03 24EC 86 DUP7 24ED 90 SWAP1 24EE 1B SHL 24EF 1C SHR 24F0 19 NOT 24F1 16 AND 24F2 60 PUSH1 0x01 24F4 85 DUP6 24F5 90 SWAP1 24F6 1B SHL 24F7 17 OR 24F8 85 DUP6 24F9 55 SSTORE 24FA 61 PUSH2 0x1ab9 24FD 56 *JUMP // Stack delta = -1 // Outputs[1] { @24F9 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 0x1ab9 label_24FE: // Incoming jump from 0x24D8, if (stack[-1] > 0x1f) == 0x01 // Inputs[3] // { // @2501 stack[-5] // @2507 memory[0x00:0x20] // @250B stack[-4] // } 24FE 5B JUMPDEST 24FF 60 PUSH1 0x00 2501 85 DUP6 2502 81 DUP2 2503 52 MSTORE 2504 60 PUSH1 0x20 2506 81 DUP2 2507 20 SHA3 2508 60 PUSH1 0x1f 250A 19 NOT 250B 86 DUP7 250C 16 AND 250D 91 SWAP2 250E 5B JUMPDEST 250F 82 DUP3 2510 81 DUP2 2511 10 LT 2512 15 ISZERO 2513 61 PUSH2 0x252d 2516 57 *JUMPI // Stack delta = +3 // Outputs[4] // { // @2503 memory[0x00:0x20] = stack[-5] // @2507 stack[1] = keccak256(memory[0x00:0x20]) // @250D stack[0] = stack[-4] & ~0x1f // @250D stack[2] = 0x00 // } // Block ends with conditional jump to 0x252d, if !(0x00 < stack[-4] & ~0x1f) label_2517: // Incoming jump from 0x2516, if not !(0x00 < stack[-4] & ~0x1f) // Incoming jump from 0x2516, if not !(stack[-1] < stack[-3]) // Inputs[6] // { // @2517 stack[-9] // @2518 stack[-6] // @251A memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @251B stack[-2] // @251D stack[-1] // @251E stack[-5] // } 2517 88 DUP9 2518 86 DUP7 2519 01 ADD 251A 51 MLOAD 251B 82 DUP3 251C 55 SSTORE 251D 94 SWAP5 251E 84 DUP5 251F 01 ADD 2520 94 SWAP5 2521 60 PUSH1 0x01 2523 90 SWAP1 2524 91 SWAP2 2525 01 ADD 2526 90 SWAP1 2527 84 DUP5 2528 01 ADD 2529 61 PUSH2 0x250e 252C 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @251C storage[stack[-2]] = memory[stack[-6] + stack[-9]:stack[-6] + stack[-9] + 0x20] // @2520 stack[-6] = stack[-5] + stack[-6] // @2526 stack[-2] = stack[-2] + 0x01 // @2528 stack[-1] = stack[-5] + stack[-1] // } // Block ends with unconditional jump to 0x250e label_252D: // Incoming jump from 0x2516, if !(0x00 < stack[-4] & ~0x1f) // Incoming jump from 0x2516, if !(stack[-1] < stack[-3]) // Inputs[2] // { // @252F stack[-7] // @2530 stack[-3] // } 252D 5B JUMPDEST 252E 50 POP 252F 85 DUP6 2530 82 DUP3 2531 10 LT 2532 15 ISZERO 2533 61 PUSH2 0x254b 2536 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x254b, if !(stack[-3] < stack[-7]) label_2537: // Incoming jump from 0x2536, if not !(stack[-3] < stack[-7]) // Inputs[7] // { // @2537 stack[-8] // @2538 stack[-5] // @253A memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @2540 stack[-6] // @2549 stack[-1] // @2557 stack[-7] // @255A stack[-9] // } 2537 87 DUP8 2538 85 DUP6 2539 01 ADD 253A 51 MLOAD 253B 60 PUSH1 0x00 253D 19 NOT 253E 60 PUSH1 0x03 2540 88 DUP9 2541 90 SWAP1 2542 1B SHL 2543 60 PUSH1 0xf8 2545 16 AND 2546 1C SHR 2547 19 NOT 2548 16 AND 2549 81 DUP2 254A 55 SSTORE 254B 5B JUMPDEST 254C 50 POP 254D 50 POP 254E 50 POP 254F 50 POP 2550 50 POP 2551 60 PUSH1 0x01 2553 90 SWAP1 2554 81 DUP2 2555 1B SHL 2556 01 ADD 2557 90 SWAP1 2558 55 SSTORE 2559 50 POP 255A 56 *JUMP // Stack delta = -9 // Outputs[2] // { // @254A storage[stack[-1]] = ~(~0x00 >> (0xf8 & (stack[-6] << 0x03))) & memory[stack[-5] + stack[-8]:stack[-5] + stack[-8] + 0x20] // @2558 storage[stack[-7]] = (stack[-6] << 0x01) + 0x01 // } // Block ends with unconditional jump to stack[-9] 255B 5B JUMPDEST 255C 60 PUSH1 0x00 255E 83 DUP4 255F 51 MLOAD 2560 60 PUSH1 0x20 2562 61 PUSH2 0x256e 2565 82 DUP3 2566 85 DUP6 2567 83 DUP4 2568 89 DUP10 2569 01 ADD 256A 61 PUSH2 0x1e8f 256D 56 *JUMP 256E 5B JUMPDEST 256F 81 DUP2 2570 84 DUP5 2571 01 ADD 2572 91 SWAP2 2573 50 POP 2574 60 PUSH1 0x00 2576 85 DUP6 2577 54 SLOAD 2578 61 PUSH2 0x2580 257B 81 DUP2 257C 61 PUSH2 0x23a1 257F 56 *JUMP 2580 5B JUMPDEST 2581 60 PUSH1 0x01 2583 82 DUP3 2584 81 DUP2 2585 16 AND 2586 80 DUP1 2587 15 ISZERO 2588 61 PUSH2 0x2598 258B 57 *JUMPI 258C 60 PUSH1 0x01 258E 81 DUP2 258F 14 EQ 2590 61 PUSH2 0x25ad 2593 57 *JUMPI 2594 61 PUSH2 0x25d9 2597 56 *JUMP 2598 5B JUMPDEST 2599 60 PUSH1 0xff 259B 19 NOT 259C 84 DUP5 259D 16 AND 259E 87 DUP8 259F 52 MSTORE 25A0 82 DUP3 25A1 15 ISZERO 25A2 15 ISZERO 25A3 83 DUP4 25A4 02 MUL 25A5 87 DUP8 25A6 01 ADD 25A7 94 SWAP5 25A8 50 POP 25A9 61 PUSH2 0x25d9 25AC 56 *JUMP 25AD 5B JUMPDEST 25AE 89 DUP10 25AF 60 PUSH1 0x00 25B1 52 MSTORE 25B2 85 DUP6 25B3 60 PUSH1 0x00 25B5 20 SHA3 25B6 60 PUSH1 0x00 25B8 5B JUMPDEST 25B9 84 DUP5 25BA 81 DUP2 25BB 10 LT 25BC 15 ISZERO 25BD 61 PUSH2 0x25d1 25C0 57 *JUMPI 25C1 81 DUP2 25C2 54 SLOAD 25C3 89 DUP10 25C4 82 DUP3 25C5 01 ADD 25C6 52 MSTORE 25C7 90 SWAP1 25C8 83 DUP4 25C9 01 ADD 25CA 90 SWAP1 25CB 87 DUP8 25CC 01 ADD 25CD 61 PUSH2 0x25b8 25D0 56 *JUMP 25D1 5B JUMPDEST 25D2 50 POP 25D3 50 POP 25D4 82 DUP3 25D5 87 DUP8 25D6 01 ADD 25D7 94 SWAP5 25D8 50 POP 25D9 5B JUMPDEST 25DA 50 POP 25DB 92 SWAP3 25DC 99 SWAP10 25DD 98 SWAP9 25DE 50 POP 25DF 50 POP 25E0 50 POP 25E1 50 POP 25E2 50 POP 25E3 50 POP 25E4 50 POP 25E5 50 POP 25E6 50 POP 25E7 56 *JUMP label_25E8: // Incoming call from 0x12CC, returns to 0x12CD // Inputs[1] { @25EB stack[-1] } 25E8 5B JUMPDEST 25E9 60 PUSH1 0x00 25EB 81 DUP2 25EC 61 PUSH2 0x25f7 25EF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25E9 stack[0] = 0x00 } // Block ends with conditional jump to 0x25f7, if stack[-1] label_25F0: // Incoming jump from 0x25EF, if not stack[-1] 25F0 61 PUSH2 0x25f7 25F3 61 PUSH2 0x23db 25F6 56 *JUMP // Stack delta = +1 // Outputs[1] { @25F0 stack[0] = 0x25f7 } // Block ends with unconditional jump to 0x23db label_25F7: // Incoming jump from 0x25EF, if stack[-1] // Inputs[2] // { // @25FC stack[-2] // @25FD stack[-3] // } 25F7 5B JUMPDEST 25F8 50 POP 25F9 60 PUSH1 0x00 25FB 19 NOT 25FC 01 ADD 25FD 90 SWAP1 25FE 56 *JUMP // Stack delta = -2 // Outputs[1] { @25FD stack[-3] = ~0x00 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_25FF: // Incoming jump from 0x137B // Inputs[2] // { // @2604 stack[-1] // @2605 stack[-2] // } 25FF 5B JUMPDEST 2600 60 PUSH1 0x00 2602 60 PUSH1 0x20 2604 82 DUP3 2605 84 DUP5 2606 03 SUB 2607 12 SLT 2608 15 ISZERO 2609 61 PUSH2 0x2611 260C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2600 stack[0] = 0x00 } // Block ends with conditional jump to 0x2611, if !(stack[-2] - stack[-1] i< 0x20) label_260D: // Incoming jump from 0x260C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2610 memory[0x00:0x00] } 260D 60 PUSH1 0x00 260F 80 DUP1 2610 FD *REVERT // Stack delta = +0 // Outputs[1] { @2610 revert(memory[0x00:0x00]); } // Block terminates label_2611: // Incoming jump from 0x260C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2612 stack[-2] // @2613 memory[stack[-2]:stack[-2] + 0x20] // } 2611 5B JUMPDEST 2612 81 DUP2 2613 51 MLOAD 2614 61 PUSH2 0x1961 2617 81 DUP2 2618 61 PUSH2 0x2225 261B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2613 stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @2614 stack[1] = 0x1961 // @2617 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x2225, returns to 0x1961 261C 5B JUMPDEST 261D 60 PUSH1 0x00 261F 83 DUP4 2620 51 MLOAD 2621 61 PUSH2 0x262e 2624 81 DUP2 2625 84 DUP5 2626 60 PUSH1 0x20 2628 88 DUP9 2629 01 ADD 262A 61 PUSH2 0x1e8f 262D 56 *JUMP 262E 5B JUMPDEST 262F 83 DUP4 2630 51 MLOAD 2631 90 SWAP1 2632 83 DUP4 2633 01 ADD 2634 90 SWAP1 2635 61 PUSH2 0x2642 2638 81 DUP2 2639 83 DUP4 263A 60 PUSH1 0x20 263C 88 DUP9 263D 01 ADD 263E 61 PUSH2 0x1e8f 2641 56 *JUMP 2642 5B JUMPDEST 2643 01 ADD 2644 94 SWAP5 2645 93 SWAP4 2646 50 POP 2647 50 POP 2648 50 POP 2649 50 POP 264A 56 *JUMP 264B 5B JUMPDEST 264C 60 PUSH1 0x01 264E 60 PUSH1 0x01 2650 60 PUSH1 0xa0 2652 1B SHL 2653 03 SUB 2654 85 DUP6 2655 81 DUP2 2656 16 AND 2657 82 DUP3 2658 52 MSTORE 2659 84 DUP5 265A 16 AND 265B 60 PUSH1 0x20 265D 82 DUP3 265E 01 ADD 265F 52 MSTORE 2660 60 PUSH1 0x40 2662 81 DUP2 2663 01 ADD 2664 83 DUP4 2665 90 SWAP1 2666 52 MSTORE 2667 60 PUSH1 0x80 2669 60 PUSH1 0x60 266B 82 DUP3 266C 01 ADD 266D 81 DUP2 266E 90 SWAP1 266F 52 MSTORE 2670 60 PUSH1 0x00 2672 90 SWAP1 2673 61 PUSH2 0x267e 2676 90 SWAP1 2677 83 DUP4 2678 01 ADD 2679 84 DUP5 267A 61 PUSH2 0x1eb3 267D 56 *JUMP 267E 5B JUMPDEST 267F 96 SWAP7 2680 95 SWAP6 2681 50 POP 2682 50 POP 2683 50 POP 2684 50 POP 2685 50 POP 2686 50 POP 2687 56 *JUMP 2688 5B JUMPDEST 2689 60 PUSH1 0x00 268B 60 PUSH1 0x20 268D 82 DUP3 268E 84 DUP5 268F 03 SUB 2690 12 SLT 2691 15 ISZERO 2692 61 PUSH2 0x269a 2695 57 *JUMPI 2696 60 PUSH1 0x00 2698 80 DUP1 2699 FD *REVERT 269A 5B JUMPDEST 269B 81 DUP2 269C 51 MLOAD 269D 61 PUSH2 0x1961 26A0 81 DUP2 26A1 61 PUSH2 0x1e02 26A4 56 *JUMP label_26A5: // Incoming jump from 0x1DB4 // Inputs[1] { @26BA memory[0x00:0x24] } 26A5 5B JUMPDEST 26A6 63 PUSH4 0x4e487b71 26AB 60 PUSH1 0xe0 26AD 1B SHL 26AE 60 PUSH1 0x00 26B0 52 MSTORE 26B1 60 PUSH1 0x32 26B3 60 PUSH1 0x04 26B5 52 MSTORE 26B6 60 PUSH1 0x24 26B8 60 PUSH1 0x00 26BA FD *REVERT // Stack delta = +0 // Outputs[3] // { // @26B0 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @26B5 memory[0x04:0x24] = 0x32 // @26BA revert(memory[0x00:0x24]); // } // Block terminates label_26BB: // Incoming call from 0x1DCD, returns to 0x1DCE // Inputs[1] { @26C0 stack[-1] } 26BB 5B JUMPDEST 26BC 60 PUSH1 0x00 26BE 60 PUSH1 0x01 26C0 82 DUP3 26C1 01 ADD 26C2 61 PUSH2 0x26cd 26C5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @26BC stack[0] = 0x00 } // Block ends with conditional jump to 0x26cd, if stack[-1] + 0x01 label_26C6: // Incoming jump from 0x26C5, if not stack[-1] + 0x01 26C6 61 PUSH2 0x26cd 26C9 61 PUSH2 0x23db 26CC 56 *JUMP // Stack delta = +1 // Outputs[1] { @26C6 stack[0] = 0x26cd } // Block ends with unconditional jump to 0x23db label_26CD: // Incoming jump from 0x26C5, if stack[-1] + 0x01 // Inputs[2] // { // @26D1 stack[-2] // @26D2 stack[-3] // } 26CD 5B JUMPDEST 26CE 50 POP 26CF 60 PUSH1 0x01 26D1 01 ADD 26D2 90 SWAP1 26D3 56 *JUMP // Stack delta = -2 // Outputs[1] { @26D2 stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] 26D4 FE *ASSERT 26D5 DD DD 26D6 F2 CALLCODE 26D7 52 MSTORE 26D8 AD AD 26D9 1B SHL 26DA E2 E2 26DB C8 C8 26DC 9B SWAP12 26DD 69 PUSH10 0xc2b068fc378daa952ba7 26E8 F1 CALL 26E9 63 PUSH4 0xc4a11628 26EE F5 CREATE2 26EF 5A GAS 26F0 4D 4D 26F1 F5 CREATE2 26F2 23 23 26F3 B3 B3 26F4 EF EF 26F5 A2 LOG2 26F6 64 PUSH5 0x6970667358 26FC 22 22 26FD 12 SLT 26FE 20 SHA3 26FF 15 ISZERO 2700 8B DUP12 2701 8B DUP12 2702 0B SIGNEXTEND 2703 D8 D8 2704 5C 5C 2705 F1 CALL 2706 12 SLT 2707 D8 D8 2708 E1 E1 2709 9B SWAP12 270A A8 A8 270B EA EA 270C 31 BALANCE 270D B4 B4 270E 4B 4B 270F 10 LT 2710 8A DUP11 2711 31 BALANCE 2712 2D 2D 2713 C1 C1 2714 7C PUSH29 0x66915b2576fec1983b4964736f6c63430008120033